@netforge/template-idle 0.0.0-stage → 0.1.0

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,43 @@
-# Temporary Holding Version
+# BRINEWORKS (idle template)
 
-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 white salt flat under a hot sky. Up to eight players each run a works:
+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; then a new one begins.
+
+A board genre (`packages/engine/src/rules/idle.ts`) on the shared runtime;
+client kit `@netforge/tabletop`. Room template `idle` (cap 8).
+
+## Why it cannot be farmed
+
+- Production runs only in the room's sim, on its ticks, for players in the
+  room. No wall clock, no offline accrual, no client-reported numbers.
+- A works stalls two minutes after its last tend (rake, buy, ship): an idle
+  tab makes nothing.
+- Raking has a cooldown; 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), and the most one seat can earn is about 550 coins an
+  hour even rejoining every time a rule pays, before the per-wallet daily
+  cap, the free-play lifetime cap and the stake terms. With full shifts the
+  four rules pay at most 80 coins a shift (320 an hour).
+- One earning seat per wallet (the room's seat lock), and the run replays
+  from its inputs for the referee.
+
+## Run it
+
+This template runs on your own computer with play money through
+`kit play` (`@netforge/kit-play`). From the repository root:
+
+```sh
+pnpm install --frozen-lockfile && pnpm build
+mkdir -p play-idle/src && cp packages/template-idle/src/game.ts play-idle/src/
+echo '{"template":"idle"}' > play-idle/netnet.json
+node packages/kit-play/dist/cli.js play-idle       # opens http://127.0.0.1:4663
+```
+
+Edit `play-idle/src/game.ts` and run it again to try a change. Real-token
+earning, stakes and claims run only on the hosted Net Forge server.
+
+Space rakes (or click your plot), 1-5 buy a plant, S ships crystals.

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.txt

@@ -0,0 +1,78 @@
+# BRINEWORKS: the idle template (NetNet game runtime, board genre)
+
+> 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,57 @@
 {
   "name": "@netforge/template-idle",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "BRINEWORKS: the idle template of the NetNet game runtime, a shared salt flat for up to eight: pump brine, boil salt, cut crystals, fill the contract together. The game module, its browser client and its playtest bots.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/manifest.ts",
+    "./store": "./src/store.ts"
+  },
+  "files": [
+    "src",
+    "client",
+    "!client/vite.config.ts",
+    "llms.txt",
+    "README.md",
+    "NOTICE",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netnetdev/net-forge.git",
+    "directory": "packages/template-idle"
+  },
+  "homepage": "https://github.com/netnetdev/net-forge/tree/main/packages/template-idle#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "three": "0.186.1",
+    "@netforge/asset-library": "0.1.0",
+    "@netforge/engine-sim": "0.1.0",
+    "@netforge/engine": "0.1.0",
+    "@netforge/tabletop": "0.1.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"
+  },
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
+  "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;