@netforge/template-cards 0.0.0-stage → 0.2.0

package/client/names.ts

@@ -0,0 +1,58 @@
+/**
+ * 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). Cards are the "weapons" table ({ name, line }).
+ */
+export const TITLE = "Inkwrit";
+
+export const WEAPON_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  blot_imp: { name: "Blot Imp", line: "Small and spiteful" },
+  quill_sprite: { name: "Quill Sprite", line: "Strikes at once" },
+  ink_frog: { name: "Ink Frog", line: "Sturdy for its cost" },
+  margin_bat: { name: "Margin Bat", line: "Strikes at once" },
+  ledger_crab: { name: "Ledger Crab", line: "Guards your hero" },
+  serif_fox: { name: "Serif Fox", line: "Draws a card" },
+  gloss_wolf: { name: "Gloss Wolf", line: "A solid hunter" },
+  stamp_golem: { name: "Stamp Golem", line: "A wall of ink" },
+  folio_wyrm: { name: "Folio Wyrm", line: "Scorches every foe" },
+  grand_errata: { name: "Grand Errata", line: "The last word" },
+  splash: { name: "Splash", line: "2 damage" },
+  blotting_sand: { name: "Blotting Sand", line: "Heal your hero 5" },
+  underline: { name: "Underline", line: "+2/+2 to a unit" },
+  second_draft: { name: "Second Draft", line: "Draw two cards" },
+  ink_storm: { name: "Ink Storm", line: "2 to every foe" },
+  final_word: { name: "Final Word", line: "5 damage" },
+};
+
+export const UPGRADE_NAMES: Readonly<Record<string, { name: string; line: string }>> = {
+  thick_vellum: { name: "Thick Vellum", line: "+5 hero health" },
+  sharp_nib: { name: "Sharp Nib", line: "+1 attack on your units" },
+  quick_ink: { name: "Quick Ink", line: "+1 mana in your first turn" },
+  spare_page: { name: "Spare Page", line: "+1 card in your first hand" },
+};
+
+// Creatures by prefab id (the duel has none; a game that adds them labels them here).
+export const ENEMY_NAMES: Readonly<Record<string, string>> = {
+};
+
+export const RULE_NAMES: Readonly<Record<string, string>> = {
+  first_ink: "First Ink",
+  full_gauntlet: "Full Gauntlet",
+  inked_duel: "Inked Duel",
+  signed_and_sealed: "Signed and Sealed",
+};
+
+export const SKU_NAMES: Readonly<Record<string, string>> = {
+  thick_vellum: "Thick Vellum",
+  sharp_nib: "Sharp Nib",
+  quick_ink: "Quick Ink",
+  spare_page: "Spare Page",
+  skin_vermilion: "Vermilion quill",
+  skin_gold_leaf: "Gold leaf quill",
+  bound_folio: "Bound folio",
+};
+
+/** Player colours by slot, and a highlight palette (the generated names module carries both). */
+export const KEEPER_COLORS = [0x2f5d8a, 0xb2382e, 0x3f7a4a, 0x8a5a2b, 0x6b4a8a, 0xc9a227, 0x2a7a7a, 0x8a2a5a];
+export const AURORA = { body: 0x3cf2c4, glow: 0xa77bff };

package/llms-full.txt

