@netforge/template-idle 0.0.0-stage → 0.2.0

package/AGENTS.md

@@ -0,0 +1,73 @@
+# Extending BRINEWORKS
+
+BRINEWORKS is the idle template of the Net Forge game engine. The template already has the works, the production chain, buying and levelling, raking, tending, the contract, the shift clock, netcode, rendering, earn and the store. You change the game by changing declarations. Read `llms.txt` for every field, and `llms-full.txt` for the complete worked example.
+
+## The one file to edit
+
+- `src/game.ts` is the whole game. Change declarations in place.
+- `src/names.json`, next to it, holds the title and every label. Plants go in `"weapons"` (`{ name, line }`), and `"enemies"` stays empty.
+- Everything else (`src/manifest.ts`, `src/store.ts`, `src/autopilot.ts`, `client/`, `test/`, `scripts/`) is template machinery. Do not edit it.
+
+## Imports
+
+`src/game.ts` imports only from `@netforge/engine`. The shipped game uses:
+
+```ts
+import { earn, game, plant, saltFlat, store, upgrade } from "@netforge/engine";
+```
+
+## Declarations
+
+- `game({ template: "idle", style, places, players: { prefab, max } })`, with `max` at most 8.
+- `saltFlat({ shift, tend, start, rake: { salt, cooldown }, brinePerSalt, saltPerCrystal, packEvery, contract: { crystals } })`, exactly one.
+- `plant(id, { model, kind: "pump" | "pan" | "kiln", cost, growth, rate })`, 1 to 8 of them. The bar shows plants in declaration order (keys 1 to 8).
+- `upgrade(id, { stat, step, maxLevel })` with stat `might` (plant output), `haste` (raking speed) or `amount` (salt a rake) only.
+- `earn.rule(id, { when, n, pay, oncePer: "run" })`. Events: `salt.packed`, `crystal.cut`, `crystal.shipped`, `plant.built`, `plant.upgraded` and `contract.filled`.
+- `earn.stake({ min, max, multiple })`, exactly one, on one top-level line.
+- `store.sku(id, { coins, grants? })`.
+
+## Rules the build enforces (the anti-farm rules)
+
+- Ids are lower_snake_case.
+- Every game declares at least one `earn.rule` and exactly one `earn.stake`. `"stake"` is reserved.
+- Plants include at least one `pump`, one `pan` and one `kiln`.
+- A shift is 600 to 3600 seconds. Every earn rule is `oncePer: "run"`.
+- `tend` is at most 300 seconds, so a works nobody tends stops.
+- No earn rule may pay sooner than 180 seconds into a fresh works, even with perfect play or raking as fast as the cooldown allows. If a change pays sooner, raise `packEvery` or the rule's `n`, or slow raking.
+- No `weapon()` or `prefab()`.
+- An earn rule must fire within about 4 minutes of 4-player play.
+- Asset ids are library ids such as `"style.lowpoly.barrel"`, never URLs or paths. Keep `game({ style })` as the creator picked it.
+- Keep the SKUs the client is wired to at their prices: `bellows`, `long_rake`, `quick_hands`, `skin_saltwhite`, `skin_rust` and `brass_bellows`.
+
+## Validate
+
+- With the MCP server (`npx -y @netforge/mcp`), call `netforge_validate_game` on `src/game.ts`. It returns one actionable line per problem, including the measured first payout when it is too early.
+- In this package, run the tests with vitest: `test/harness.test.ts` and `test/store.test.ts`.
+
+## Playtest
+
+- With the MCP server, call `netforge_run_playtest`.
+- In code, import the game module and run the headless harness:
+
+```ts
+import { engine } from "@netforge/engine";
+import "./src/game.js";
+
+const report = await engine.test.run({ ticks: 30 * 240, bots: 4, seed: 1 });
+console.log(report.kills, report.earned, report.rules?.checks);
+```
+
+The report has crates packed (as kills), earn by rule, softlock, ms per tick and the genre's checks (the farming bounds) under `rules.checks`.
+
+## Play locally
+
+In a folder with `netnet.json` (`{"template":"idle"}`) and `src/game.ts`, with `@netforge/kit-play` and `@netforge/engine` installed, run `npx kit-play`. It opens http://127.0.0.1:4663 with play money. The MCP tool `netforge_play_locally` gives the same steps.
+
+## Do not
+
+- Do not write renderers, netcode, physics or bot logic. The template has them.
+- Do not add offline production, wall-clock timers or client-reported numbers.
+- Do not reference assets by URL or file path.
+- Do not import anything other than `@netforge/engine` in `src/game.ts`.
+- Do not edit `client/`, `src/manifest.ts`, `src/store.ts` or `src/autopilot.ts`.
+- Do not rename or reprice the SKUs the client is wired to.

package/CLAUDE.md

@@ -0,0 +1,11 @@
+# CLAUDE.md
+
+This package is BRINEWORKS, a Net Forge game template. Read AGENTS.md before changing this game. It lists the declarations this genre has, the rules the build enforces, and how to validate, playtest and play the game locally.
+
+The five hard rules:
+
+1. Edit only src/game.ts (and src/names.json for the labels players read).
+2. Import only from @netforge/engine.
+3. Ids are lower_snake_case.
+4. Declare at least one earn.rule and exactly one earn.stake.
+5. Never write renderers, netcode, physics or bot AI, and never reference assets by URL or file path (use library ids such as "style.lowpoly.frog").

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NetNet Capital Management
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,27 @@
+@netforge/template-idle (BRINEWORKS)
+Copyright (c) 2026 NetNet Capital Management
+
+An original game. No names, characters, maps, models, sounds or code from
+any other game or franchise.
+
+Art and sound
+- Models come from the per-style asset library
+  (@netforge/asset-library): CC0 1.0 models by Kenney and
+  Quaternius (Space Kit, Nature Kit, ships), each pack listed with its
+  source URL and licence verification in that package's NOTICE and
+  manifest/packs.json. The files are fetched and built, never committed
+  here; the build copies only the models this game uses.
+- Fallback shapes (@netforge/tabletop stage.ts) are generated from three.js
+  primitives; all textures are drawn on a canvas at load; sounds are the
+  library's CC0 samples with WebAudio synth fallbacks.
+
+Dependencies (unmodified, via npm)
+- three.js 0.186.1 (https://github.com/mrdoob/three.js), MIT.
+- @netforge/engine and @netforge/engine-sim (this repository);
+  see their NOTICE files (bitECS MPL-2.0, Rapier Apache-2.0, Colyseus MIT,
+  zod MIT).
+
+Patterns (ideas only)
+- The idle and incremental genre's general mechanics (producers bought
+  and levelled with rising costs, a click action, a production chain).
+  Mechanics, not expression; no names, art or text were copied.

package/README.md

