create-siltrun 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joel Brubaker
+
+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/README.md

@@ -0,0 +1,54 @@
+# create-siltrun
+
+Scaffold a [Silt](https://silt.run) multiplayer project: an authoritative room
+contract and a client, in one directory, wired together and ready to run.
+
+```bash
+npm create siltrun@latest my-game
+cd my-game
+npm install
+npm run dev
+```
+
+`npm run dev` boots both halves at once. Your room runs through the `siltrun` CLI,
+which serves room info on <http://localhost:4000>, and the Vite client runs on
+<http://localhost:5173>. Open the client in two windows and you have a multiplayer
+room. Edit `room.ts` and both sides reload.
+
+The project directory is required. Running the command with no directory prints
+usage and exits.
+
+## Templates
+
+```bash
+npm create siltrun@latest my-game -- --template tower-defense
+```
+
+| Template | What you get |
+|---|---|
+| `minimal` | The default. The smallest real room: each player moves a ship by tapping a target, the server clamps that intent and eases the ship toward it, and every client renders the same authoritative state. |
+| `tower-defense` | Co-op tower defense. Two players share one always-warm room, ready up, and defend a path against waves together. |
+| `mass-grid` | Territory capture in the Paper.io style. Leave your land to draw a trail, loop back to claim what you enclosed, cut a rival by crossing their trail. |
+| `turn-based-grid` | A starter for agent-first games: a deterministic world that agents play and humans watch, with an action API, an ASCII view alongside the graphics view, an emote channel, and scripted stub agents to prove it. |
+
+An unknown template name fails immediately and lists the ones that exist.
+
+## What you get
+
+```
+my-game/
+  room.ts            your contract: tick(state, inputs), runs server-side at 60Hz
+  src/               the client, built on @siltrun/react and @siltrun/stage
+  package.json       a dev script that runs the room and Vite together
+```
+
+`room.ts` is the whole server. It default-exports a `tick(state, inputs)` function
+that runs 60 times a second and owns the truth. Clients send intent; the tick
+decides what actually happens.
+
+This is a plain Node initializer with no dependencies of its own, so it runs
+anywhere `npm create` does.
+
+## Docs
+
+Full guides and API reference: <https://silt.run/docs/>

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "create-siltrun",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "license": "MIT",
   "description": "Scaffold a Silt multiplayer project — `npm create siltrun my-game`.",
   "type": "module",
   "bin": {
     "create-siltrun": "index.mjs"
   },
-  "files": ["index.mjs", "templates"],
-  "repository": "https://github.com/digitalpine/silt",
+  "files": [
+    "index.mjs",
+    "templates"
+  ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
     "test": "node --test",
     "typecheck": "true"
-  }
+  },
+  "homepage": "https://silt.run"
 }

package/templates/mass-grid/AGENTS.md

@@ -50,7 +50,7 @@ server sends and send intent back. This is why cheating is hard: a client asking
   understand before you touch `State`.** → `skills/compact-snapshots.md`.
 - **The genre picks the lane.** Moves ride the *reliable* lane, not the presence datagram lane,
   because a slow discrete grid game wants ordered, no-drop turns (a dropped turn is a death).
-  **Ratified amendment (DIG-763): a room that opts into client-side prediction moves its
+  **Amendment: a room that opts into client-side prediction moves its
   steering to the INPUT lane as held intent** — only input-envelope seqs are acked, so only
   they can reconcile. → `skills/genre-lane-mapping.md` (incl. the prediction amendment).
 

package/templates/mass-grid/skills/genre-lane-mapping.md

@@ -55,7 +55,7 @@ ack map would be pure dead weight on a datagram budget this genre already pushes
 empty and is dropped from the wire entirely. The lane choice that is *correct for the genre* is
 also the one that *reclaims budget*. That is not a coincidence you should fight.
 
-## The prediction amendment (DIG-763, ratified 2026-07-21)
+## The prediction amendment
 
 The rule above has one ratified exception: **a room that opts into client-side prediction
 puts its steering on the INPUT (datagram) lane — even discrete steering.** Prediction's

package/templates/turn-based-grid/room.ts

@@ -3,7 +3,7 @@
 // intent on the reliable lane; this tick() decides what actually happens; every peer
 // (playing agents + spectating humans) receives the resulting State each tick.
 //
-// THE TICK / BEAT MODEL (DIG-725, the load-bearing decision) ─────────────────────────
+// THE TICK / BEAT MODEL (the load-bearing decision) ─────────────────────────
 //
 //   • The relay clock is a constant 60Hz and never pauses while ≥1 peer is present.
 //     We do NOT fight it. On top of it we quantize turns into BEATS of BEAT_TICKS ticks.

package/templates/turn-based-grid/src/brains.ts

@@ -1,7 +1,7 @@
 // brains.ts — scripted stub agents. Each brain is a pure decision function over the
 // AGENT PERCEPTION (the rendered ASCII string) — it never sees State. That constraint
 // is the whole point: if these can play from text alone, the substrate is sufficient,
-// and the same brain lifts behind a real MCP agent later (DIG-718) unchanged.
+// and the same brain lifts behind a real MCP agent later unchanged.
 //
 // The four brains double as the substrate's live demonstrators:
 //   greedy — competent play (walks to the nearest pellet)

package/templates/turn-based-grid/src/stubAgent.ts

@@ -1,7 +1,7 @@
 // stubAgent.ts — a scripted agent as a REAL Silt client. It opens its own joinRoom
 // connection (exactly like the drift diag two-connection pattern), so from the room's
 // point of view it is indistinguishable from any other peer — and from a real MCP-driven
-// agent later (DIG-718). The only difference is the brain: scripted here, an LLM there.
+// agent later. The only difference is the brain: scripted here, an LLM there.
 //
 // The read→think→act loop is deliberately faithful to real agent latency:
 //   1. snapshot the latest received State,

package/templates/turn-based-grid/src/substrate/map.ts

@@ -6,7 +6,7 @@
 
 import type { Dir, Pos } from "./types.ts";
 
-// ── The tick / beat model constants (the load-bearing design, DIG-725) ──
+// ── The tick / beat model constants (the load-bearing design) ──
 //
 // The relay's world clock runs at a fixed 60 ticks/sec and never pauses while ≥1 peer
 // is present. On top of that constant clock we quantize turns into BEATS.