@@ -0,0 +1,243 @@
+# Net Forge card battler template (INKWRIT)
+
+> A one-against-one card battler. Two scribes duel at a desk: heroes with
+> health, ink (mana) that rises each turn, a hand drawn from a shuffled
+> deck, inked creatures on the board, spells. A run is a gauntlet of
+> duels; after each one, every player drafts one of three cards into
+> their deck. Alone, an AI scribe of the gauntlet takes the other seat.
+> You change the game by editing src/game.ts only. The template already has
+> the duel, turns and the turn timer, the shuffle (on the server), hidden
+> hands, guards, rush, the draft, the AI, netcode, rendering, touch,
+> earn and the store. Do not write renderers, netcode or AI.
+
+## Files
+
+- src/game.ts: THE GAME. Declarations against @netforge/engine:
+  game(), cardTable(), card(), upgrade(), earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label players read. Cards go in
+  "weapons" ({ name, line }), plus upgrades, earn rules and store items.
+- Everything else is template machinery.
+
+## Rules the build enforces
+
+- game({ template: "cards", style, places, players: { prefab, max } }), players.max at most 2.
+- Exactly one cardTable(...); 4 to 40 card(...)s. The starter deck (8 to 30
+  cards) names declared cards, holds at least one unit and cards costing 2
+  or less. ai is 1 to 12 tiers { health, smart }.
+- A unit has health 1 or more; a spell has an effect.
+- Effects: kind "damage", "heal", "draw" or "buff"; target "enemy" (the
+  player picks an enemy unit or the hero), "enemy_hero", "all_enemies",
+  "own_hero", "own_unit" (the player picks one of theirs) or "all_own".
+- Upgrades read four stats only: maxHealth (hero health), might (+attack on
+  the buyer's units), haste (+ink in the first turn), amount (+cards in
+  the first hand).
+- No weapon(...). Asset ids look like "style.lowpoly.frog"; keep game({ style }).
+- 2 playtest players must decide duels and fire an earn rule within 4 minutes.
+
+## Units
+
+Health and attack in points, cost in ink (0 to 10), seconds for timers.
+Tick rate 30 Hz.
+
+## The loop
+
+A duel: a coin decides who goes first; the second player draws one extra
+card. Each turn: +1 ink (up to manaMax), draw a card (an empty deck hurts
+more each time), play cards, attack with ready units (a unit is ready the
+turn after it lands, or at once with rush; guard units must be attacked
+first), end the turn (or the timer ends it). A hero at 0 loses; turnCap
+turns is a draw. After each duel but the last, a draft: one of three.
+
+## Common changes
+
+### A new card
+card("mirror_moth", { model: "style.lowpoly.jelly_flyer", kind: "unit", cost: 3, attack: 2, health: 2, effect: { kind: "damage", amount: 1, target: "all_enemies" } });
+Add its label to names.json weapons. The draft offers every card unless cardTable pool lists some.
+
+### Tune the table
+cardTable({ health: 25, duels: 5, turnSeconds: 40, ... }). Lower health
+makes faster duels; more duels make longer runs.
+
+### Harder or easier AI
+ai: [{ health: 14, smart: 0.3 }, ...]: duel n against the AI uses tier n;
+raise health and smart for a harder gauntlet.
+
+### Earn rules
+earn.rule("ink_master", { when: "ai.beaten", n: 3, pay: 15, oncePer: "run" });
+Events: duel.won (a duel won against a person; never against the AI, never
+a forfeit), ai.beaten (a gauntlet AI scribe beaten; a forfeit pays
+nothing), run.won (more duels won than lost in the run). Each rule pays
+once per run per player, in coins; the room server is the referee; the AI
+scribe never earns.
+
+### The buy-in run (required)
+earn.stake({ min: 10, max: 100, multiple: 2 }); one top-level line. "stake" is reserved.
+
+### Coins: earn and the store
+store.sku("thick_vellum", { coins: 40 });                            // one level of the upgrade for the run
+store.sku("skin_gold_leaf", { coins: 500, grants: { cosmetic: 2 } }); // a finish for your quill, owned for good
+store.sku("bound_folio", { coins: 120, grants: { gear: "thick_vellum", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (thick_vellum, sharp_nib, quick_ink,
+spare_page, skin_vermilion, skin_gold_leaf, bound_folio) at their prices.
+
+## Hidden information
+
+Decks are shuffled on the room server and their order never leaves it; a
+hand and a draft offer are sent only to their owner. Nothing in game.ts
+can change that.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 2 }) plays duels between two
+players (bots: 1 plays one person against the AI) and reports duels won
+(kills) and lost (deaths), the duel reached (wave), runs, earned by rule,
+softlock, ms per tick and the genre's checks 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
+/**
+ * INKWRIT: the card battler template (play style:
+ * card battler).
+ *
+ * Scribes duel in a lamplit study. Every card is an inked creature or a
+ * spell written on a page: blot imps, ledger crabs, folio wyrms, a splash
+ * of ink. One against one, a person against a person or against the
+ * gauntlet's AI scribes. A run is four duels; after each, you draft one of
+ * three new cards into your deck.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine. The duel, the draft, the
+ * shuffle, hidden hands, the AI, netcode, renderer and referee are the
+ * template's machinery.
+ */
+import { card, cardTable, earn, game, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "cards",
+  style: "lowpoly",
+  places: { study: { chunks: "places/study", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.hooded_adventurer", max: 2 },
+});
+
+// The table: hero health, hands, the board, the gauntlet and its AI scribes (tier n plays duel n against the AI).
+cardTable({
+  health: 20,
+  startHand: 3,
+  handMax: 7,
+  boardMax: 5,
+  manaMax: 10,
+  turnSeconds: 30,
+  draftSeconds: 15,
+  duels: 4,
+  starter: ["blot_imp", "blot_imp", "quill_sprite", "quill_sprite", "ink_frog", "ink_frog", "margin_bat", "ledger_crab", "serif_fox", "splash", "splash", "blotting_sand"],
+  ai: [
+    { health: 14, smart: 0.3 },
+    { health: 16, smart: 0.55 },
+    { health: 20, smart: 0.75 },
+    { health: 24, smart: 0.9 },
+  ],
+});
+
+// Units: cost in mana, attack and health. guard units must be attacked first; rush units attack the turn they land.
+card("blot_imp", { model: "style.lowpoly.imp", kind: "unit", cost: 1, attack: 2, health: 1 });
+card("quill_sprite", { model: "style.lowpoly.bee", kind: "unit", cost: 1, attack: 1, health: 2, rush: true });
+card("ink_frog", { model: "style.lowpoly.frog", kind: "unit", cost: 2, attack: 2, health: 3 });
+card("margin_bat", { model: "style.lowpoly.bat", kind: "unit", cost: 2, attack: 3, health: 1, rush: true });
+card("ledger_crab", { model: "style.lowpoly.crab", kind: "unit", cost: 3, attack: 2, health: 5, guard: true });
+card("serif_fox", { model: "style.lowpoly.fox", kind: "unit", cost: 3, attack: 3, health: 3, effect: { kind: "draw", amount: 1 } });
+card("gloss_wolf", { model: "style.lowpoly.wolf", kind: "unit", cost: 4, attack: 4, health: 4 });
+card("stamp_golem", { model: "style.lowpoly.yeti", kind: "unit", cost: 5, attack: 4, health: 7, guard: true });
+card("folio_wyrm", { model: "style.lowpoly.dragon_whelp", kind: "unit", cost: 6, attack: 5, health: 5, effect: { kind: "damage", amount: 2, target: "all_enemies" } });
+card("grand_errata", { model: "style.lowpoly.dragon", kind: "unit", cost: 8, attack: 8, health: 8 });
+// Spells: an effect only. "enemy" lets the player pick an enemy unit or the hero.
+card("splash", { model: "style.lowpoly.crystal", kind: "spell", cost: 1, effect: { kind: "damage", amount: 2, target: "enemy" } });
+card("blotting_sand", { model: "style.lowpoly.gem_mid", kind: "spell", cost: 2, effect: { kind: "heal", amount: 5, target: "own_hero" } });
+card("underline", { model: "style.lowpoly.gem_pink", kind: "spell", cost: 2, effect: { kind: "buff", amount: 2, target: "own_unit" } });
+card("second_draft", { model: "style.lowpoly.chest", kind: "spell", cost: 3, effect: { kind: "draw", amount: 2 } });
+card("ink_storm", { model: "style.lowpoly.meteor", kind: "spell", cost: 4, effect: { kind: "damage", amount: 2, target: "all_enemies" } });
+card("final_word", { model: "style.lowpoly.crystal_rock", kind: "spell", cost: 5, effect: { kind: "damage", amount: 5, target: "enemy" } });
+
+// Store upgrades: one level each, for the rest of the run (hero health, unit attack, first-turn mana, starting hand).
+upgrade("thick_vellum", { stat: "maxHealth", step: 5, maxLevel: 1 });
+upgrade("sharp_nib", { stat: "might", step: 1, maxLevel: 1 });
+upgrade("quick_ink", { stat: "haste", step: 1, maxLevel: 1 });
+upgrade("spare_page", { stat: "amount", step: 1, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once per run each. Values are PLACEHOLDER.
+// duel.won counts duels won against a person (never against the AI, never a forfeit); ai.beaten counts gauntlet AI scribes beaten.
+earn.rule("first_ink", { when: "ai.beaten", n: 1, pay: 5, oncePer: "run" });
+earn.rule("full_gauntlet", { when: "ai.beaten", n: 4, pay: 20, oncePer: "run" });
+earn.rule("inked_duel", { when: "duel.won", n: 1, pay: 12, oncePer: "run" });
+earn.rule("signed_and_sealed", { when: "duel.won", n: 3, pay: 25, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at run start to earn above free play. Values are PLACEHOLDER.
+earn.stake({ min: 10, max: 100, multiple: 2 });
+
+// Store (the Kit), priced in coins: four run upgrades and two finishes for your quill, owned for good.
+store.sku("thick_vellum", { coins: 40 });
+store.sku("sharp_nib", { coins: 60 });
+store.sku("quick_ink", { coins: 40 });
+store.sku("spare_page", { coins: 50 });
+store.sku("skin_vermilion", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_gold_leaf", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: one level of its upgrade in every staked run, lost when that run makes under loseBelow of its most earn. PLACEHOLDER.
+store.sku("bound_folio", { coins: 120, grants: { gear: "thick_vellum", 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 two players for 4 minutes at 30 Hz (bots: 1 plays one person against the AI).
+
+```ts
+import { engine } from "@netforge/engine";
+import "./src/game.js";
+
+const report = await engine.test.run({
+  ticks: 30 * 240,
+  bots: 2,
+  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 duels won (kills) and lost (deaths), the duel reached (wave), runs, earned by rule, softlock, ms per tick and the genre's checks 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-cards
+echo '{"template":"cards"}' > 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,94 @@
+# Net Forge card battler template (INKWRIT)
+
+> A one-against-one card battler. Two scribes duel at a desk: heroes with
+> health, ink (mana) that rises each turn, a hand drawn from a shuffled
+> deck, inked creatures on the board, spells. A run is a gauntlet of
+> duels; after each one, every player drafts one of three cards into
+> their deck. Alone, an AI scribe of the gauntlet takes the other seat.
+> You change the game by editing src/game.ts only. The template already has
+> the duel, turns and the turn timer, the shuffle (on the server), hidden
+> hands, guards, rush, the draft, the AI, netcode, rendering, touch,
+> earn and the store. Do not write renderers, netcode or AI.
+
+## Files
+
+- src/game.ts: THE GAME. Declarations against @netforge/engine:
+  game(), cardTable(), card(), upgrade(), earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label players read. Cards go in
+  "weapons" ({ name, line }), plus upgrades, earn rules and store items.
+- Everything else is template machinery.
+
+## Rules the build enforces
+
+- game({ template: "cards", style, places, players: { prefab, max } }), players.max at most 2.
+- Exactly one cardTable(...); 4 to 40 card(...)s. The starter deck (8 to 30
+  cards) names declared cards, holds at least one unit and cards costing 2
+  or less. ai is 1 to 12 tiers { health, smart }.
+- A unit has health 1 or more; a spell has an effect.
+- Effects: kind "damage", "heal", "draw" or "buff"; target "enemy" (the
+  player picks an enemy unit or the hero), "enemy_hero", "all_enemies",
+  "own_hero", "own_unit" (the player picks one of theirs) or "all_own".
+- Upgrades read four stats only: maxHealth (hero health), might (+attack on
+  the buyer's units), haste (+ink in the first turn), amount (+cards in
+  the first hand).
+- No weapon(...). Asset ids look like "style.lowpoly.frog"; keep game({ style }).
+- 2 playtest players must decide duels and fire an earn rule within 4 minutes.
+
+## Units
+
+Health and attack in points, cost in ink (0 to 10), seconds for timers.
+Tick rate 30 Hz.
+
+## The loop
+
+A duel: a coin decides who goes first; the second player draws one extra
+card. Each turn: +1 ink (up to manaMax), draw a card (an empty deck hurts
+more each time), play cards, attack with ready units (a unit is ready the
+turn after it lands, or at once with rush; guard units must be attacked
+first), end the turn (or the timer ends it). A hero at 0 loses; turnCap
+turns is a draw. After each duel but the last, a draft: one of three.
+
+## Common changes
+
+### A new card
+card("mirror_moth", { model: "style.lowpoly.jelly_flyer", kind: "unit", cost: 3, attack: 2, health: 2, effect: { kind: "damage", amount: 1, target: "all_enemies" } });
+Add its label to names.json weapons. The draft offers every card unless cardTable pool lists some.
+
+### Tune the table
+cardTable({ health: 25, duels: 5, turnSeconds: 40, ... }). Lower health
+makes faster duels; more duels make longer runs.
+
+### Harder or easier AI
+ai: [{ health: 14, smart: 0.3 }, ...]: duel n against the AI uses tier n;
+raise health and smart for a harder gauntlet.
+
+### Earn rules
+earn.rule("ink_master", { when: "ai.beaten", n: 3, pay: 15, oncePer: "run" });
+Events: duel.won (a duel won against a person; never against the AI, never
+a forfeit), ai.beaten (a gauntlet AI scribe beaten; a forfeit pays
+nothing), run.won (more duels won than lost in the run). Each rule pays
+once per run per player, in coins; the room server is the referee; the AI
+scribe never earns.
+
+### The buy-in run (required)
+earn.stake({ min: 10, max: 100, multiple: 2 }); one top-level line. "stake" is reserved.
+
+### Coins: earn and the store
+store.sku("thick_vellum", { coins: 40 });                            // one level of the upgrade for the run
+store.sku("skin_gold_leaf", { coins: 500, grants: { cosmetic: 2 } }); // a finish for your quill, owned for good
+store.sku("bound_folio", { coins: 120, grants: { gear: "thick_vellum", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (thick_vellum, sharp_nib, quick_ink,
+spare_page, skin_vermilion, skin_gold_leaf, bound_folio) at their prices.
+
+## Hidden information
+
+Decks are shuffled on the room server and their order never leaves it; a
+hand and a draft offer are sent only to their owner. Nothing in game.ts
+can change that.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 2 }) plays duels between two
+players (bots: 1 plays one person against the AI) and reports duels won
+(kills) and lost (deaths), the duel reached (wave), runs, earned by rule,
+softlock, ms per tick and the genre's checks under rules.checks.

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "@netforge/template-cards",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Card battler game template for Net Forge: one against one or against the AI, a gauntlet of duels with drafts, server-side shuffle and hidden hands (INKWRIT).",
+  "keywords": [
+    "game-template",
+    "multiplayer",
+    "browser-game",
+    "html5-game",
+    "threejs",
+    "game-engine",
+    "typescript",
+    "gamedev",
+    "ai-agents",
+    "mcp",
+    "net-forge",
+    "card-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/cards",
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netnetdev/net-forge.git",
+    "directory": "packages/template-cards"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "three": "0.186.1",
+    "@netforge/asset-library": "0.2.0",
+    "@netforge/engine": "0.2.0",
+    "@netforge/engine-sim": "0.2.0",
+    "@netforge/tabletop": "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/game.ts

@@ -0,0 +1,86 @@
+/**
+ * INKWRIT: the card battler template (play style:
+ * card battler).
+ *
+ * Scribes duel in a lamplit study. Every card is an inked creature or a
+ * spell written on a page: blot imps, ledger crabs, folio wyrms, a splash
+ * of ink. One against one, a person against a person or against the
+ * gauntlet's AI scribes. A run is four duels; after each, you draft one of
+ * three new cards into your deck.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine. The duel, the draft, the
+ * shuffle, hidden hands, the AI, netcode, renderer and referee are the
+ * template's machinery.
+ */
+import { card, cardTable, earn, game, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "cards",
+  style: "lowpoly",
+  places: { study: { chunks: "places/study", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.hooded_adventurer", max: 2 },
+});
+
+// The table: hero health, hands, the board, the gauntlet and its AI scribes (tier n plays duel n against the AI).
+cardTable({
+  health: 20,
+  startHand: 3,
+  handMax: 7,
+  boardMax: 5,
+  manaMax: 10,
+  turnSeconds: 30,
+  draftSeconds: 15,
+  duels: 4,
+  starter: ["blot_imp", "blot_imp", "quill_sprite", "quill_sprite", "ink_frog", "ink_frog", "margin_bat", "ledger_crab", "serif_fox", "splash", "splash", "blotting_sand"],
+  ai: [
+    { health: 14, smart: 0.3 },
+    { health: 16, smart: 0.55 },
+    { health: 20, smart: 0.75 },
+    { health: 24, smart: 0.9 },
+  ],
+});
+
+// Units: cost in mana, attack and health. guard units must be attacked first; rush units attack the turn they land.
+card("blot_imp", { model: "style.lowpoly.imp", kind: "unit", cost: 1, attack: 2, health: 1 });
+card("quill_sprite", { model: "style.lowpoly.bee", kind: "unit", cost: 1, attack: 1, health: 2, rush: true });
+card("ink_frog", { model: "style.lowpoly.frog", kind: "unit", cost: 2, attack: 2, health: 3 });
+card("margin_bat", { model: "style.lowpoly.bat", kind: "unit", cost: 2, attack: 3, health: 1, rush: true });
+card("ledger_crab", { model: "style.lowpoly.crab", kind: "unit", cost: 3, attack: 2, health: 5, guard: true });
+card("serif_fox", { model: "style.lowpoly.fox", kind: "unit", cost: 3, attack: 3, health: 3, effect: { kind: "draw", amount: 1 } });
+card("gloss_wolf", { model: "style.lowpoly.wolf", kind: "unit", cost: 4, attack: 4, health: 4 });
+card("stamp_golem", { model: "style.lowpoly.yeti", kind: "unit", cost: 5, attack: 4, health: 7, guard: true });
+card("folio_wyrm", { model: "style.lowpoly.dragon_whelp", kind: "unit", cost: 6, attack: 5, health: 5, effect: { kind: "damage", amount: 2, target: "all_enemies" } });
+card("grand_errata", { model: "style.lowpoly.dragon", kind: "unit", cost: 8, attack: 8, health: 8 });
+// Spells: an effect only. "enemy" lets the player pick an enemy unit or the hero.
+card("splash", { model: "style.lowpoly.crystal", kind: "spell", cost: 1, effect: { kind: "damage", amount: 2, target: "enemy" } });
+card("blotting_sand", { model: "style.lowpoly.gem_mid", kind: "spell", cost: 2, effect: { kind: "heal", amount: 5, target: "own_hero" } });
+card("underline", { model: "style.lowpoly.gem_pink", kind: "spell", cost: 2, effect: { kind: "buff", amount: 2, target: "own_unit" } });
+card("second_draft", { model: "style.lowpoly.chest", kind: "spell", cost: 3, effect: { kind: "draw", amount: 2 } });
+card("ink_storm", { model: "style.lowpoly.meteor", kind: "spell", cost: 4, effect: { kind: "damage", amount: 2, target: "all_enemies" } });
+card("final_word", { model: "style.lowpoly.crystal_rock", kind: "spell", cost: 5, effect: { kind: "damage", amount: 5, target: "enemy" } });
+
+// Store upgrades: one level each, for the rest of the run (hero health, unit attack, first-turn mana, starting hand).
+upgrade("thick_vellum", { stat: "maxHealth", step: 5, maxLevel: 1 });
+upgrade("sharp_nib", { stat: "might", step: 1, maxLevel: 1 });
+upgrade("quick_ink", { stat: "haste", step: 1, maxLevel: 1 });
+upgrade("spare_page", { stat: "amount", step: 1, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once per run each. Values are PLACEHOLDER.
+// duel.won counts duels won against a person (never against the AI, never a forfeit); ai.beaten counts gauntlet AI scribes beaten.
+earn.rule("first_ink", { when: "ai.beaten", n: 1, pay: 5, oncePer: "run" });
+earn.rule("full_gauntlet", { when: "ai.beaten", n: 4, pay: 20, oncePer: "run" });
+earn.rule("inked_duel", { when: "duel.won", n: 1, pay: 12, oncePer: "run" });
+earn.rule("signed_and_sealed", { when: "duel.won", n: 3, pay: 25, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at run start to earn above free play. Values are PLACEHOLDER.
+earn.stake({ min: 10, max: 100, multiple: 2 });
+
+// Store (the Kit), priced in coins: four run upgrades and two finishes for your quill, owned for good.
+store.sku("thick_vellum", { coins: 40 });
+store.sku("sharp_nib", { coins: 60 });
+store.sku("quick_ink", { coins: 40 });
+store.sku("spare_page", { coins: 50 });
+store.sku("skin_vermilion", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_gold_leaf", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: one level of its upgrade in every staked run, lost when that run makes under loseBelow of its most earn. PLACEHOLDER.
+store.sku("bound_folio", { coins: 120, grants: { gear: "thick_vellum", 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, cardsGenre } from "@netforge/engine/rules";
+import type { RulesInput, RulesWorld, CardsState } 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 = "inkwrit-0.1.0";
+export const GAME_NAME = "inkwrit";
+/** Room template (as the Net Forge room server names it) and place used by the client and the bots. */
+export const TEMPLATE = "cards";
+export const PLACE = "study";
+
+/**
+ * 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 cardsGenre> | null = null;
+
+/** The game's manifest (every declaration). */
+export function cardsManifest(): GameManifest {
+  return MANIFEST;
+}
+
+/** The compiled card battler genre (table, cards, AI). */
+export function cardsGame(): ReturnType<typeof cardsGenre> {
+  genre ??= cardsGenre(MANIFEST);
+  return genre;
+}
+
+/** The SimAdapter the room server and the client both run. */
+export function cardsAdapter(): SimAdapter<RulesWorld<CardsState>, RulesInput> {
+  return rulesAdapter(cardsGame(), 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_vermilion: 1, skin_gold_leaf: 2 };

package/src/store.ts

@@ -0,0 +1,24 @@
+/**
+ * Store hooks (the Coins model): every
+ * game has coins, 1 coin = 1 game token, shown under the token's own name,
+ * symbol and logo. INKWRIT sells four run upgrades (a store command named
+ * after the upgrade grants one level for the rest of the run), two quill
+ * finishes (permanent) and one piece of losable gear, all priced in coins.
+ * The Kit bridge and its in-memory stand-in live 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 = { thick_vellum: 40, sharp_nib: 60, quick_ink: 40, spare_page: 50, skin_vermilion: 300, skin_gold_leaf: 500, bound_folio: 120 } as const;
+/** Run upgrades: spent, applied by the room for the rest of the run. */
+export const UPGRADE_SKUS = ["thick_vellum", "sharp_nib", "quick_ink", "spare_page"] as const;
+/** Cosmetic finishes: bought once, owned for good. */
+export const COSMETIC_SKUS = ["skin_vermilion", "skin_gold_leaf"] as const;
+
+/** The template's own coin, as its token metadata names it until a creator renames it. */
+export const INKWRIT_COIN = {
+  name: "Ink",
+  symbol: "INK",
+  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='%231f3550'/%3E%3Cpath d='M16 5c4 6 7 10 7 14a7 7 0 0 1-14 0c0-4 3-8 7-14z' fill='%23e8dcc0'/%3E%3C/svg%3E",
+} as const;