@@ -1,3 +1,87 @@
-# Temporary Holding Version
+# @netforge/template-idle
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A shared idle game template for Net Forge: a salt flat where up to eight players each run a works and fill one contract together (BRINEWORKS).
+
+A white salt flat under a hot sky. Pumps draw brine, pans boil it into salt, kilns cut crystals, and salt buys more plants. A barge on the canal takes crystals for a contract everyone fills together. A shift lasts fifteen minutes, and then a new one begins from nothing.
+
+## Install
+
+```sh
+npm install @netforge/template-idle
+```
+
+You rarely import this package directly. kit play (`@netforge/kit-play`) and the Net Forge MCP server use it to build and run a game whose `src/game.ts` you write.
+
+## Play it locally
+
+```sh
+mkdir -p my-game/src && cd my-game
+npm init -y && npm install @netforge/kit-play @netforge/engine @netforge/template-idle
+cp node_modules/@netforge/template-idle/src/game.ts src/
+echo '{"template":"idle"}' > netnet.json
+npx kit-play        # opens http://127.0.0.1:4663
+```
+
+Open the link in more tabs for more players. Coins are play money. Real-token earning, stakes and claims run only on the hosted Net Forge server.
+
+## Change the game
+
+Edit `src/game.ts` and run `npx kit-play` again. For example, make the hand pump cheaper to level for longer:
+
+```ts
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.1, rate: 3 });
+```
+
+Or lengthen the shift and enlarge the contract in `saltFlat({ ... })`:
+
+```ts
+shift: 1200,
+contract: { crystals: 120 },
+```
+
+Keep the first payout at least 180 s into a fresh works. The build measures it and fails with the number if a change pays sooner.
+
+## Why it cannot be farmed
+
+- Production runs only in the room's sim, on its ticks, for players in the room. There is no wall clock, no offline accrual and no client-reported number.
+- A works stalls two minutes after its last tend (rake, buy, ship), so an idle tab makes nothing.
+- Raking has a cooldown, so mashing adds nothing.
+- Earn rules pay once a run. A seat that leaves and rejoins starts a fresh works from 20 kg of salt. The genre's gate check simulates a fresh works with perfect play and with pure raking: the first payout comes 199 s in (the floor is 180 s). With full shifts the four rules pay at most 80 coins a shift.
+- One earning seat per wallet, and the run replays from its inputs for the referee.
+
+## Files
+
+| Path | What |
+|---|---|
+| `src/game.ts` | The game, as declarations only. This is the file you edit. |
+| `src/manifest.ts` | Loads the game; `idleAdapter()` for the room host and the client (up to 8 seats). |
+| `src/store.ts` | Coin prices the client is wired to. |
+| `src/autopilot.ts` | The autopilot the browser's `?autopilot=1` and the measure script use. |
+| `client/` | The browser client, drawn with `@netforge/tabletop`. |
+| `test/` | Playtest bots through `engine.test.run`, and the store test. |
+| `llms.txt`, `llms-full.txt` | How to change the game, for agents. |
+
+## Controls
+
+Space rakes (or click your plot), 1 to 5 buy a plant, S ships crystals.
+
+## For AI agents
+
+Read `AGENTS.md` and `llms.txt` before editing. The Net Forge MCP server gives a coding agent the templates, the API and a playtest loop:
+
+```sh
+npx -y @netforge/mcp
+```
+
+The package is `@netforge/mcp` and its bin is `netforge-mcp`. Its tools are `netforge_list_templates`, `netforge_create_game`, `netforge_explain_api`, `netforge_search_docs`, `netforge_validate_game`, `netforge_run_playtest` and `netforge_play_locally`.
+
+To set up a coding agent in a game project, run `npx netforge setup agent`. It writes AGENTS.md, CLAUDE.md, Cursor rules and `.mcp.json` into the project. In Claude Code you can also add the server directly with `claude mcp add netforge -- npx -y @netforge/mcp`.
+
+## Docs
+
+- https://forge.netnet.capital/docs/templates/idle
+- `llms.txt` and `llms-full.txt` in this package. The full file includes the complete `src/game.ts` and the validate and playtest steps.
+
+## License
+
+MIT. See LICENSE and NOTICE.

package/client/decor.ts

@@ -0,0 +1,5 @@
+/** Library models the scene draws on its own: the barge, crystals, the flat's edge. Copied into ./library in every art style. */
+export const BARGE_MODEL = "style.lowpoly.cargo_ship";
+export const CRYSTAL_MODEL = "style.lowpoly.crystal";
+export const EDGE_MODELS = ["style.lowpoly.rock_small", "style.lowpoly.cactus", "style.lowpoly.rock_tall", "style.lowpoly.tent"] as const;
+export const SCENE_MODELS: readonly string[] = [BARGE_MODEL, CRYSTAL_MODEL, ...EDGE_MODELS];

package/client/index.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, user-scalable=no" />
+    <title>Brineworks</title>
+  </head>
+  <body>
+    <script type="module" src="./main.ts"></script>
+  </body>
+</html>

package/client/main.ts

