npm - create-siltrun - Versions diffs - 0.1.0 - Mend

create-siltrun 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/index.mjs +98 -0
package/package.json +18 -0
package/templates/mass-grid/AGENTS.md +106 -0
package/templates/mass-grid/README.md +59 -0
package/templates/mass-grid/_gitignore +4 -0
package/templates/mass-grid/index.html +22 -0
package/templates/mass-grid/package.json +31 -0
package/templates/mass-grid/room.test.ts +214 -0
package/templates/mass-grid/room.ts +530 -0
package/templates/mass-grid/skills/authoritative-tick.md +116 -0
package/templates/mass-grid/skills/compact-snapshots.md +110 -0
package/templates/mass-grid/skills/demo-room-lifecycle.md +145 -0
package/templates/mass-grid/skills/genre-lane-mapping.md +88 -0
package/templates/mass-grid/skills/territory-capture.md +115 -0
package/templates/mass-grid/src/Game.tsx +174 -0
package/templates/mass-grid/src/main.tsx +9 -0
package/templates/mass-grid/tsconfig.json +15 -0
package/templates/mass-grid/vite.config.ts +9 -0
package/templates/minimal/README.md +39 -0
package/templates/minimal/_gitignore +4 -0
package/templates/minimal/index.html +15 -0
package/templates/minimal/package.json +30 -0
package/templates/minimal/room.ts +30 -0
package/templates/minimal/src/Game.tsx +71 -0
package/templates/minimal/src/main.tsx +9 -0
package/templates/minimal/tsconfig.json +15 -0
package/templates/minimal/vite.config.ts +7 -0
package/templates/tower-defense/AGENTS.md +132 -0
package/templates/tower-defense/README.md +53 -0
package/templates/tower-defense/_gitignore +4 -0
package/templates/tower-defense/index.html +15 -0
package/templates/tower-defense/package.json +31 -0
package/templates/tower-defense/room.test.ts +159 -0
package/templates/tower-defense/room.ts +321 -0
package/templates/tower-defense/skills/authoritative-tick.md +96 -0
package/templates/tower-defense/skills/demo-room-lifecycle.md +145 -0
package/templates/tower-defense/skills/state-budget.md +79 -0
package/templates/tower-defense/skills/two-lanes.md +66 -0
package/templates/tower-defense/skills/waves-and-timing.md +79 -0
package/templates/tower-defense/src/Game.tsx +227 -0
package/templates/tower-defense/src/main.tsx +9 -0
package/templates/tower-defense/tsconfig.json +15 -0
package/templates/tower-defense/vite.config.ts +7 -0
package/templates/turn-based-grid/AGENTS.md +183 -0
package/templates/turn-based-grid/README.md +72 -0
package/templates/turn-based-grid/_gitignore +4 -0
package/templates/turn-based-grid/index.html +15 -0
package/templates/turn-based-grid/package.json +30 -0
package/templates/turn-based-grid/room.ts +309 -0
package/templates/turn-based-grid/skills/play.md +97 -0
package/templates/turn-based-grid/src/App.tsx +141 -0
package/templates/turn-based-grid/src/GraphicsView.tsx +148 -0
package/templates/turn-based-grid/src/brains.ts +112 -0
package/templates/turn-based-grid/src/main.tsx +8 -0
package/templates/turn-based-grid/src/stubAgent.ts +82 -0
package/templates/turn-based-grid/src/substrate/ascii.ts +87 -0
package/templates/turn-based-grid/src/substrate/map.ts +104 -0
package/templates/turn-based-grid/src/substrate/types.ts +59 -0
package/templates/turn-based-grid/src/view.ts +94 -0
package/templates/turn-based-grid/tsconfig.json +15 -0
package/templates/turn-based-grid/vite.config.ts +7 -0

package/templates/mass-grid/vite.config.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+// The Vite app runs on :5173 and discovers the room at http://localhost:4000
+// (siltrun dev's room-info endpoint) at runtime — no proxy, no cert handling here.
+export default defineConfig({
+  plugins: [react()],
+  server: { port: 5173 },
+});

