docs: all 5 @ignitionai/* packages live on npm — remove callouts

All three remaining backend packages published at v0.1.0:
- @ignitionai/backend-onnx
- @ignitionai/storage
- @ignitionai/environments

Docs updated post-publish:

- Quickstart: replaced the inlined 60-line CartPoleEnv with a clean
  import from @ignitionai/environments. Back to the original
  7-line promise in the page title.
- Landing hero + components/quickstart.tsx: install command now
  lists all three published install-time packages (core,
  backend-tfjs, environments).
- index.mdx intro: updated install section to explain the three
  packages and note that environments is optional if you want to
  write your own TrainingEnv from scratch.
- how-it-works/{index,backend-onnx,storage}.mdx: import lines go
  back to '@ignitionai/environments' instead of the './cartpole-env'
  workaround. Added a note about the fifth package on the monorepo
  map page.
- how-it-works/backend-onnx.mdx + storage.mdx + tutorials/onnx-unity.mdx:
  removed the "publish pending" <Callout> blocks. ONNX tutorial
  prereq updated to `npm install @ignitionai/backend-onnx`.
- research.md R3 + roadmap Phase 1.4: marked all 5 packages as ✓
  published, noted the post-publish doc cleanup.

package.json autocorrect: `npm pkg fix` normalized the repository.url
on @ignitionai/environments during publish. Kept the normalized form.

Build: 23 routes, 0 errors.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: salim4n

packages/environments/package.json

@@ -4,7 +4,9 @@
   "description": "Reference training environments for IgnitionAI — GridWorld, CartPole, MountainCar",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "vitest run"
@@ -21,6 +23,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/IgnitionAI/ignition"
+    "url": "git+https://github.com/IgnitionAI/ignition.git"
   }
 }

packages/web/components/hero.tsx

@@ -56,7 +56,7 @@ export default function Hero() {
             <div className="mt-12" data-aos="fade-down" data-aos-delay="600">
               <div className="inline-flex items-center gap-2 bg-slate-900/60 border border-slate-800 rounded-lg px-4 py-2 font-mono text-sm text-slate-300">
                 <span className="text-indigo-400">$</span>
-                <span>npm install @ignitionai/core @ignitionai/backend-tfjs</span>
+                <span>npm install @ignitionai/core @ignitionai/backend-tfjs @ignitionai/environments</span>
               </div>
             </div>
 

packages/web/components/quickstart.tsx

@@ -1,6 +1,6 @@
 export default function QuickStart() {
   const code = `import { IgnitionEnvTFJS } from '@ignitionai/backend-tfjs';
-import { CartPoleEnv } from '@ignitionai/core';
+import { CartPoleEnv } from '@ignitionai/environments';
 
 const cartpole = new CartPoleEnv();
 const env = new IgnitionEnvTFJS(cartpole);

packages/web/content/how-it-works/backend-onnx.mdx

@@ -9,12 +9,6 @@ description: The ONNX bridge — train in the browser with TF.js, export to ONNX
 
 **Source**: [`packages/backend-onnx/src/`](https://github.com/IgnitionAI/ignition/tree/main/packages/backend-onnx/src) on GitHub.
 
-import { Callout } from 'nextra/components'
-
-<Callout type="warning">
-**Publish status**: `@ignitionai/backend-onnx` ships with the monorepo but is not yet on the public npm registry. Build it from source with `pnpm --filter @ignitionai/backend-onnx build`. A public release is tracked in the roadmap.
-</Callout>
-
 ## What "Train → Deploy" means in practice
 
 The pipeline has four stages:
@@ -47,7 +41,7 @@ Nothing new here — you're using `@ignitionai/backend-tfjs` exactly as describe
 
 ```ts filename="train.ts"
 import { IgnitionEnvTFJS } from '@ignitionai/backend-tfjs'
-import { CartPoleEnv } from './cartpole-env'   // from the Quickstart
+import { CartPoleEnv } from '@ignitionai/environments'
 
 const env = new IgnitionEnvTFJS(new CartPoleEnv())
 env.train('dqn')
@@ -135,7 +129,7 @@ Three lines. The model runs at full speed on WebGPU where available, and because
 ```ts filename="play.ts"
 import { IgnitionEnv } from '@ignitionai/core'
 import { OnnxAgent } from '@ignitionai/backend-onnx'
-import { CartPoleEnv } from './cartpole-env'   // from the Quickstart
+import { CartPoleEnv } from '@ignitionai/environments'
 
 const env = new IgnitionEnv(new CartPoleEnv())
 const agent = new OnnxAgent({ modelPath: './model.onnx', actionSize: 2 })

packages/web/content/how-it-works/index.mdx

@@ -24,18 +24,17 @@ When you write:
 
 ```ts
 import { IgnitionEnvTFJS } from '@ignitionai/backend-tfjs'
-import { CartPoleEnv } from './cartpole-env'  // the env you defined yourself
+import { CartPoleEnv } from '@ignitionai/environments'
 
 const env = new IgnitionEnvTFJS(new CartPoleEnv())
 env.train('dqn')
 ```
 
-(The `CartPoleEnv` class comes from your own project — see the [Quickstart](/docs/quickstart) for a complete copy-paste definition.)
-
 Here's what happens across the packages:
 
-1. **`@ignitionai/core`** provides the `TrainingEnv` interface contract and the `IgnitionEnv` base class with the generic training loop.
-2. **`@ignitionai/backend-tfjs`** provides `IgnitionEnvTFJS`, which extends `IgnitionEnv` and registers the TF.js-backed `DQNAgent`, `PPOAgent`, and `QTableAgent` as the available algorithm factories.
+1. **`@ignitionai/environments`** ships `CartPoleEnv` as a built-in `TrainingEnv` (also `GridWorldEnv` and `MountainCarEnv`).
+2. **`@ignitionai/core`** provides the `TrainingEnv` interface contract and the `IgnitionEnv` base class with the generic training loop.
+3. **`@ignitionai/backend-tfjs`** provides `IgnitionEnvTFJS`, which extends `IgnitionEnv` and registers the TF.js-backed `DQNAgent`, `PPOAgent`, and `QTableAgent` as the available algorithm factories.
 3. When you call `env.train('dqn')`, `core`'s `IgnitionEnv.train()` method is invoked. It looks up the `'dqn'` factory (registered by the TFJS backend), deduces `inputSize` from `observe()` and `actionSize` from `actions`, calls the factory, and starts the training loop.
 4. The training loop lives entirely in `core`. It doesn't know anything about TensorFlow.js — it just calls the generic `AgentInterface` methods (`getAction`, `remember`, `train`) on whatever agent the backend registered.
 
@@ -50,6 +49,8 @@ Each subsequent page in this section does an annotated walkthrough of one packag
 3. **[backend-onnx](/docs/how-it-works/backend-onnx)** — the deploy pipeline.
 4. **[storage](/docs/how-it-works/storage)** — persistence and HF Hub integration.
 
+(There's a fifth package, [`@ignitionai/environments`](https://www.npmjs.com/package/@ignitionai/environments), that ships the built-in envs used in the docs. It's a thin wrapper around the `TrainingEnv` interface and doesn't need its own page — read [any env's source](https://github.com/IgnitionAI/ignition/tree/main/packages/environments/src) to see how the interface is actually implemented.)
+
 ---
 
 Previous: **[← Q-Table](/docs/algorithms/q-table)** · Next: **[@ignitionai/core →](/docs/how-it-works/core)**

packages/web/content/how-it-works/storage.mdx

@@ -9,12 +9,6 @@ description: Persistent model storage for IgnitionAI agents — save and load tr
 
 **Source**: [`packages/storage/src/`](https://github.com/IgnitionAI/ignition/tree/main/packages/storage/src) on GitHub.
 
-import { Callout } from 'nextra/components'
-
-<Callout type="warning">
-**Publish status**: `@ignitionai/storage` ships with the monorepo but is not yet on the public npm registry. Build it from source with `pnpm --filter @ignitionai/storage build`. A public release is tracked in the roadmap.
-</Callout>
-
 ## Public API surface
 
 | Export | Kind | Purpose |
@@ -61,7 +55,7 @@ export HF_REPO_ID=your-user/my-rl-agent
 
 ```ts filename="save-and-load.ts"
 import { IgnitionEnvTFJS } from '@ignitionai/backend-tfjs'
-import { CartPoleEnv } from './cartpole-env'   // from the Quickstart
+import { CartPoleEnv } from '@ignitionai/environments'
 import { HuggingFaceProvider, parseHFConfig } from '@ignitionai/storage'
 
 // 1. Train an agent

packages/web/content/index.mdx

@@ -45,10 +45,10 @@ None of these is strictly better than the others — they target different audie
 ## Install
 
 ```bash
-npm install @ignitionai/core @ignitionai/backend-tfjs
+npm install @ignitionai/core @ignitionai/backend-tfjs @ignitionai/environments
 ```
 
-Two packages. `core` contains the training loop and interfaces; `backend-tfjs` provides the TensorFlow.js agents (DQN, PPO, Q-Table).
+Three packages to get started. `core` contains the training loop and the `TrainingEnv` interface. `backend-tfjs` provides the TensorFlow.js agents (DQN, PPO, Q-Table). `environments` ships ready-made envs (`CartPoleEnv`, `GridWorldEnv`, `MountainCarEnv`) so you can train something in 30 seconds. Drop `environments` from the list if you'd rather write your own env from scratch — the [tutorials](/docs/tutorials) walk through that exact flow.
 
 ## Where to go next
 

packages/web/content/quickstart.mdx

@@ -5,99 +5,25 @@ description: Train your first RL agent in the browser in under 10 lines of code.
 
 # Quickstart
 
-By the end of this page, you will have trained a reinforcement-learning agent to balance a pole in the browser. The entire setup is 9 lines of code. You will not configure a neural network, pick hyperparameters, or write a training loop.
+By the end of this page, you will have trained a reinforcement-learning agent to balance a pole in the browser. The entire setup is 7 lines of code. You will not configure a neural network, pick hyperparameters, or write a training loop.
 
 ## Install
 
 ```bash
-npm install @ignitionai/core @ignitionai/backend-tfjs
+npm install @ignitionai/core @ignitionai/backend-tfjs @ignitionai/environments
 ```
 
 You need:
 - Node.js 20 or later
 - A bundler that can serve ES modules (Vite, Next.js, Webpack 5, etc.)
 
-## Step 1 — Define the environment
-
-IgnitionAI doesn't ship built-in envs on npm yet — you write yours, and the framework learns to play it. Here's a complete cart-pole env. Copy it into `src/cartpole-env.ts`:
-
-```ts filename="src/cartpole-env.ts"
-import type { TrainingEnv } from '@ignitionai/core'
-
-const GRAVITY = 9.8
-const CART_MASS = 1.0
-const POLE_MASS = 0.1
-const TOTAL_MASS = CART_MASS + POLE_MASS
-const POLE_HALF_LENGTH = 0.5
-const POLE_MASS_LENGTH = POLE_MASS * POLE_HALF_LENGTH
-const FORCE_MAG = 10.0
-const DT = 0.02
-const THETA_LIMIT = (12 * Math.PI) / 180
-const X_LIMIT = 2.4
-const MAX_STEPS = 500
-
-export class CartPoleEnv implements TrainingEnv {
-  actions = ['push_left', 'push_right']
-  private x = 0
-  private xDot = 0
-  private theta = 0
-  private thetaDot = 0
-  private stepCount = 0
-
-  constructor() { this.reset() }
-
-  observe(): number[] {
-    return [this.x, this.xDot, this.theta, this.thetaDot]
-  }
-
-  step(action: number | number[]): void {
-    const a = typeof action === 'number' ? action : action[0]
-    const force = a === 1 ? FORCE_MAG : -FORCE_MAG
-    const cosTheta = Math.cos(this.theta)
-    const sinTheta = Math.sin(this.theta)
-    const temp = (force + POLE_MASS_LENGTH * this.thetaDot ** 2 * sinTheta) / TOTAL_MASS
-    const thetaAcc =
-      (GRAVITY * sinTheta - cosTheta * temp) /
-      (POLE_HALF_LENGTH * (4 / 3 - (POLE_MASS * cosTheta ** 2) / TOTAL_MASS))
-    const xAcc = temp - (POLE_MASS_LENGTH * thetaAcc * cosTheta) / TOTAL_MASS
-    this.x += DT * this.xDot
-    this.xDot += DT * xAcc
-    this.theta += DT * this.thetaDot
-    this.thetaDot += DT * thetaAcc
-    this.stepCount++
-  }
-
-  reward(): number {
-    return this.done() ? 0 : 1
-  }
-
-  done(): boolean {
-    return (
-      Math.abs(this.theta) > THETA_LIMIT ||
-      Math.abs(this.x) > X_LIMIT ||
-      this.stepCount >= MAX_STEPS
-    )
-  }
-
-  reset(): void {
-    this.x = (Math.random() - 0.5) * 0.1
-    this.xDot = (Math.random() - 0.5) * 0.1
-    this.theta = (Math.random() - 0.5) * 0.1
-    this.thetaDot = (Math.random() - 0.5) * 0.1
-    this.stepCount = 0
-  }
-}
-```
-
-This is roughly 60 lines, most of which is physics. The RL-relevant surface area is the six `TrainingEnv` methods at the top — that's your contract with the framework.
+## Train a CartPole agent
 
-## Step 2 — Train it
-
-Now create `src/main.ts`:
+Create `src/main.ts` and paste this in exactly:
 
 ```ts filename="src/main.ts"
 import { IgnitionEnvTFJS } from '@ignitionai/backend-tfjs'
-import { CartPoleEnv } from './cartpole-env'
+import { CartPoleEnv } from '@ignitionai/environments'
 
 const env = new IgnitionEnvTFJS(new CartPoleEnv())
 
@@ -106,10 +32,12 @@ env.train('dqn')       // Zero config. It just works.
 // env.setSpeed(50)    // Turbo training — 50× faster.
 ```
 
-**Five lines.** That's the entire training setup. No neural network code, no hyperparameter tuning, no config files.
+**Seven lines.** That's the entire training setup. No neural network code, no hyperparameter tuning, no config files.
 
 Open the page in your browser, pop the devtools console, and you'll see reward logs scrolling as the agent learns. Within a few dozen seconds on most machines, the pole will start staying up.
 
+That's it. If you want to understand *how* to write your own `TrainingEnv` from scratch (instead of using the built-in `CartPoleEnv`), jump to the [GridWorld tutorial](/docs/tutorials/grid-world) — it walks through the full 5-method interface.
+
 ## What just happened
 
 Let's map each line of the example to a concept you'll see explained in more depth elsewhere in the docs.
@@ -118,9 +46,9 @@ Let's map each line of the example to a concept you'll see explained in more dep
 
 `IgnitionEnvTFJS` is the **training environment** that runs on TensorFlow.js. It owns the training loop, the agent instance, and the TF.js backend selection. You'll see its internals in [How it works → backend-tfjs](/docs/how-it-works/backend-tfjs).
 
-### Line 2 — `import { CartPoleEnv } from './cartpole-env'`
+### Line 2 — `import { CartPoleEnv } from '@ignitionai/environments'`
 
-`CartPoleEnv` is the `TrainingEnv` you just wrote. It describes the classic cart-pole world: a cart that can move left or right, a pole balanced on top, Euler-integrated physics, and a done condition when the pole tips past 12° or the cart leaves the track. The `TrainingEnv` interface is what you'll implement for your own worlds. See [How it works → core](/docs/how-it-works/core) for the full interface.
+`CartPoleEnv` is a built-in `TrainingEnv` that describes the classic cart-pole world: a cart that can move left or right, a pole balanced on top, Euler-integrated physics, and a done condition when the pole tips past 12° or the cart leaves the track. The `@ignitionai/environments` package also ships `GridWorldEnv` and `MountainCarEnv`. The `TrainingEnv` interface is what you'll implement for your own worlds — see [How it works → core](/docs/how-it-works/core).
 
 ### Line 4 — `new IgnitionEnvTFJS(new CartPoleEnv())`
 

packages/web/content/tutorials/onnx-unity.mdx

@@ -9,18 +9,12 @@ This tutorial is the entire IgnitionAI deploy story in one page. You'll train a
 
 Estimated time: **50–75 minutes**. Most of it is installing Python and Unity if you don't already have them.
 
-import { Callout } from 'nextra/components'
-
-<Callout type="warning">
-**Publish status**: `@ignitionai/backend-onnx` ships with the monorepo but is not yet on the public npm registry. For now, clone the [IgnitionAI repo](https://github.com/IgnitionAI/ignition) and run `pnpm --filter @ignitionai/backend-onnx build`, then link it into your project with `pnpm pack` + `npm install ./ignitionai-backend-onnx-0.1.0.tgz`. A public release is tracked in the roadmap.
-</Callout>
-
 ## Prerequisites
 
 - You've done the [Quickstart](/docs/quickstart) and trained a CartPole policy. You have `src/cartpole-env.ts` + `src/main.ts` working.
 - **Python 3.9+** with `pip`. Check with `python --version`.
 - **Unity 2022.3 LTS or newer** with the **Sentis** package. If you don't have Unity, this tutorial doubles as a reason to install it.
-- Built `@ignitionai/backend-onnx` locally (per the callout above).
+- `@ignitionai/backend-onnx` installed: `npm install @ignitionai/backend-onnx`.
 
 ## Stage 1 — Train the model
 

roadmap.md

@@ -53,13 +53,14 @@
 - [ ] Social card image for Twitter/OG (not yet done)
 - [ ] Hero GIF of Car Circuit demo in README (README currently text-only)
 
-### 1.4 npm publish v0.1.0
+### 1.4 npm publish v0.1.0 ✅
 - [x] `@ignitionai/core` published at 0.1.0
 - [x] `@ignitionai/backend-tfjs` published at 0.1.0
-- [ ] `@ignitionai/backend-onnx` — built locally, not yet on npm (docs carry "publish pending" callout)
-- [ ] `@ignitionai/storage` — built locally, not yet on npm (docs carry "publish pending" callout)
-- [ ] `@ignitionai/environments` — CartPoleEnv / GridWorldEnv / MountainCarEnv not yet on npm. Quickstart inlines CartPoleEnv to avoid depending on an unpublished package.
-- [ ] Tag v0.1.0 in git after all four @ignitionai/* backend packages are live
+- [x] `@ignitionai/backend-onnx` published at 0.1.0
+- [x] `@ignitionai/storage` published at 0.1.0
+- [x] `@ignitionai/environments` published at 0.1.0 (ships `CartPoleEnv`, `GridWorldEnv`, `MountainCarEnv`)
+- [x] Docs updated post-publish: "publish pending" callouts removed, Quickstart imports `CartPoleEnv` from `@ignitionai/environments` directly
+- [ ] Tag v0.1.0 in git once the post-publish commit is merged
 
 **Known framework bug surfaced during docs**: `backend-tfjs/src/defaults.ts:3-13` disagrees with `agents/dqn.ts:43` on `targetUpdateFrequency` (100 vs 1000). Docs cite the runtime value (1000). Needs a cleanup commit in the framework after merge.