@@ -0,0 +1,402 @@
+/**
+ * BRINEWORKS client: your works is one of eight plots on a shared salt
+ * flat. Rake (Space or the big button) to bring in salt by hand and keep the
+ * works tended, buy and level plants from the bar, ship crystals to the
+ * barge. The room makes every litre, kilo and crystal on its own clock;
+ * your foreman (the cursor) is predicted, so pointing never waits.
+ *
+ * URL parameters: see @netforge/tabletop boot.ts.
+ */
+import { BoxGeometry, CircleGeometry, Color, ConeGeometry, DoubleSide, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial, PlaneGeometry, RingGeometry } from "three/webgpu";
+import type { InterpolatedEntity } from "@netforge/engine/net";
+import { IdleAct, plantSpot, plotCenter, PLOT, RF, RulesKind, UNITS, IDLE_SEATS } from "@netforge/engine/rules";
+import type { RulesInput } from "@netforge/engine/rules";
+import { bootBoard, cssColor, type Placed } from "@netforge/tabletop";
+import { COSMETICS, GAME_VERSION, idleAdapter, idleGame, idleManifest, PLACE, TEMPLATE } from "../src/manifest.js";
+import { BRINE_COIN } from "../src/store.js";
+import { idleAutopilot, type IdleView } from "../src/autopilot.js";
+import { BARGE_MODEL, CRYSTAL_MODEL, EDGE_MODELS } from "./decor.js";
+import { KEEPER_COLORS, RULE_NAMES, SKU_NAMES, TITLE, UPGRADE_NAMES, WEAPON_NAMES } from "./names.js";
+
+
+const genre = idleGame();
+const g = genre.game;
+const manifest = idleManifest();
+const FLAT_W = PLOT.cols * (PLOT.w + PLOT.gapX) + 4;
+const FLAT_H = 2 * PLOT.d + PLOT.gapZ + 4;
+const FINISH = [0xd8c39a, 0xf4f1ea, 0xb5552e];
+const fmt = (n: number) => (n >= 10_000 ? `${(n / 1000).toFixed(1)}t` : `${Math.floor(n).toLocaleString("en-US")}`);
+const mmss = (s: number) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
+
+let lastView: IdleView | null = null;
+const autopilot = (tick: number): RulesInput | null => idleAutopilot(lastView, tick);
+
+async function main(): Promise<void> {
+  const app = await bootBoard({
+    adapter: idleAdapter(),
+    manifest,
+    template: TEMPLATE,
+    place: PLACE,
+    version: GAME_VERSION,
+    labels: { title: TITLE, rules: RULE_NAMES, skus: SKU_NAMES, upgrades: UPGRADE_NAMES, loading: "Opening the sluices", help: "Space rake · 1-5 buy a plant · S ship crystals · ` stats" },
+    theme: {
+      accent: "#2aa7d8",
+      gold: "#e8a33c",
+      ink: "#1d2a33",
+      dim: "#5d6f7b",
+      panel: "rgba(250, 247, 240, 0.9)",
+      bg: "#efe9dc",
+      font: '"Futura", "Century Gothic", "Trebuchet MS", system-ui, sans-serif',
+      display: '"Futura", "Century Gothic", system-ui, sans-serif',
+      radius: 2,
+    },
+    coin: BRINE_COIN,
+    cosmetics: COSMETICS,
+    swatch: (c) => `linear-gradient(135deg, ${cssColor(FINISH[c] ?? 0xd8c39a)}, #2a3a44)`,
+    ground: { w: FLAT_W, h: FLAT_H },
+    preset: "day",
+    theme3d: "desert",
+    groundColor: 0xe9e1cc,
+    pitch: 1.05,
+    autopilot,
+    soundKey: "brineworks:sound",
+  });
+  const { stage, hud, clock, sfx } = app;
+  sfx.define("rake", { wave: "noise", f0: 1800, f1: 600, ms: 90, gain: 0.35 }, { minGapMs: 60, voices: 3, pitchVar: 0.15 });
+  sfx.define("crate", { wave: "triangle", f0: 520, f1: 780, ms: 140, gain: 0.5 }, { minGapMs: 100, voices: 2, pitchVar: 0 });
+  sfx.define("ship", { wave: "sine", f0: 300, f1: 900, ms: 260, gain: 0.55 }, { minGapMs: 200, voices: 1, pitchVar: 0 });
+
+  // ---- The flat: plots, the canal and its barge, the edge of the pan.
+  const plotMat = (mine: boolean) => new MeshStandardMaterial({ color: mine ? 0xe6f6fb : 0xc9dde2, roughness: 0.35, metalness: 0.05, emissive: new Color(mine ? 0x2a6a80 : 0x0e2a33), emissiveIntensity: mine ? 0.35 : 0.15 });
+  const plots: Mesh[] = [];
+  for (let slot = 0; slot < IDLE_SEATS; slot++) {
+    const c = plotCenter(slot);
+    const m = new Mesh(new BoxGeometry(PLOT.w, 0.08, PLOT.d), plotMat(false));
+    m.position.set(c.x, stage.groundAt(c.x, c.z) + 0.04, c.z);
+    m.receiveShadow = true;
+    stage.add(m);
+    plots.push(m);
+    // Low berms around each plot.
+    for (const [dx, dz, w, d] of [
+      [0, -PLOT.d / 2, PLOT.w, 0.3],
+      [0, PLOT.d / 2, PLOT.w, 0.3],
+      [-PLOT.w / 2, 0, 0.3, PLOT.d],
+      [PLOT.w / 2, 0, 0.3, PLOT.d],
+    ] as const) {
+      const berm = new Mesh(new BoxGeometry(w, 0.28, d), new MeshStandardMaterial({ color: 0xc9bc9d, roughness: 1 }));
+      berm.position.set(c.x + dx, m.position.y + 0.12, c.z + dz);
+      stage.add(berm);
+    }
+  }
+  const canal = new Mesh(new PlaneGeometry(FLAT_W + 30, PLOT.gapZ * 0.8), new MeshStandardMaterial({ color: 0x3b9cc4, roughness: 0.2, metalness: 0.1, emissive: new Color(0x0a3448) }));
+  canal.rotation.x = -Math.PI / 2;
+  canal.position.y = 0.02;
+  stage.add(canal);
+  const barge = stage.model(BARGE_MODEL, 2.2, 0x8a6a4a, 7);
+  barge.root.position.set(0, 0.1, 0);
+  barge.root.rotation.y = Math.PI / 2;
+  stage.add(barge.root);
+  const hold = new Mesh(new BoxGeometry(1, 1, 1), new MeshStandardMaterial({ color: 0xbfe8ff, emissive: new Color(0x4fb6e0), emissiveIntensity: 0.6, roughness: 0.3 }));
+  hold.position.set(0, 1.2, 0);
+  hold.scale.set(4, 0.01, 1.6);
+  stage.add(hold);
+  let seed = 5;
+  const rnd = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
+  for (const id of EDGE_MODELS) {
+    const at: { x: number; z: number; yaw: number; s: number }[] = [];
+    for (let i = 0; i < 9; i++) {
+      const side = rnd() < 0.5 ? -1 : 1;
+      at.push({ x: (rnd() - 0.5) * (FLAT_W + 20), z: side * (FLAT_H / 2 + 2 + rnd() * 8), yaw: rnd() * 6.3, s: 0.7 + rnd() * 0.6 });
+    }
+    const crowd = stage.crowd(id, id.endsWith("tent") ? 2.4 : 1.6, at.length, 0xb59a7a);
+    app.loop((_, now) => {
+      crowd.begin();
+      for (const p of at) crowd.push(p.x, stage.groundAt(p.x, p.z), p.z, p.yaw, 0, 0, 0, 0, p.s);
+      crowd.end(now / 1000);
+    });
+  }
+
+  // ---- Works: plant models, brine pools, salt piles, crystals; foremen.
+  const plantModels = new Map<number, { placed: Placed; level: number; type: number }>();
+  const piles = new Map<number, { pool: Mesh; pile: Mesh; crystals: Placed[]; salt: number }>();
+  const foremen = new Map<number, Group>();
+  const pileFor = (id: number) => {
+    let p = piles.get(id);
+    if (p) return p;
+    const pool = new Mesh(new CircleGeometry(1, 28), new MeshStandardMaterial({ color: 0x5fc3e8, roughness: 0.15, metalness: 0.1, transparent: true, opacity: 0.85 }));
+    pool.rotation.x = -Math.PI / 2;
+    const pile = new Mesh(new ConeGeometry(1, 1, 12), new MeshStandardMaterial({ color: 0xffffff, roughness: 0.6, emissive: new Color(0x404040) }));
+    stage.add(pool, pile);
+    p = { pool, pile, crystals: [], salt: 0 };
+    piles.set(id, p);
+    return p;
+  };
+
+  // ---- The bar: rake, plants, ship; the works meter.
+  const style = document.createElement("style");
+  style.textContent = `
+#bar { left: 50%; bottom: max(10px, env(safe-area-inset-bottom)); transform: translateX(-50%); display: flex; gap: 6px; align-items: stretch; }
+#bar button { pointer-events: auto; }
+#rake { width: 92px; font-weight: 900; letter-spacing: 0.12em; background: var(--accent); color: #fff; border: none; position: relative; overflow: hidden; }
+#rake i { position: absolute; left: 0; bottom: 0; height: 4px; background: rgba(255,255,255,0.8); }
+#bar .plant { width: min(118px, 17vw); padding: 6px 8px; text-align: left; display: grid; gap: 1px; }
+#bar .plant b { font-size: 12px; }
+#bar .plant span { font-size: 10px; color: var(--dim); }
+#bar .plant i { font-style: normal; color: var(--gold); font-weight: 800; font-size: 12px; }
+#bar .plant.poor { opacity: 0.55; }
+#bar .plant kbd { font: 700 10px ui-monospace, monospace; color: var(--accent); }
+#ship { width: 90px; font-weight: 800; }
+#meter { left: 50%; top: max(10px, env(safe-area-inset-top)); transform: translateX(-50%); width: min(380px, 46vw); text-align: center; font-size: 11px; letter-spacing: 0.14em; color: var(--dim); }
+#meter .row { display: flex; justify-content: space-between; margin-top: 4px; font-weight: 700; color: var(--ink); letter-spacing: 0.04em; font-size: 13px; }
+#meter .bar { height: 8px; background: rgba(0,0,0,0.12); border-radius: 2px; overflow: hidden; margin-top: 4px; }
+#meter .bar > i { display: block; height: 100%; background: linear-gradient(90deg, #2aa7d8, #8fe1ff); transform-origin: left; }
+#stall { left: 50%; top: 38%; transform: translate(-50%, -50%); font: 900 30px var(--display, inherit); letter-spacing: 0.18em; color: #b5552e; background: rgba(250,247,240,0.92); padding: 10px 18px; border: 2px solid #b5552e; display: none; }
+#stall.show { display: block; }
+.puff { position: fixed; z-index: 6; pointer-events: none; font: 800 14px var(--display, inherit); color: #e8a33c; text-shadow: 0 1px 0 #fff; transition: transform 700ms ease-out, opacity 700ms; }
+@media (max-width: 560px), (max-height: 500px) { #bar .plant span { display: none; } #bar .plant { width: 74px; padding: 4px 5px; } #bar .plant b { font-size: 10px; } #rake { width: 70px; } #ship { width: 64px; } }
+`;
+  document.head.append(style);
+  const bar = document.createElement("div");
+  bar.id = "bar";
+  bar.className = "hud";
+  document.body.append(bar);
+  const rakeBtn = document.createElement("button");
+  rakeBtn.id = "rake";
+  rakeBtn.innerHTML = "RAKE<i></i>";
+  bar.append(rakeBtn);
+  const cards = g.plants.map((p, i) => {
+    const c = document.createElement("button");
+    c.className = "plant";
+    c.innerHTML = `<kbd>${i + 1}</kbd><b></b><span></span><i></i>`;
+    (c.querySelector("b") as HTMLElement).textContent = WEAPON_NAMES[p.id]?.name ?? p.id;
+    c.addEventListener("click", () => buy(i));
+    bar.append(c);
+    return c;
+  });
+  const shipBtn = document.createElement("button");
+  shipBtn.id = "ship";
+  shipBtn.addEventListener("click", () => ship());
+  bar.append(shipBtn);
+  const meter = document.createElement("div");
+  meter.id = "meter";
+  meter.className = "hud";
+  meter.innerHTML = `CONTRACT<div class="bar"><i></i></div><div class="row"><span id="m-left"></span><span id="m-hold"></span></div>`;
+  document.body.append(meter);
+  const stall = document.createElement("div");
+  stall.id = "stall";
+  stall.className = "hud";
+  stall.textContent = "WORKS STOPPED · RAKE";
+  document.body.append(stall);
+
+  const rake = () => {
+    sfx.unlock();
+    if ((lastView?.rake ?? 1) > 0) return;
+    clock.act(IdleAct.Rake);
+    sfx.play("rake");
+    const c = plotCenter(lastView?.slot ?? 0);
+    stage.burst("dust", c.x + 4.6, 0.4, c.z + 3.4, 0xffffff, 8);
+    puff(`+${g.rakeSalt / 1000} kg`, c.x + 4.6, c.z + 3.4);
+  };
+  const buy = (i: number) => {
+    sfx.unlock();
+    const v = lastView;
+    if (!v?.costs || (v.salt ?? 0) < (v.costs[i] ?? Infinity)) {
+      hud.toast("Not enough salt");
+      return;
+    }
+    clock.act(IdleAct.Buy, i);
+    sfx.play("land");
+  };
+  const ship = () => {
+    const v = lastView;
+    if (!v || (v.crystals ?? 0) < 1 || v.filled) return;
+    clock.act(IdleAct.Ship, v.crystals ?? 1);
+    sfx.play("ship");
+    stage.burst("magic", 0, 1.5, 0, 0x8fe1ff, 20);
+  };
+  rakeBtn.addEventListener("click", rake);
+  addEventListener("keydown", (e) => {
+    if (e.code === "Space") {
+      e.preventDefault();
+      rake();
+    }
+    const n = Number(e.key);
+    if (n >= 1 && n <= g.plants.length) buy(n - 1);
+    if (e.code === "KeyS") ship();
+  });
+  // Clicking your own plot rakes too; pointing walks your foreman.
+  app.canvas.addEventListener("pointermove", (e) => {
+    const p = stage.pick(e.clientX, e.clientY, app.canvas.getBoundingClientRect());
+    if (p) clock.cursor(p.x, p.z);
+  });
+  app.canvas.addEventListener("pointerdown", (e) => {
+    const p = stage.pick(e.clientX, e.clientY, app.canvas.getBoundingClientRect());
+    if (!p) return;
+    clock.cursor(p.x, p.z);
+    const c = plotCenter(lastView?.slot ?? 0);
+    if (Math.abs(p.x - c.x) < PLOT.w / 2 && Math.abs(p.z - c.z) < PLOT.d / 2) rake();
+  });
+  function puff(text: string, x: number, z: number): void {
+    const s = stage.project(x, 1.5, z, app.canvas.clientWidth, app.canvas.clientHeight);
+    const el = document.createElement("div");
+    el.className = "puff";
+    el.textContent = text;
+    el.style.left = `${s.x}px`;
+    el.style.top = `${s.y}px`;
+    document.body.append(el);
+    requestAnimationFrame(() => {
+      el.style.transform = "translateY(-36px)";
+      el.style.opacity = "0";
+    });
+    setTimeout(() => el.remove(), 750);
+  }
+
+  let mySlot = -1;
+  let knownPacks = 0;
+  let knownFilled = false;
+  const m = (e: InterpolatedEntity, f: number) => (e.values[f] ?? 0) / UNITS;
+  app.loop((_dt, now) => {
+    const conn = app.conn();
+    const v = app.view() as unknown as IdleView | null;
+    lastView = v;
+    const view = conn.net.render(now);
+    const t = now / 1000;
+    if (v?.slot !== undefined && v.slot !== mySlot) {
+      const old = plots[mySlot];
+      if (old) old.material = plotMat(false);
+      mySlot = v.slot;
+      (plots[mySlot] as Mesh).material = plotMat(true);
+    }
+    const seenPlants = new Set<number>();
+    const seenPiles = new Set<number>();
+    for (const e of view.others) {
+      if (e.kind === RulesKind.Structure) {
+        seenPlants.add(e.id);
+        const type = Math.round(e.values[RF.type] ?? 0);
+        const level = Math.round(e.values[RF.value] ?? 0);
+        let pm = plantModels.get(e.id);
+        if (!pm) {
+          const def = g.plants[type]?.def;
+          const h = def?.kind === "kiln" ? 2.4 : def?.kind === "pan" ? 1.1 : 1.6;
+          const placed = stage.model(def?.model ?? "style.lowpoly.barrel", h, 0x9a8a6a, 2.4);
+          placed.root.position.set(m(e, RF.x), stage.groundAt(m(e, RF.x), m(e, RF.z)) + 0.08, m(e, RF.z));
+          stage.add(placed.root);
+          pm = { placed, level: 0, type };
+          plantModels.set(e.id, pm);
+          stage.burst("dust", m(e, RF.x), 0.5, m(e, RF.z), 0xe8dcc0, 14);
+        }
+        if (level > pm.level && pm.level > 0) stage.burst("sparks", m(e, RF.x), 1.6, m(e, RF.z), 0xffd76a, 10);
+        pm.level = level;
+        const running = (Math.round(e.values[RF.flags] ?? 0) & 1) !== 0;
+        const s = 1 + Math.min(10, level) * 0.04;
+        pm.placed.root.scale.set(s, s * (running ? 1 + Math.sin(t * 8 + e.id) * 0.03 : 1), s);
+      } else if (e.kind === RulesKind.Pickup) {
+        seenPiles.add(e.owner);
+        const p = pileFor(e.owner);
+        const x = m(e, RF.x);
+        const z = m(e, RF.z);
+        const brine = e.values[RF.hp] ?? 0;
+        const salt = e.values[RF.value] ?? 0;
+        const crystals = e.values[RF.aux] ?? 0;
+        const pr = 0.4 + Math.min(1.8, Math.sqrt(brine) * 0.05);
+        p.pool.position.set(x - 2.6, stage.groundAt(x, z) + 0.1, z);
+        p.pool.scale.setScalar(pr);
+        const ps = 0.3 + Math.min(2.2, Math.cbrt(salt) * 0.16);
+        p.pile.position.set(x, stage.groundAt(x, z) + ps * 0.5, z);
+        p.pile.scale.set(ps * 0.9, ps, ps * 0.9);
+        const want = Math.min(6, Math.floor(crystals));
+        while (p.crystals.length < want) {
+          const c = stage.model(CRYSTAL_MODEL, 0.8, 0x8fe1ff);
+          const k = p.crystals.length;
+          c.root.position.set(x + 1.4 + (k % 3) * 0.55, stage.groundAt(x, z) + 0.05, z - 0.5 + Math.floor(k / 3) * 0.6);
+          stage.add(c.root);
+          p.crystals.push(c);
+        }
+        while (p.crystals.length > want) stage.scene.remove((p.crystals.pop() as Placed).root);
+      }
+    }
+    for (const [id, pm] of plantModels)
+      if (!seenPlants.has(id)) {
+        stage.scene.remove(pm.placed.root);
+        plantModels.delete(id);
+      }
+    for (const [id, p] of piles)
+      if (!seenPiles.has(id)) {
+        stage.scene.remove(p.pool, p.pile);
+        for (const c of p.crystals) stage.scene.remove(c.root);
+        piles.delete(id);
+      }
+    // Foremen: ours predicted, the others interpolated.
+    const seenF = new Set<number>();
+    const place = (e: InterpolatedEntity | undefined, owner: number) => {
+      if (!e) return;
+      seenF.add(owner);
+      let f = foremen.get(owner);
+      if (!f) {
+        f = new Group();
+        const col = KEEPER_COLORS[(owner - 1) % KEEPER_COLORS.length] ?? 0xffffff;
+        f.add(stage.model(manifest.game.players.prefab, 1.8, col).root);
+        const ring = new Mesh(new RingGeometry(0.45, 0.62, 24), new MeshBasicMaterial({ color: col, side: DoubleSide }));
+        ring.rotation.x = -Math.PI / 2;
+        ring.position.y = 0.12;
+        f.add(ring);
+        stage.add(f);
+        foremen.set(owner, f);
+      }
+      f.position.set(m(e, RF.x), stage.groundAt(m(e, RF.x), m(e, RF.z)) + 0.08, m(e, RF.z));
+      f.rotation.y = e.values[RF.yaw] ?? 0;
+    };
+    place(view.self, app.self);
+    for (const e of view.others) if (e.kind === RulesKind.Avatar) place(e, e.owner);
+    for (const [o, f] of foremen)
+      if (!seenF.has(o)) {
+        stage.scene.remove(f);
+        foremen.delete(o);
+      }
+    if (!v) return;
+    hold.scale.y = Math.max(0.01, (v.contract / Math.max(1, v.contractTarget)) * 1.4);
+    hold.position.y = 0.9 + hold.scale.y / 2;
+    // HUD.
+    hud.status([
+      ["SALT", `${fmt(v.salt ?? 0)} kg`],
+      ["BRINE", `${fmt(v.brine ?? 0)} L`],
+      ["CRYSTALS", `${v.crystals ?? 0}`],
+      ["NEXT CRATE", `${fmt(v.made ?? 0)} / ${fmt(v.nextPack ?? 0)} kg`],
+    ]);
+    ((meter.querySelector(".bar") as HTMLElement).firstChild as HTMLElement).style.transform = `scaleX(${Math.min(1, v.contract / Math.max(1, v.contractTarget))})`;
+    (meter.querySelector("#m-left") as HTMLElement).textContent = `SHIFT ${mmss(v.left)}`;
+    (meter.querySelector("#m-hold") as HTMLElement).textContent = v.filled ? "HOLD FULL" : `${v.contract} / ${v.contractTarget} crystals`;
+    const ready = (v.rake ?? 0) === 0;
+    rakeBtn.style.opacity = ready ? "1" : "0.75";
+    (rakeBtn.lastChild as HTMLElement).style.width = `${ready ? 100 : Math.max(0, 100 - ((v.rake ?? 0) / g.rakeTicks) * 100)}%`;
+    cards.forEach((c, i) => {
+      const cost = v.costs?.[i] ?? 0;
+      c.classList.toggle("poor", (v.salt ?? 0) < cost);
+      (c.querySelector("span") as HTMLElement).textContent = `Lv ${v.levels?.[i] ?? 0} · ${WEAPON_NAMES[g.plants[i]?.id ?? ""]?.line ?? ""}`;
+      (c.querySelector("i") as HTMLElement).textContent = `${fmt(cost)} kg`;
+    });
+    shipBtn.textContent = v.filled ? "Hold full" : `Ship ${v.crystals ?? 0}`;
+    shipBtn.disabled = v.filled || (v.crystals ?? 0) < 1;
+    stall.classList.toggle("show", v.stall === 0 && v.phase !== "ended" && !app.preview);
+    const packs = Math.floor((v.made ?? 0) / (g.packEvery / 1000));
+    if (packs > knownPacks && knownPacks > 0) {
+      sfx.play("crate");
+      if (packs % 5 === 0) hud.toast(`Crate ${packs}`);
+    }
+    knownPacks = packs;
+    if (v.filled && !knownFilled) {
+      hud.toast("The barge is full");
+      stage.ring(0, 0, 6, 0x8fe1ff);
+      sfx.play("levelUp");
+    }
+    knownFilled = v.filled;
+    hud.end(v.phase === "ended", v.filled ? "SHIFT DONE · HOLD FULL" : "SHIFT DONE", `${fmt(v.made ?? 0)} kg of salt made`, v.endsIn ?? null);
+  });
+  app.extraStats(() => ({ plants: plantModels.size, works: piles.size, salt: lastView?.salt ?? 0, made: lastView?.made ?? 0, contract: lastView?.contract ?? 0 }));
+}
+
+main().catch((e: unknown) => {
+  const t = document.getElementById("banner-text");
+  if (t) t.textContent = `Could not start: ${e instanceof Error ? e.message : String(e)}`;
+  console.error(e);
+});