package/templates/minimal/README.md ADDED Viewed

@@ -0,0 +1,39 @@
+# my silt game
+A multiplayer room on [Silt](https://silt.run) — an authoritative server contract
+(`room.ts`) plus a React client (`src/`), one project, one language.
+## Run
+```bash
+npm install
+npm run dev
+```
+This boots both halves:
+- **room** — `siltrun dev room.ts`: your contract running authoritatively at 60Hz
+  (room-info on `http://localhost:4000`, WebTransport on `:4433`)
+- **web** — vite dev server on [http://localhost:5173](http://localhost:5173)
+Open `http://localhost:5173` in **two windows** — that's your multiplayer room.
+## Edit
+- `room.ts` — the server's truth: membership, movement, rules. Hot-reloads on save
+  (a determinism doctor re-checks each reload).
+- `src/Game.tsx` — the client: `useRoom(url, { id })` gives you `{ state, send }`.
+  `send(data)` is droppable intent (movement); `send(data, { reliable: true })` is
+  an ordered event (chat, turns). Rendering is [@siltrun/stage](https://silt.run/docs)
+  (PixiJS): `createStage` + one camera call + one input primitive is the whole
+  ceremony — touch, viewport fit, and DPR handling come free, so the game is
+  phone-playable from the first run.
+The two share types through `import type { State } from "../room"` — erased at
+build, so no server code reaches the browser.
+## Learn more
+- Quickstart & contract rules: https://silt.run/docs
+- The lanes (datagram vs reliable), determinism realm, and limits are the load-bearing
+  docs — read them before designing a game.

package/templates/minimal/_gitignore ADDED Viewed

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+*.log
+.DS_Store

package/templates/minimal/index.html ADDED Viewed

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="mobile-web-app-capable" content="yes" />
+    <style>html, body { overscroll-behavior: none; }</style>
+    <title>my silt game</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/minimal/package.json ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "name": "my-silt-game",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "concurrently -k -n room,web -c yellow,cyan \"siltrun dev room.ts\" \"vite\"",
+    "build": "vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@siltrun/stage": "^0.1.0",
+    "pixi.js": "^8.19.0",
+    "@siltrun/client": "^0.3.0",
+    "@siltrun/react": "^0.1.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@siltrun/room": "^0.1.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "concurrently": "^9.0.0",
+    "siltrun": "^0.1.0",
+    "typescript": "^5.6.0",
+    "vite": "^5.4.0"
+  }
+}

package/templates/minimal/room.ts ADDED Viewed

@@ -0,0 +1,30 @@
+// room.ts — your authoritative room contract. This file runs SERVER-SIDE at 60Hz;
+// browsers submit intent, this tick() decides truth, and every client receives the
+// full state each tick. Edit it while `npm run dev` is running — it hot-reloads.
+import type { Room } from "@siltrun/room";
+type Ship = { x: number; y: number; tx?: number; ty?: number };
+export type State = { ships: Record<string, Ship> };
+export type Cmd = { x: number; y: number };
+const clamp = (v: number) => Math.max(0, Math.min(520, v));
+export default {
+  tick(state = { ships: {} }, inputs) {
+    for (const ev of inputs) {
+      if (ev.kind === "leave") { delete state.ships[ev.id]; continue; }
+      if (ev.kind === "join")  { state.ships[ev.id] = { x: 260, y: 140 }; continue; }
+      if (ev.kind === "input") {
+        const s = state.ships[ev.from];
+        if (s) { s.tx = clamp(ev.data.x); s.ty = clamp(ev.data.y); }  // the server clamps intent
+      }
+    }
+    for (const id in state.ships) {
+      const s = state.ships[id];
+      if (s.tx == null || s.ty == null) continue;
+      s.x += (s.tx - s.x) * 0.1;
+      s.y += (s.ty - s.y) * 0.1;
+    }
+    return state;
+  },
+} satisfies Room<State, Cmd>;

package/templates/minimal/src/Game.tsx ADDED Viewed

@@ -0,0 +1,71 @@
+import { useEffect, useRef } from "react";
+import { useRoom } from "@siltrun/react";
+import { createStage, createCamera, type StageHandle } from "@siltrun/stage";
+import { tapBoard } from "@siltrun/stage/input";
+import { Graphics } from "pixi.js";
+// The server and client share types with a type-only import — erased at build, so
+// nothing server-side leaks into the bundle. One project, one language, one seam.
+import type { State } from "../room";
+// A stable player identity, kept for this browser tab.
+const PLAYER_ID = sessionStorage.getItem("player-id") ?? crypto.randomUUID();
+sessionStorage.setItem("player-id", PLAYER_ID);
+// The playfield in world units — the same 0..520 space the server clamps intent to.
+const FIELD = { x: 0, y: 0, w: 520, h: 280 };
+const INK = 0x0b0b0d, BONE = 0xeae7de, SILT = 0x7e837a, HAIR = 0x3a3a3d;
+export function Game() {
+  const { state, send, status, error } = useRoom<State>("http://localhost:4000", { id: PLAYER_ID });
+  // React owns the DOM chrome; the stage redraws the world each frame from this ref.
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const hostRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    let stage: StageHandle | undefined;
+    let cancelled = false;
+    // createStage is awaited INSIDE the effect — never top-level. (A top-level await
+    // deadlocks a bundled build; see the @siltrun/stage README.)
+    createStage(hostRef.current!, { background: INK }).then((s) => {
+      if (cancelled) return s.dispose();
+      stage = s;
+      // One camera call: frame the field on any screen, refit on rotate/resize.
+      const cam = createCamera(s);
+      const fit = () => cam.fitRect(FIELD, { pad: 24 });
+      fit(); s.onResize(fit);
+      // One input primitive: tap (or click) → world point → intent to the server.
+      tapBoard(s.app.canvas, {
+        map: (sx, sy) => cam.toWorld(sx, sy),
+        onTap: (p) => send({ x: p.x, y: p.y }),
+      });
+      // Draw: vector shapes redrawn from authoritative state every frame.
+      const gfx = s.world.addChild(new Graphics());
+      s.app.ticker.add((tk) => {
+        cam.update(tk.deltaMS / 1000);
+        gfx.clear();
+        gfx.rect(FIELD.x, FIELD.y, FIELD.w, FIELD.h).stroke({ color: HAIR, width: 2 });
+        for (const [id, ship] of Object.entries(stateRef.current?.ships ?? {})) {
+          gfx.circle(ship.x, ship.y, 8).fill(id === PLAYER_ID ? BONE : SILT);
+        }
+      });
+    });
+    return () => { cancelled = true; stage?.dispose(); }; // dispose tears down ticker + canvas + inputs
+  }, [send]);
+  const hint = status === "failed"
+    ? `connection failed: ${String(error)} — is \`npm run dev\` running?`
+    : !state ? (status === "reconnecting" ? "reconnecting…" : "joining…")
+    : "tap the field to send your ship — open a second window for player two";
+  return (
+    <main style={{ position: "fixed", inset: 0, fontFamily: "system-ui" }}>
+      <div ref={hostRef} style={{ position: "absolute", inset: 0 }} />
+      <p style={{ position: "absolute", left: 0, right: 0, bottom: 8, margin: 0, textAlign: "center", pointerEvents: "none", color: "#7e837a", fontSize: 12 }}>{hint}</p>
+    </main>
+  );
+}