package/client/names.ts

@@ -0,0 +1,44 @@
+/**
+ * Display names for the template's content ids. Labels only; the rules are
+ * in src/game.ts. A Net Forge game generated on this template ships its own
+ * table (the model writes src/names.json; the build turns it into this
+ * module). Plants are the "weapons" table.
+ */
+export const TITLE = "Brineworks";
+
+export const WEAPON_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  hand_pump: { name: "Hand Pump", line: "Draws brine" },
+  boil_pan: { name: "Boil Pan", line: "Boils brine into salt" },
+  steam_pump: { name: "Steam Pump", line: "Draws a lot of brine" },
+  sun_pan: { name: "Sun Pan", line: "Boils fast" },
+  crystal_kiln: { name: "Crystal Kiln", line: "Cuts salt into crystals" },
+};
+
+export const UPGRADE_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  bellows: { name: "Bellows", line: "Plants work 15% faster" },
+  long_rake: { name: "Long Rake", line: "+30% salt a rake" },
+  quick_hands: { name: "Quick Hands", line: "Rake faster" },
+};
+
+// Creatures by id (the flat has none; a game that adds some labels them here).
+export const ENEMY_NAMES: Readonly<Record<string, string>> = {
+};
+
+export const RULE_NAMES: Readonly<Record<string, string>> = {
+  first_crate: "First Crates",
+  long_haul: "Long Haul",
+  full_hold: "Full Hold",
+  cutter: "Cutter",
+};
+
+export const SKU_NAMES: Readonly<Record<string, string>> = {
+  bellows: "Bellows",
+  long_rake: "Long Rake",
+  quick_hands: "Quick Hands",
+  skin_saltwhite: "Saltwhite finish",
+  skin_rust: "Rust finish",
+  brass_bellows: "Brass bellows",
+};
+
+export const KEEPER_COLORS = [0xffb347, 0x5ec8ff, 0x9dff7a, 0xff7ab8, 0xc9a7ff, 0xffe066, 0x7affd4, 0xff9a5c];
+export const AURORA = { body: 0x3cf2c4, glow: 0xa77bff };

package/llms-full.txt

@@ -0,0 +1,209 @@
+# Net Forge idle template (BRINEWORKS)
+
+> A shared salt flat for up to 8 players. Each player runs a works on a
+> plot: pumps draw brine, pans boil it into salt, kilns cut salt into
+> crystals, and salt buys and levels more plants. Players rake by hand for
+> salt, and everyone ships crystals to one contract barge. A shift has a
+> fixed length; then a new shift starts from nothing.
+> You change the game by editing src/game.ts only. The template already has
+> the works, the production chain, buying and levelling, raking, tending,
+> the contract, the shift clock, netcode, rendering, earn and the store.
+
+## Files
+
+- src/game.ts: THE GAME. game(), saltFlat(), plant(), upgrade(),
+  earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label. Plants go in "weapons"
+  ({ name, line }); "enemies" stays empty.
+
+## Rules the build enforces (the anti-farm rules)
+
+- game({ template: "idle", style, places, players: { prefab, max } }), max at most 8.
+- Exactly one saltFlat(...); 1 to 8 plant(...)s with at least one "pump",
+  one "pan" and one "kiln" (the chain).
+- A shift is 600 to 3600 seconds. Every earn rule is oncePer: "run" (a run
+  is a shift, or a player's time in it).
+- tend is at most 300 seconds: a works nobody tends stops, so an idle tab
+  makes nothing. Production happens only on the room's clock while the
+  player is in the room; nothing is earned offline and a player who leaves
+  and comes back starts a fresh works.
+- No earn rule may pay sooner than 180 seconds into a fresh works, even
+  with perfect play or raking as fast as the cooldown allows. The gate
+  measures it; if a draft pays sooner it fails with the number. Raise
+  packEvery or the rule's n, or slow raking.
+- Upgrades read three stats: might (plant output), haste (raking speed),
+  amount (salt a rake). No weapon() or prefab().
+- An earn rule must fire within about 4 minutes of 4-player play.
+
+## Units
+
+Seconds, litres of brine, kg of salt, whole crystals. A plant's rate is a
+second, a level. Costs are kg of salt; each level costs growth times the last.
+
+## Common changes
+
+### Faster or slower progress
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+Lower growth makes levels cheap for longer; a higher rate makes each level count more.
+Keep the first payout at least 180 s away (the gate checks).
+
+### A new plant
+plant("deep_bore", { model: "style.lowpoly.generator_large", kind: "pump", cost: 5000, growth: 1.2, rate: 200 });
+Add its label to names.json weapons. The bar shows plants in order (keys 1-8).
+
+### Longer or shorter shifts
+saltFlat({ shift: 1200, ... }) (600 to 3600 s). A bigger contract: contract: { crystals: 120 }.
+
+### Earn rules
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+Events: salt.packed (one each packEvery kg a player makes), crystal.cut,
+crystal.shipped, plant.built, plant.upgraded (each credits the player),
+contract.filled (the players who shipped to it; world progress, so never a
+player whose run started after the shift began). Pays coins once a run.
+
+### The buy-in run (required)
+earn.stake({ min: 20, max: 200, multiple: 2 }); one top-level line. "stake" is reserved.
+
+### Coins: earn and the store
+store.sku("bellows", { coins: 40 });                               // one level of "bellows" for the shift
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });   // a finish for your foreman
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (bellows, long_rake, quick_hands,
+skin_saltwhite, skin_rust, brass_bellows) at their prices.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 4 }) plays the flat and reports
+crates packed (as kills), earned by rule, softlock, ms per tick and the
+genre's checks (the farming bounds) under rules.checks.
+
+## Worked example: src/game.ts
+
+This is the template's complete src/game.ts as it ships. A new game on this
+template starts from this file and changes declarations in place.
+
+```ts
+/**
+ * BRINEWORKS: the idle template (play style: idle).
+ *
+ * A white salt flat under a hot sky. Up to eight players each run a works on
+ * the flat: pumps draw brine, pans boil it into salt, kilns cut salt into
+ * crystals, and salt buys and levels more plants. A barge on the canal
+ * takes crystals for a contract everyone fills together. A shift lasts
+ * fifteen minutes; then the flat is raked clean and a new shift begins.
+ *
+ * Works run only while their player is on the flat and has tended them in
+ * the last two minutes (a rake, a purchase, a shipment): no offline
+ * production, nothing for an idle tab.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine.
+ */
+import { earn, game, plant, saltFlat, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "idle",
+  style: "lowpoly",
+  places: { flat: { chunks: "places/flat", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.worker", max: 8 },
+});
+
+// The flat: a fifteen-minute shift, works that stall two minutes after the last tend,
+// a rake every 0.4 s for 3 kg, 3 L of brine to a kg of salt, 25 kg of salt to a crystal, a crate every 150 kg.
+saltFlat({
+  shift: 900,
+  tend: 120,
+  start: 20,
+  rake: { salt: 3, cooldown: 0.4 },
+  brinePerSalt: 3,
+  saltPerCrystal: 25,
+  packEvery: 150,
+  contract: { crystals: 60 },
+});
+
+// Plants. cost is kg of salt for the first level, growth the price rise a level; rate is a second, a level
+// (pumps: litres of brine; pans: kg of salt boiled; kilns: crystals cut).
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+plant("boil_pan", { model: "style.lowpoly.crate", kind: "pan", cost: 25, growth: 1.15, rate: 1 });
+plant("steam_pump", { model: "style.lowpoly.generator", kind: "pump", cost: 400, growth: 1.18, rate: 30 });
+plant("sun_pan", { model: "style.lowpoly.barrels", kind: "pan", cost: 600, growth: 1.18, rate: 10 });
+plant("crystal_kiln", { model: "style.lowpoly.generator_large", kind: "kiln", cost: 900, growth: 1.25, rate: 0.05 });
+
+// Store upgrades: one level each, for the rest of the shift, on the buyer's own works.
+upgrade("bellows", { stat: "might", step: 0.15, maxLevel: 1 });
+upgrade("long_rake", { stat: "amount", step: 0.3, maxLevel: 1 });
+upgrade("quick_hands", { stat: "haste", step: 0.25, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once a shift each. Values are PLACEHOLDER.
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+earn.rule("long_haul", { when: "salt.packed", n: 300, pay: 20, oncePer: "run" });
+earn.rule("full_hold", { when: "contract.filled", n: 1, pay: 50, oncePer: "run" });
+earn.rule("cutter", { when: "crystal.cut", n: 30, pay: 5, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at shift start to earn above free play. Values are PLACEHOLDER.
+earn.stake({ min: 20, max: 200, multiple: 2 });
+
+// Store (the Kit), priced in coins: three shift upgrades, two finishes owned for good, one piece of losable gear.
+store.sku("bellows", { coins: 40 });
+store.sku("long_rake", { coins: 40 });
+store.sku("quick_hands", { coins: 60 });
+store.sku("skin_saltwhite", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: owned for good until lost. It brings one level of its upgrade into every staked shift,
+// and is lost when that shift makes less than loseBelow of its most earn. Values are PLACEHOLDER.
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } });
+```
+
+## Validate and playtest
+
+### With the MCP server
+
+Run `npx -y @netforge/mcp` (package @netforge/mcp, bin netforge-mcp) and
+connect it to your coding agent. Its tools are netforge_list_templates, netforge_create_game,
+netforge_explain_api, netforge_search_docs, netforge_validate_game, netforge_run_playtest and netforge_play_locally.
+
+- netforge_validate_game checks src/game.ts against the engine's schemas and this
+  template's rules, and returns one actionable line per problem.
+- netforge_run_playtest plays the game headless with bots and returns the report.
+- netforge_play_locally gives the steps to open the game in a browser with kit play.
+
+### In code
+
+Import the game module first so its declarations register, then run the
+headless harness. This plays 4 players for 4 minutes at 30 Hz.
+
+```ts
+import { engine } from "@netforge/engine";
+import "./src/game.js";
+
+const report = await engine.test.run({
+  ticks: 30 * 240,
+  bots: 4,
+  seed: 1,
+  assert: [
+    { name: "earn fired", check: (r) => r.earnEmitted > 0 },
+    { name: "no softlock", check: (r) => !r.softlock },
+  ],
+});
+if (report.failed.length > 0) throw new Error(report.failed.join("\n"));
+```
+
+The report has crates packed (as kills), earned by rule, softlock, ms per tick and the genre's checks (the farming bounds) under rules.checks.
+
+The template's own tests (vitest) are the reference checks:
+
+- test/harness.test.ts
+- test/store.test.ts
+
+### Play it locally
+
+In a folder with netnet.json and src/game.ts:
+
+```sh
+npm install @netforge/kit-play @netforge/engine @netforge/template-idle
+echo '{"template":"idle"}' > netnet.json
+npx kit-play        # opens http://127.0.0.1:4663
+```
+
+kit play builds the template client with your src/game.ts and runs a local
+room host with play money. No wallet, no chain and no hosted servers are
+involved. Open the link in more tabs for more players.