package/templates/minimal/src/main.tsx ADDED Viewed

@@ -0,0 +1,9 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { Game } from "./Game.tsx";
+createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <Game />
+  </React.StrictMode>,
+);

package/templates/minimal/tsconfig.json ADDED Viewed

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src", "room.ts", "vite.config.ts"]
+}

package/templates/minimal/vite.config.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+export default defineConfig({
+  plugins: [react()],
+  server: { port: 5173 },
+});

package/templates/tower-defense/AGENTS.md ADDED Viewed

@@ -0,0 +1,132 @@
+# AGENTS.md — co-op tower defense on Silt
+You (a coding agent) are working in a **Silt** project: an authoritative multiplayer room.
+This file orients you so you can extend the game immediately. Read it fully once, then read
+the one skill in `skills/` that matches what you're about to change. The skills are the deep
+knowledge; this file is the map.
+## What this project is
+A **co-op tower defense** starter. Two players share one always-warm room: they drop in,
+ready up, and defend a path against waves of creeps together — shared gold, shared lives.
+It is a **teaching template**, not a finished game: minimal genre mechanics chosen so each
+one demonstrates a Silt concept. Build your real game by extending it.
+Two parts, deliberately separated in `room.ts`:
+1. **The demo-room lifecycle shell** — the `══ DEMO-ROOM LIFECYCLE SHELL ══` block. Genre-
+   agnostic: the always-warm, tap-and-play room model (drop-in join, take over an abandoned
+   teammate, ready-up → rolling rounds → lose → auto-restart, no lobby). You usually **don't
+   edit this** — you wire your game to its three signals. Spec: `skills/demo-room-lifecycle.md`.
+2. **The tower-defense genre** — everything below the shell. This is what you replace or
+   extend to change the game.
+## The one mental model that matters
+**The server owns truth. Clients submit intent. The room decides.**
+```
+browser ──send(intent)──▶  Go relay ──inputs──▶  room.ts tick()  ──full state──▶ every browser
+                           (WebTransport)        (Bun, 60Hz, deterministic)
+```
+`room.ts` default-exports `{ tick }`. It runs **server-side at 60Hz** inside a deterministic
+realm. Each tick it receives the canonical state + a batch of inputs (joins, leaves, and the
+peers' intent), mutates state, and returns it. The server broadcasts the **entire** returned
+state to every client every tick. Clients never own state — they render what the server sends
+and send intent back. This is why cheating is hard: the client asking to place a tower is
+*intent*; `tick` decides whether it's allowed (occupied? affordable?) and only then is it truth.
+Full model → `skills/authoritative-tick.md`.
+## Code map
+| File | What it is |
+|---|---|
+| `room.ts` | The authoritative contract. Shell block (copy-verbatim) + TD genre. **The game lives here.** |
+| `room.test.ts` | Deterministic contract tests — `tick` is a pure function, so you test it with no browser. Your safety net. |
+| `src/Game.tsx` | The React client. `useRoom(url, { id })` → `{ state, send }`. Renders on `@siltrun/stage`: `createStage` + `cam.fitRect(arena)` + `tapBoard` (tap a slot to place — phone-first). Derives rendering (creep positions, etc.) from state. |
+| `src/main.tsx`, `index.html` | Standard vite entry. |
+| `skills/` | The deep concept docs. Read the one for your change. |
+## Run it + verify your change
+```bash
+npm install
+npm run dev          # boots BOTH halves: `siltrun dev room.ts` (room-info :4000) + vite (:5173)
+```
+Open `http://localhost:5173` in **two windows** — that's your two-player room. Ready up in both
+to start.
+**Verify by observation, not by reading your own diff:**
+- `bun test room.test.ts` — the fast loop, and your **primary** verification. The contract is a
+  pure function; scripted inputs assert truth (membership, phase transitions, placement rules,
+  the state-size budget). It runs with **no install** because the `@siltrun/*` imports are type-only
+  and erased at runtime. When you change mechanics, add/adjust a test and keep it green.
+  - Note: `npm run typecheck` (`tsc`) will NOT work until the `@siltrun/*` packages are published
+    (see the alpha limitation below) — it errors on unresolved modules, not on your code. Don't
+    chase those errors; `bun test` is the real check in the shipped state.
+- Two windows for the live feel. `room.ts` hot-reloads on save (a determinism doctor re-checks
+  each reload) — if it rejects your change as non-deterministic, read `skills/authoritative-tick.md`.
+## ⚠️ Alpha limitation — installing `@siltrun/*`
+At the time this template ships, the `@siltrun/*` packages are **not yet published to npm**, so
+`npm install` here will fail to resolve them. Until the publish lands, consume Silt from a
+local checkout using the workspace path documented in the silt repo's `docs/QUICKSTART.md`
+(clone silt, point your project's `package.json` `workspaces`/deps at `vendor/silt/packages/*`,
+`bun install`, `bun run dev`). The game code in this template is identical either way — only the
+dependency wiring differs. Once the packages are published, the `package.json` here works as-is.
+## Extension recipes — the common moves
+Each is small because the design is small on purpose. Read the cited skill first.
+- **Add a *damage* tower kind** (`skills/state-budget.md`) — append `[cost, range, damage,
+  cooldown]` to `KINDS` in `room.ts`, add a picker button in `Game.tsx`'s `KindPicker` and a
+  glyph branch in the slots draw (the `t.k` switch). The `place` event already carries
+  `kind`; the server already validates cost/slot. That's the whole change — but only because the
+  effect is *damage*, which the existing tower loop already applies.
+- **Add a tower whose effect ISN'T damage** (slow, poison, gold-bonus, chain…) — the one-liner
+  above is NOT enough; that recipe assumes damage. A non-damage effect also means:
+  1. a **new branch in the tower loop** in `stepGame` — the stock loop finds the single nearest
+     creep and damages it. Decide your targeting (nearest-one vs **area/aura over all creeps in
+     range**) and write it; there's no default for "affect everyone in range".
+  2. usually a **new field on `Creep`** to carry the effect (a slow-timer, a poison stack). This
+     spends against the **state budget** — keep the key one char and update the saturated-creep
+     push in `room.test.ts`'s budget test so the guard stays honest. Read `skills/state-budget.md`.
+  3. often a **movement/behavior modifier** elsewhere in `stepGame` that reads that field.
+  4. The `KINDS` tuple is `[cost, range, damage, cooldown]`. If your effect's parameters don't
+     fit (slow factor, duration), the clean move is module constants (`const SLOW_FACTOR = 0.5`),
+     not widening the tuple — leave `damage` at 0 for a pure-effect tower.
+  5. To render the *status* (not just position/hp), you must put the effect field in `State` so
+     the client can read it — a real byte cost you're choosing to pay for the visual. Weigh it
+     against the budget.
+- **Add a creep type** (`skills/waves-and-timing.md`, `skills/state-budget.md`) — add a field to
+  the `Creep` type (keep the key **short** — budget), vary it at spawn in `stepGame`, and branch
+  on it in the tower/movement loops. Render the variant in `Game.tsx`. Mind the byte budget test.
+- **Change the path** — edit the `PATH` waypoint array in `room.ts`. Both the server (movement)
+  and the client (rendering) read the same array, so they stay in sync automatically.
+- **Tune waves / difficulty** (`skills/waves-and-timing.md`) — `WAVES`, `beginWave`'s creep
+  count, `CREEP_SPEED`, `START_GOLD`/`START_LIVES`, hp/bounty in `stepGame`.
+- **Change room rules** (`skills/demo-room-lifecycle.md`) — seats, `minPlayers`, gameover
+  duration live in `SHELL_OPTS`. If you edit the shell block itself, re-read its invariants.
+## Skills index — read the one that fits
+| Skill | Read when you're… |
+|---|---|
+| `skills/authoritative-tick.md` | changing ANY server logic — the tick model, determinism realm, `ctx`, input batch |
+| `skills/two-lanes.md` | sending data from the client — deciding datagram (presence) vs reliable (events) |
+| `skills/waves-and-timing.md` | doing anything time-based — spawns, cooldowns, timers, delays (there is no `setTimeout`) |
+| `skills/state-budget.md` | adding to `State` — the MTU ceiling that caps how much you can broadcast |
+| `skills/demo-room-lifecycle.md` | touching room flow — seats, phases, ready-up, join/leave, or copying the shell |
+## The two hard rules you cannot violate
+1. **Determinism.** No `Date.now()`, `Math.random()`, `fetch`, or timers inside `tick`. Use the
+   injected `ctx` (`ctx.tick`, `ctx.random()`). The doctor enforces this on every reload.
+2. **State budget.** The whole `State` is broadcast in ONE ~1200-byte datagram every tick. Keep
+   it small (short keys, derive don't store). The `room.test.ts` budget test guards it. Details:
+   `skills/state-budget.md`.

package/templates/tower-defense/README.md ADDED Viewed

@@ -0,0 +1,53 @@
+# silt · co-op tower defense
+A co-op tower defense game on [Silt](https://silt.run) — an authoritative server contract
+(`room.ts`) plus a React client (`src/`), one project, one language. Two players share one
+always-warm room: drop in, ready up, and defend a path against waves together.
+**Building on this with a coding agent? Point it at [`AGENTS.md`](./AGENTS.md) first** — it's
+the orientation map, and `skills/` holds the deep concept docs.
+## Run
+```bash
+npm install
+npm run dev
+```
+Boots both halves:
+- **room** — `siltrun dev room.ts`: your contract running authoritatively at 60Hz (room-info on
+  `http://localhost:4000`, WebTransport on `:4433`). Hot-reloads on save.
+- **web** — vite dev server on [http://localhost:5173](http://localhost:5173).
+Open `http://localhost:5173` in **two windows** and ready up in both — that's your game.
+> **Alpha note:** the `@siltrun/*` packages aren't published to npm yet, so `npm install` won't
+> resolve them until the publish lands. Until then, consume Silt from a local checkout per the
+> silt repo's `docs/QUICKSTART.md` (the game code is identical; only dependency wiring differs).
+> See [`AGENTS.md`](./AGENTS.md) → *Alpha limitation*.
+## Test
+```bash
+bun test room.test.ts
+```
+`room.ts` is a deterministic pure function, so the whole game is testable with no browser:
+membership, phase transitions, tower-placement rules, and the state-size budget are all asserted
+by scripted ticks. This is your fast feedback loop — keep it green as you build.
+## What's here
+- `room.ts` — the authoritative contract: a genre-agnostic **demo-room lifecycle shell** (drop-in
+  join, take over an abandoned teammate, ready-up → rolling waves → lose → auto-restart) plus the
+  **tower-defense genre** below it. Replace the genre to build a different game on the same shell.
+- `src/Game.tsx` — the React client, rendered on `@siltrun/stage` (PixiJS): `createStage` +
+  `cam.fitRect(arena)` + `tapBoard` is the whole ceremony — the arena fits any screen and
+  tap-to-place works identically on touch and mouse. Renders state, sends intent, derives
+  creep positions from the shared path.
+- `AGENTS.md` + `skills/` — the teaching layer. Read these to extend the game.
+## Learn more
+- Quickstart, the two lanes, the determinism realm, and the honest limits are the load-bearing
+  docs — read them before designing: https://silt.run/docs

package/templates/tower-defense/_gitignore ADDED Viewed

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+*.log
+.DS_Store

package/templates/tower-defense/index.html ADDED Viewed

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="mobile-web-app-capable" content="yes" />
+    <style>html, body { overscroll-behavior: none; }</style>
+    <title>silt · co-op tower defense</title>
+  </head>
+  <body style="margin: 0; background: #0B0B0D; color: #EAE7DE; font-family: 'Geist', system-ui, sans-serif;">
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/tower-defense/package.json ADDED Viewed

@@ -0,0 +1,31 @@
+{
+  "name": "my-silt-game",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "concurrently -k -n room,web -c yellow,cyan \"siltrun dev room.ts\" \"vite\"",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "bun test room.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@siltrun/stage": "^0.1.0",
+    "pixi.js": "^8.19.0",
+    "@siltrun/client": "^0.3.0",
+    "@siltrun/react": "^0.1.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@siltrun/room": "^0.1.0",
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "concurrently": "^9.0.0",
+    "siltrun": "^0.1.0",
+    "typescript": "^5.6.0",
+    "vite": "^5.4.0"
+  }
+}

package/templates/tower-defense/room.test.ts ADDED Viewed

@@ -0,0 +1,159 @@
+// room.test.ts — the contract is a deterministic pure function, so we verify it by
+// driving tick() with scripted inputs and asserting truth. No browser, no network.
+//   bun test room.test.ts
+import { test, expect } from "bun:test";
+import contract, { type State, type Cmd } from "./room.ts";
+import type { Ctx, Input } from "@siltrun/room";
+// A deterministic Ctx. `random` is seeded + reproducible so spawn jitter is testable.
+function makeCtx(tick: number, seed = 1): Ctx {
+  let s = seed >>> 0;
+  return {
+    tick, dt: 1 / 60, time: tick / 60,
+    random() { s = (s * 1664525 + 1013904223) >>> 0; return s / 2 ** 32; },
+    emit() {},
+  };
+}
+const join = (id: string): Input<Cmd> => ({ kind: "join", id });
+const leave = (id: string, reason: "left" | "timeout" = "left"): Input<Cmd> => ({ kind: "leave", id, reason });
+const ready = (from: string): Input<Cmd> => ({ kind: "event", from, data: { type: "ready" } });
+const place = (from: string, slot: number, kind: number): Input<Cmd> => ({ kind: "event", from, data: { type: "place", slot, kind } });
+/** Drive N ticks with an optional per-tick input supplier. Returns final state. */
+function run(state: State | undefined, ticks: number, at: (t: number) => Input<Cmd>[] = () => [], t0 = 0): State {
+  let s = state as State;
+  for (let i = 0; i < ticks; i++) s = contract.tick(s, at(t0 + i), makeCtx(t0 + i)) as State;
+  return s;
+}
+// ── LIFECYCLE SHELL ──────────────────────────────────────────────────────────────────
+test("first tick seeds a gathering room with empty seats", () => {
+  const s = run(undefined, 1);
+  expect(s.shell.phase).toBe("gathering");
+  expect(s.shell.seats.length).toBe(2);
+  expect(s.shell.seats.every((x) => x.id === null)).toBe(true);
+});
+test("a join claims an empty seat", () => {
+  const s = run(undefined, 1, (t) => (t === 0 ? [join("alice")] : []));
+  expect(s.shell.seats[0].id).toBe("alice");
+});
+test("ready-up of 2 players starts a game (gathering → playing)", () => {
+  const s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : []);
+  expect(s.shell.phase).toBe("playing");
+  expect(s.shell.round).toBe(1);
+  expect(s.wave).toBe(1);
+  expect(s.shell.seats.every((x) => !x.ready)).toBe(true); // ready flags cleared on start
+});
+test("one ready player is NOT enough to start", () => {
+  const s = run(undefined, 5, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice")] : []);
+  expect(s.shell.phase).toBe("gathering");
+});
+test("leaving during gathering frees the seat entirely", () => {
+  const s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [leave("alice")] : []);
+  expect(s.shell.seats[0].id).toBe(null);
+  expect(s.shell.seats[0].abandoned).toBe(false);
+});
+test("leaving DURING play abandons the seat (data kept), and a newcomer takes it over", () => {
+  // start a game
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : [], 0);
+  expect(s.shell.phase).toBe("playing");
+  // alice drops mid-game → seat 0 abandoned, not freed
+  s = contract.tick(s, [leave("alice", "timeout")], makeCtx(100)) as State;
+  expect(s.shell.seats[0].id).toBe("alice");
+  expect(s.shell.seats[0].abandoned).toBe(true);
+  // carol joins mid-game → takes over the abandoned seat (not a new seat; both were full)
+  s = contract.tick(s, [join("carol")], makeCtx(101)) as State;
+  expect(s.shell.seats[0].id).toBe("carol");
+  expect(s.shell.seats[0].abandoned).toBe(false);
+  expect(s.shell.phase).toBe("playing"); // game never paused
+});
+test("reconnect (same id) resumes the seat without a takeover", () => {
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : []);
+  s = contract.tick(s, [leave("alice", "timeout")], makeCtx(50)) as State;
+  expect(s.shell.seats[0].abandoned).toBe(true);
+  s = contract.tick(s, [join("alice")], makeCtx(51)) as State; // same id rejoins
+  expect(s.shell.seats[0].id).toBe("alice");
+  expect(s.shell.seats[0].abandoned).toBe(false);
+});
+test("a third joiner with no free seat spectates (no seat), then seats at next gathering", () => {
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : []);
+  s = contract.tick(s, [join("carol")], makeCtx(80)) as State; // both seats live → spectator
+  expect(s.shell.seats.some((x) => x.id === "carol")).toBe(false);
+});
+test("loss (lives to 0) rolls playing → gameover → a fresh gathering", () => {
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : []);
+  // force a loss without placing any towers: creeps will leak. Fast-forward enough ticks.
+  s = run(s, 4000, () => [], 3);
+  // after a loss the room is back to gathering with a fresh (idle) game and round preserved logic
+  expect(["gathering", "gameover"]).toContain(s.shell.phase);
+  // drive past the gameover countdown to be sure it resets
+  const cont = run(s, 400, () => [], 5000);
+  expect(cont.shell.phase).toBe("gathering");
+  expect(cont.wave).toBe(0); // game cleared on reset
+});
+// ── GENRE: authoritative placement ─────────────────────────────────────────────────
+test("server validates tower placement: rejects occupied slot, bad slot, and unaffordable", () => {
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] : []);
+  const gold0 = s.gold;
+  s = contract.tick(s, [place("alice", 0, 0)], makeCtx(10)) as State; // valid
+  expect(s.towers.length).toBe(1);
+  expect(s.gold).toBe(gold0 - 50);
+  s = contract.tick(s, [place("bob", 0, 0)], makeCtx(11)) as State;   // slot occupied → reject
+  expect(s.towers.length).toBe(1);
+  s = contract.tick(s, [place("bob", 99, 0)], makeCtx(12)) as State;  // bad slot → reject
+  expect(s.towers.length).toBe(1);
+  // drain gold then attempt an unaffordable place
+  s.gold = 10;
+  s = contract.tick(s, [place("bob", 1, 1)], makeCtx(13)) as State;   // costs 90 → reject
+  expect(s.towers.length).toBe(1);
+});
+// ── STATE BUDGET: the whole State must fit one ~1200B datagram (BOUNDARIES §1) ──────
+test("worst-case state serializes under the datagram MTU budget", () => {
+  // Construct a maxed state: full seats, all slots towered, creep array at its cap.
+  let s = run(undefined, 3, (t) =>
+    t === 0 ? [join("aaaaaaaa"), join("bbbbbbbb")] : t === 1 ? [ready("aaaaaaaa"), ready("bbbbbbbb")] : []);
+  // fill every tower slot
+  for (let slot = 0; slot < s.towers.length + 8; slot++) {
+    s = contract.tick(s, [place("aaaaaaaa", slot, 1)], makeCtx(20 + slot)) as State;
+    s.gold = 9999; // keep affordable
+  }
+  // saturate creeps to the cap
+  while (s.creeps.length < 14) s.creeps.push({ i: s.next++, w: 2, t: 0.5, h: 99 });
+  s.cursors = { aaaaaaaa: { x: 0.123, y: 0.456 }, bbbbbbbb: { x: 0.789, y: 0.012 } };
+  const bytes = Buffer.byteLength(JSON.stringify(s), "utf8");
+  console.log(`worst-case state = ${bytes}B (budget ~1100)`);
+  expect(bytes).toBeLessThan(1100);
+});
+// ── DETERMINISM: same inputs + same ctx → identical state ──────────────────────────
+test("tick is deterministic — identical scripted runs produce identical state", () => {
+  const script = (t: number): Input<Cmd>[] =>
+    t === 0 ? [join("alice"), join("bob")] : t === 1 ? [ready("alice"), ready("bob")] :
+    t === 5 ? [place("alice", 0, 0), place("bob", 4, 1)] : [];
+  const a = run(undefined, 300, script);
+  const b = run(undefined, 300, script);
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+});