package/llms.txt

@@ -0,0 +1,78 @@
+# Net Forge idle template (BRINEWORKS)
+
+> A shared salt flat for up to 8 players. Each player runs a works on a
+> plot: pumps draw brine, pans boil it into salt, kilns cut salt into
+> crystals, and salt buys and levels more plants. Players rake by hand for
+> salt, and everyone ships crystals to one contract barge. A shift has a
+> fixed length; then a new shift starts from nothing.
+> You change the game by editing src/game.ts only. The template already has
+> the works, the production chain, buying and levelling, raking, tending,
+> the contract, the shift clock, netcode, rendering, earn and the store.
+
+## Files
+
+- src/game.ts: THE GAME. game(), saltFlat(), plant(), upgrade(),
+  earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label. Plants go in "weapons"
+  ({ name, line }); "enemies" stays empty.
+
+## Rules the build enforces (the anti-farm rules)
+
+- game({ template: "idle", style, places, players: { prefab, max } }), max at most 8.
+- Exactly one saltFlat(...); 1 to 8 plant(...)s with at least one "pump",
+  one "pan" and one "kiln" (the chain).
+- A shift is 600 to 3600 seconds. Every earn rule is oncePer: "run" (a run
+  is a shift, or a player's time in it).
+- tend is at most 300 seconds: a works nobody tends stops, so an idle tab
+  makes nothing. Production happens only on the room's clock while the
+  player is in the room; nothing is earned offline and a player who leaves
+  and comes back starts a fresh works.
+- No earn rule may pay sooner than 180 seconds into a fresh works, even
+  with perfect play or raking as fast as the cooldown allows. The gate
+  measures it; if a draft pays sooner it fails with the number. Raise
+  packEvery or the rule's n, or slow raking.
+- Upgrades read three stats: might (plant output), haste (raking speed),
+  amount (salt a rake). No weapon() or prefab().
+- An earn rule must fire within about 4 minutes of 4-player play.
+
+## Units
+
+Seconds, litres of brine, kg of salt, whole crystals. A plant's rate is a
+second, a level. Costs are kg of salt; each level costs growth times the last.
+
+## Common changes
+
+### Faster or slower progress
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+Lower growth makes levels cheap for longer; a higher rate makes each level count more.
+Keep the first payout at least 180 s away (the gate checks).
+
+### A new plant
+plant("deep_bore", { model: "style.lowpoly.generator_large", kind: "pump", cost: 5000, growth: 1.2, rate: 200 });
+Add its label to names.json weapons. The bar shows plants in order (keys 1-8).
+
+### Longer or shorter shifts
+saltFlat({ shift: 1200, ... }) (600 to 3600 s). A bigger contract: contract: { crystals: 120 }.
+
+### Earn rules
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+Events: salt.packed (one each packEvery kg a player makes), crystal.cut,
+crystal.shipped, plant.built, plant.upgraded (each credits the player),
+contract.filled (the players who shipped to it; world progress, so never a
+player whose run started after the shift began). Pays coins once a run.
+
+### The buy-in run (required)
+earn.stake({ min: 20, max: 200, multiple: 2 }); one top-level line. "stake" is reserved.
+
+### Coins: earn and the store
+store.sku("bellows", { coins: 40 });                               // one level of "bellows" for the shift
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });   // a finish for your foreman
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (bellows, long_rake, quick_hands,
+skin_saltwhite, skin_rust, brass_bellows) at their prices.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 4 }) plays the flat and reports
+crates packed (as kills), earned by rule, softlock, ms per tick and the
+genre's checks (the farming bounds) under rules.checks.

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "@netforge/template-idle",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Shared idle game template for Net Forge: up to 8 players pump, boil and cut salt to fill a contract together (BRINEWORKS).",
+  "keywords": [
+    "game-template",
+    "multiplayer",
+    "browser-game",
+    "html5-game",
+    "threejs",
+    "game-engine",
+    "typescript",
+    "gamedev",
+    "ai-agents",
+    "mcp",
+    "net-forge",
+    "idle-game"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "./src/game.ts",
+    "./src/manifest.ts",
+    "./client/**"
+  ],
+  "exports": {
+    ".": "./src/manifest.ts",
+    "./store": "./src/store.ts",
+    "./package.json": "./package.json",
+    "./llms.txt": "./llms.txt",
+    "./llms-full.txt": "./llms-full.txt"
+  },
+  "files": [
+    "src",
+    "client",
+    "!client/vite.config.ts",
+    "llms.txt",
+    "README.md",
+    "NOTICE",
+    "LICENSE",
+    "llms-full.txt",
+    "AGENTS.md",
+    "CLAUDE.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://forge.netnet.capital/docs/templates/idle",
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netnetdev/net-forge.git",
+    "directory": "packages/template-idle"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "three": "0.186.1",
+    "@netforge/asset-library": "0.2.0",
+    "@netforge/tabletop": "0.2.0",
+    "@netforge/engine": "0.2.0",
+    "@netforge/engine-sim": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "@types/three": "0.186.0",
+    "tsx": "4.23.0",
+    "typescript": "5.8.3",
+    "vite": "6.4.3",
+    "vitest": "3.2.7"
+  },
+  "scripts": {
+    "build": "node ../engine/scripts/fresh-dist.mjs && vite build --config client/vite.config.ts",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "dev": "vite --config client/vite.config.ts",
+    "preview": "vite preview --config client/vite.config.ts"
+  }
 }

package/src/autopilot.ts

@@ -0,0 +1,58 @@
+/**
+ * The autopilot over a player's own run state (no DOM): the browser's
+ * ?autopilot=1 and the measure script's node clients play the works the
+ * way the genre's bot does, from what the room sends them.
+ */
+import { IdleAct, plotCenter } from "@netforge/engine/rules";
+import type { RulesInput } from "@netforge/engine/rules";
+import { idleGame } from "./manifest.js";
+
+/** What the room sends one player (adapter infoFor over the genre's view). */
+export interface IdleView {
+  readonly phase?: "playing" | "ended";
+  readonly outcome?: "won" | "lost" | null;
+  readonly endsIn?: number | null;
+  readonly earn?: readonly { id: string; when: string; n: number; have: number; paid: boolean }[];
+  readonly left: number;
+  readonly shift: number;
+  readonly contract: number;
+  readonly contractTarget: number;
+  readonly filled: boolean;
+  readonly players: readonly { id: number; slot: number; made: number; shipped: number; tended: boolean }[];
+  readonly slot?: number;
+  readonly brine?: number;
+  readonly salt?: number;
+  readonly crystals?: number;
+  readonly made?: number;
+  readonly nextPack?: number;
+  readonly levels?: readonly number[];
+  readonly costs?: readonly number[];
+  readonly stall?: number;
+  readonly rake?: number;
+  readonly rates?: { pump: number; pan: number; kiln: number };
+}
+
+const g = idleGame().game;
+
+/** The browser's autopilot: rake when ready, buy what the chain lacks, ship crystals. */
+export function idleAutopilot(v: IdleView | null, tick: number): RulesInput | null {
+  if (!v || v.salt === undefined || !v.levels || !v.costs || !v.rates || tick % 3 !== 0) return null;
+  const c = plotCenter(v.slot ?? 0);
+  const base = { mx: 0, mz: 0, cx: Math.round(c.x * 16), cz: Math.round((c.z + 2) * 16), b: 0, c: 0 };
+  const saltRate = Math.min(v.rates.pan, v.rates.pump / g.brinePerSalt);
+  const kind = v.left < v.shift * 0.65 && saltRate > v.rates.kiln * g.saltPerCrystal * 2 ? "kiln" : v.rates.pump / g.brinePerSalt <= v.rates.pan ? "pump" : "pan";
+  let best = -1;
+  let score = Infinity;
+  g.plants.forEach((p, i) => {
+    if (p.def.kind !== kind) return;
+    const sc = (v.costs?.[i] ?? Infinity) / p.def.rate;
+    if (sc < score) {
+      score = sc;
+      best = i;
+    }
+  });
+  if (best >= 0 && v.salt >= (v.costs[best] ?? Infinity)) return { ...base, act: IdleAct.Buy, a: best };
+  if ((v.rake ?? 1) === 0) return { ...base, act: IdleAct.Rake, a: 0 };
+  if ((v.crystals ?? 0) >= 1 && !v.filled) return { ...base, act: IdleAct.Ship, a: v.crystals ?? 1 };
+  return null;
+}

package/src/game.ts

@@ -0,0 +1,68 @@
+/**
+ * BRINEWORKS: the idle template (play style: idle).
+ *
+ * A white salt flat under a hot sky. Up to eight players each run a works on
+ * the flat: pumps draw brine, pans boil it into salt, kilns cut salt into
+ * crystals, and salt buys and levels more plants. A barge on the canal
+ * takes crystals for a contract everyone fills together. A shift lasts
+ * fifteen minutes; then the flat is raked clean and a new shift begins.
+ *
+ * Works run only while their player is on the flat and has tended them in
+ * the last two minutes (a rake, a purchase, a shipment): no offline
+ * production, nothing for an idle tab.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine.
+ */
+import { earn, game, plant, saltFlat, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "idle",
+  style: "lowpoly",
+  places: { flat: { chunks: "places/flat", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.worker", max: 8 },
+});
+
+// The flat: a fifteen-minute shift, works that stall two minutes after the last tend,
+// a rake every 0.4 s for 3 kg, 3 L of brine to a kg of salt, 25 kg of salt to a crystal, a crate every 150 kg.
+saltFlat({
+  shift: 900,
+  tend: 120,
+  start: 20,
+  rake: { salt: 3, cooldown: 0.4 },
+  brinePerSalt: 3,
+  saltPerCrystal: 25,
+  packEvery: 150,
+  contract: { crystals: 60 },
+});
+
+// Plants. cost is kg of salt for the first level, growth the price rise a level; rate is a second, a level
+// (pumps: litres of brine; pans: kg of salt boiled; kilns: crystals cut).
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+plant("boil_pan", { model: "style.lowpoly.crate", kind: "pan", cost: 25, growth: 1.15, rate: 1 });
+plant("steam_pump", { model: "style.lowpoly.generator", kind: "pump", cost: 400, growth: 1.18, rate: 30 });
+plant("sun_pan", { model: "style.lowpoly.barrels", kind: "pan", cost: 600, growth: 1.18, rate: 10 });
+plant("crystal_kiln", { model: "style.lowpoly.generator_large", kind: "kiln", cost: 900, growth: 1.25, rate: 0.05 });
+
+// Store upgrades: one level each, for the rest of the shift, on the buyer's own works.
+upgrade("bellows", { stat: "might", step: 0.15, maxLevel: 1 });
+upgrade("long_rake", { stat: "amount", step: 0.3, maxLevel: 1 });
+upgrade("quick_hands", { stat: "haste", step: 0.25, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once a shift each. Values are PLACEHOLDER.
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+earn.rule("long_haul", { when: "salt.packed", n: 300, pay: 20, oncePer: "run" });
+earn.rule("full_hold", { when: "contract.filled", n: 1, pay: 50, oncePer: "run" });
+earn.rule("cutter", { when: "crystal.cut", n: 30, pay: 5, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at shift start to earn above free play. Values are PLACEHOLDER.
+earn.stake({ min: 20, max: 200, multiple: 2 });
+
+// Store (the Kit), priced in coins: three shift upgrades, two finishes owned for good, one piece of losable gear.
+store.sku("bellows", { coins: 40 });
+store.sku("long_rake", { coins: 40 });
+store.sku("quick_hands", { coins: 60 });
+store.sku("skin_saltwhite", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: owned for good until lost. It brings one level of its upgrade into every staked shift,
+// and is lost when that shift makes less than loseBelow of its most earn. Values are PLACEHOLDER.
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } });

package/src/manifest.ts

@@ -0,0 +1,44 @@
+/**
+ * Loads the game module once per process and compiles it. The room server,
+ * the client, the bots and the tests all start here.
+ */
+import { collectManifest } from "@netforge/engine/game";
+import type { GameManifest } from "@netforge/engine";
+import { rulesAdapter, idleGenre } from "@netforge/engine/rules";
+import type { RulesInput, RulesWorld, IdleState } from "@netforge/engine/rules";
+import type { SimAdapter } from "@netforge/engine/net";
+import "./game.js";
+
+/** Content version: bump with any change to game.ts (hot swap compares it). */
+export const GAME_VERSION = "brineworks-0.1.0";
+export const GAME_NAME = "brineworks";
+/** Room template (as the Net Forge room server names it) and place used by the client and the bots. */
+export const TEMPLATE = "idle";
+export const PLACE = "flat";
+
+/**
+ * Collected as soon as the module is imported: one process may load more
+ * than one game module (the room server hosts every template), and each
+ * manifest takes its own game before the next module declares.
+ */
+const MANIFEST = collectManifest();
+let genre: ReturnType<typeof idleGenre> | null = null;
+
+/** The game's manifest (every declaration). */
+export function idleManifest(): GameManifest {
+  return MANIFEST;
+}
+
+/** The compiled idle genre (flat, plants). */
+export function idleGame(): ReturnType<typeof idleGenre> {
+  genre ??= idleGenre(MANIFEST);
+  return genre;
+}
+
+/** The SimAdapter the room server and the client both run. */
+export function idleAdapter(): SimAdapter<RulesWorld<IdleState>, RulesInput> {
+  return rulesAdapter(idleGame(), MANIFEST, { name: GAME_NAME, version: GAME_VERSION });
+}
+
+/** Cosmetic ids for store SKUs (0 is the default finish). */
+export const COSMETICS: Readonly<Record<string, number>> = { skin_saltwhite: 1, skin_rust: 2 };

package/src/store.ts

@@ -0,0 +1,20 @@
+/**
+ * Store hooks (the Coins model). BRINEWORKS
+ * sells three shift upgrades (a store command named after the upgrade grants
+ * one level for the rest of the shift), two finishes and one piece of
+ * losable gear, all priced in coins. The Kit bridge lives in @netforge/tabletop.
+ */
+export { mockKit } from "@netforge/tabletop";
+export type { KitStoreBridge, MockKit, SkuPrice } from "@netforge/tabletop";
+
+/** Coin prices the client is wired to (they match store.sku(...) in game.ts; the generator's gate keeps them). */
+export const COIN_PRICES = { bellows: 40, long_rake: 40, quick_hands: 60, skin_saltwhite: 300, skin_rust: 500, brass_bellows: 150 } as const;
+export const UPGRADE_SKUS = ["bellows", "long_rake", "quick_hands"] as const;
+export const COSMETIC_SKUS = ["skin_saltwhite", "skin_rust"] as const;
+
+/** The template's own coin until a creator renames it. */
+export const BRINE_COIN = {
+  name: "Brine",
+  symbol: "BRINE",
+  logo: "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Ccircle cx='16' cy='16' r='15' fill='%235ec8ff'/%3E%3Cpath d='M16 6l7 9-7 11-7-11z' fill='%23f6fbff'/%3E%3Cpath d='M16 6l7 9h-14z' fill='%23d6eefc'/%3E%3C/svg%3E",
+} as const;