@netforge/template-dungeon 0.0.0-stage → 0.2.0

package/llms.txt

@@ -0,0 +1,398 @@
+# Net Forge co-op dungeon template (CRYPTWICK)
+
+> A co-op dungeon crawl for up to 4 players: a procedural crypt of rooms
+> from a seed, rooms that wake as the party nears them, loot in every
+> cleared room, a mini-boss on the way down and a boss in the deepest
+> room. Runs are permadeath: a wipe ends the descent. You change the game
+> by editing src/game.ts only. The template already has the crypt's walls
+> and floors, enemies that path through doors, weapons, XP shards,
+> level-ups, bosses, co-op revive, netcode, rendering, touch controls, earn
+> and the store. Do not write renderers, netcode or physics.
+
+## Files
+
+- src/game.ts: THE GAME. Declarations against @netforge/engine:
+  dungeon(), game(), prefab(), weapon(), upgrade(), system(), earn.rule(),
+  earn.stake(), store.sku(), keeper(), achievement(), mission(), title().
+- packages/engine/GAME-DESIGN.md: the design rules the playtest gate scores
+  (a readable opening, off-screen spawns, i-frames, telegraphs, fast levels).
+- client/names.ts: display names for weapon, upgrade and earn ids (labels).
+- Models come from the asset library (real CC0 models; the full list of ids is in your instructions). client/library.ts holds the fallback shapes drawn until a model loads.
+- Everything else is template machinery.
+
+## Rules the build enforces
+
+- Asset ids look like "style.lowpoly.skeleton", never URLs or paths, and must be in the asset library.
+- game({ style }) is the art style the creator picked: lowpoly, toon, ps1, pixel, voxel or handdrawn. Keep it. The template draws everything in it, and a "style.lowpoly.<name>" id draws as that style's own model of the same name when the style has one.
+- game({ template: "dungeon" }) and game({ field: CRYPT.field }): the crypt comes from dungeon(...).
+- Ids are lower_snake_case.
+- Every game declares at least one earn.rule (mandatory earn) and one earn.stake (the buy-in run).
+- A dungeon game needs one enemy prefab, one weapon and players.weapon (or keepers).
+- Drops must be pickup prefabs. At most 15 weapons (evolutions count) and 8 upgrades.
+- Run `pnpm --filter @netforge/template-dungeon test` (playtest bots).
+
+## Units
+
+Seconds, metres, metres per second, hit points. Tick rate 30 Hz.
+Wickbearers run at 7 m/s; keep chasers at 3-4 m/s and fast ones under 6.
+
+## The crypt: dungeon(...)
+
+const CRYPT = dungeon({ seed: 2026, rooms: 10, cell: 24, size: [12, 18], corridor: 6, loops: 2 });
+game({ template: "dungeon", ..., field: CRYPT.field });
+
+- seed: any whole number; a different seed is a different floor plan.
+- rooms: 3 to 20 (the start room and the boss room included). About 10
+  makes a 6 to 10 minute descent.
+- cell: room spacing in metres (16 to 32); size: [smallest, largest] room
+  side in metres (at most cell - 4); corridor: corridor width in metres
+  (6 lets a boss through; 4 is tight); loops: extra doors that make loops.
+- The start room is centred on [0, 0], where the party spawns. The deepest
+  room (most doors from the start) is CRYPT.boss.
+- CRYPT.rooms: each room's centre (x, z), half sizes (hx, hz), depth (doors
+  from the start) and links (the rooms it has a corridor to).
+  CRYPT.roomAt(x, z) is the room holding a point, or -1 in a corridor.
+- The same spec gives the same crypt on the room server, in every client
+  and in the playtest; nothing is downloaded.
+- Walls stop players, enemies and bolts. Enemies behind a wall walk round
+  through the doors (a flow field), big bodies included.
+
+## The crawl (the "crawl" system in game.ts)
+
+The crawl is a system you can read and change, not hidden machinery:
+
+- Where a wickbearer stands wakes the room (if it still sleeps) and, once
+  that room is cleared, the rooms next to it. Two rooms fight at once at
+  most.
+- A woken room's dead come in inside that room, off every screen (the
+  system tries points in the room until onScreen(x, z) is false, and after
+  3 s takes any point), then come for the party through the doors.
+- ENCOUNTERS lists what a room holds by its depth: [prefab, count] for one
+  player; each extra player adds 35%. Every third room adds an elite; the
+  first room three doors down brings the Marrow Knight (a mini-boss).
+- When nothing of DEAD is left standing, the room is cleared: a reliquary
+  (a chest: pick an upgrade) appears at its centre, room.cleared fires (earn
+  rules count it; the HUD shows ROOM n OF N), and anyone who fell comes
+  back (respawnDead).
+- Quiet for STIR_AFTER seconds, the nearest sleeping room stirs by itself,
+  so a party that waits is still found. A fight that drags past 75 s with 3
+  or fewer left ends: the stragglers slink back into the dark.
+- The deepest room holds the boss; boss.killed ends the run won.
+
+## Permadeath
+
+players: { downed: { seconds: 12, crawl: 0.35, selfRevives: 0, respawn: 0 } }
+A fallen wickbearer bleeds for 12 s and can crawl to a teammate, who
+revives by standing close. There is no free get-up, and once out they stay
+out until the party clears a room. If everyone is down at once, the run is
+lost and the next descent starts from the top with nothing carried down
+(the store's revive is the one way back up). Softer: selfRevives: 1, or a
+respawn time in seconds.
+
+## Common changes
+
+### Make it harder or easier
+Change ENCOUNTERS (counts, or tougher prefabs at shallower depths), the
+boss's health, STIR_AFTER (a shorter quiet), or the per-player 35%.
+Easier also: players.hitIframes (0.7 s), players.magnet (4 m), a revive
+(selfRevives: 1), a longer starting weapon range.
+
+### A bigger or smaller crypt
+dungeon({ seed, rooms: 14, ... }): more rooms is a longer descent (about 40
+s a room). size: [16, 22] with cell: 28 gives bigger rooms; loops: 0 is a
+pure tree, every dead end a dead end.
+
+### Add an enemy
+prefab("ghoul", { model: "style.lowpoly.zombie", health: 30, speed: 3.2, radius: 0.4, damage: 8, ai: "chase", drops: ["wick_small"] });
+then put it in ENCOUNTERS at the depth it should start appearing, and in DEAD
+(so a room with ghouls left is not cleared):
+[["ghoul", 6], ["bone_rattler", 6]],
+ai is the enemy's role. Every big hit is telegraphed on the ground first:
+- "chase" (default), "tank" (a chaser; give it mass), "idle"/"none" (stands still)
+- "runner": aims where you will be. Fast, fragile.
+- "charger": stops inside 6 m, shows a lane 0.55 s, then charges along it.
+- "ranged": keeps its distance, shows an aim line, fires a slow dodgeable shot
+  (only with a clear line: walls and pillars are cover).
+- "bomber": walks up, arms a 1 s fuse circle, explodes (hurts enemies too).
+- "shielder" / "healer": every few seconds shields or heals nearby allies.
+- "summoner": keeps away and calls adds: attack: { summon: "gnat", count: 2 }.
+- "flee", "wander".
+Tune a role with attack: { damage, range, windup, cooldown, speed, radius, summon, count }:
+prefab("bone_archer", { model: "style.lowpoly.skeleton", health: 24, speed: 2.8, ai: "ranged", attack: { damage: 9, range: 10, speed: 7 }, drops: ["wick_small"] });
+A splitter bursts into smaller enemies on death:
+prefab("tomb_slime", { model: "style.lowpoly.slime_horned", health: 44, speed: 2.8, split: { into: "crypt_bat", count: 3 }, drops: ["wick_small"] });
+
+### Add elites
+An elite is x6 health, x1.5 damage, x5 XP and a gold rim, and drops a chest.
+The crawl adds one every third room (add(prefab, 1, true) in wake); change
+`wakes % 3` for more or fewer. From any system: spawn("grave_shambler", [x, 0.5, z], { elite: true }).
+
+### Add a weapon
+weapon("frost_ring", {
+  kind: "nova", damage: 6, cooldown: 0.8, range: 5, knockback: 8,
+  levels: [{ damage: "+30%" }, { range: "+15%" }, { cooldown: "-15%" }, { damage: "+30%" }, { knockback: 3 }],
+});
+kinds:
+- "nova": a burst in range; "aura": a field that burns what is inside, every cooldown
+- "bolt": count projectiles at the nearest enemy (speed, pierce)
+- "orbit": count blades at range metres, speed rad/s
+- "cone": a sweep of spread degrees where the keeper faces (360: all around)
+- "chain": strikes the nearest, then jumps count times, each within speed m
+- "meteor": count circles of blast m land on enemies in range, 0.6 s after showing
+- "boomerang": flies out range m and back, hitting everything both ways
+levels: what each level changes from the one before (5-8 levels). A number
+adds (count: 1, pierce: 2, cooldown: -0.1 s), a percent scales ("+40%").
+Cards show these changes ("+1 projectile, -20% cooldown"). It is offered at
+level-up automatically. Add a label in client/names.ts.
+
+### Add an evolution
+weapon("frost_ring", { ..., evolve: { into: "blizzard", requires: "iron_skin" } });
+weapon("blizzard", { kind: "nova", damage: 20, cooldown: 0.6, range: 9, knockback: 12 });
+At max level, with the passive "iron_skin" taken, the "blizzard" card always
+shows; it replaces frost_ring in its slot. Evolutions are never offered on
+their own. Give them about x1.7 damage and a new shape (360 degrees, double
+radius, more count). Pair each base weapon with a different passive.
+
+### Add a passive
+upgrade("iron_skin", { stat: "armor", step: 1, maxLevel: 4 });
+stats: speed, maxHealth, magnet, might, haste, regen, armor, area (bigger
+novas, auras, cones, meteors and orbits), amount (more projectiles, blades,
+jumps and meteors). Up to 8. maxLevel caps how often it is offered.
+
+### Add pickups and loot
+prefab("tallow", { model: "style.lowpoly.cell_heal", health: 1, speed: 0, kind: "pickup", pickup: { effect: "heal", amount: 0.3 } });
+A boss's hoard: pickup: { effect: "chest", amount: 3, evolve: true }. Bosses
+drop it instead of the plain chest. If the player holds a weapon and already
+has its paired passive, that weapon jumps to max level, so its evolution is
+on the cards.
+effects: heal (amount: fraction of max health, or hit points above 1),
+vacuum (every gem on the floor comes to you), bomb (clears the screen's
+non-boss enemies), chest (amount card picks; a ready evolution shows first).
+Drop them with a chance: drops: ["wick_small", { id: "tallow", chance: 0.03 }].
+Elites always drop the game's chest; bosses drop a heal, a vacuum and a chest.
+Above 300 gems on the floor, new gems merge into the nearest one.
+
+### Add props (breakables)
+prefab("crypt_urn", { model: "style.lowpoly.column_broken", health: 25, speed: 0, radius: 0.5, prop: true, drops: ["wick_mid", { id: "tallow", chance: 0.3 }] });
+then scatter("crypt_urn", 36) from a system (props land on the floors only). Props never move, never hurt
+and never count as enemies.
+
+### Add events and moments
+In the crawl's wake(room) or clearActive(), or a system of your own:
+on("room.cleared", () => { if (random() < 0.2) { announce("A SHRINE GLOWS", { tone: "reward" }); xpBoost(2, 20); } });
+announce tones: info, danger, reward. Off-screen bosses get an edge arrow
+automatically. Game events you can key on (and earn rules too):
+room.cleared, miniboss.killed, boss.killed, player.evolved, heal.collected,
+vacuum.collected, bomb.collected, chest.collected. clear("bone_rattler")
+removes a prefab at once (no kills or drops).
+
+### Cards
+Weighted: an owned weapon's next level 8, a new weapon 10 (while a slot is
+free), a passive 4 (7 once weapon slots are full); a ready evolution always
+shows. players.rerolls (default 1) rerolls per run (R); Skip (X) trades the
+cards for a small heal. When everything is maxed, a level heals and gives
+teammates a little XP.
+
+### Add a boss
+prefab("ossuary_queen", {
+  model: "style.lowpoly.trex", appearance: { tint: "#c2410c", scale: 1.2 }, health: 3000, speed: 2.2, radius: 1.5, damage: 30,
+  boss: { attacks: ["slam", "ring", "dash", "summon"], summon: "bone_rattler", enrageAt: 0.5 },
+  drops: ["wick_large"],
+});
+In the crawl, the boss room's wake adds it: add("ossuary_queen", 1). The
+crawl already ends the run on boss.killed.
+Keep a boss's radius at 1.5 or under with 6 m corridors (radius 1 with 4 m
+ones): it walks the corridors to reach a party that will not come to it.
+Attacks (all telegraphed): slam (circle around it), dash (11 m lane), leap
+(lands on a circle at you), rain (circles near players), ring (14 shots
+outward), fan (7 shots at you), summon (adds). It switches near and far
+modes every 4-9 s; below enrageAt health it is faster and throws more.
+A mini-boss: boss: { attacks: [...], rank: "mini" } raises "miniboss.killed"
+(not "boss.killed", so it never ends the run). Boss health scales with
+players present (players.bossHealthPerPlayer, 0.55); every boss gets a HUD
+bar and drops a burst of gems worth 1-2 levels.
+
+### Change pacing
+A room takes about 30 to 45 s to wake and clear; STIR_AFTER (18 s) is the
+longest quiet. The XP curve is players.xp { base, growth, exponent }: XP to
+go from L to L+1 is base + growth x (L - 1)^exponent. Aim for level 2
+within 10 s and level 5 by the end of the first minute; reliquaries add a
+pick per cleared room.
+
+### Add an earn rule
+earn.rule("five_rooms", { when: "room.cleared", n: 5, pay: 10, oncePer: "run" });
+Events: room.cleared (the crawl emits it), enemy.killed (credits the killer),
+boss.killed (everyone present), player.downed, player.revived (credits the
+reviver), player.levelup, run.won, run.lost, and anything you emit().
+Each rule pays once per run per player, in coins; the room server is the referee.
+
+### The buy-in run (required)
+earn.stake({ min: 20, max: 200, multiple: 2 });
+Every game declares one, on one top-level line; a game without it does not
+build. A player stakes coins at the start of a run (the Kit spends them as
+coins.spend(amount, "stake"), then the client calls conn.stake()). The room
+fixes the stake when the next run starts. A staked run pays its normal earn
+plus a share of stake x multiple: the share is the part of the run's most
+earn the player makes. What it does not win back stays in the reward pool.
+multiple is 1 to 2. "stake" is reserved: never a SKU or meta upgrade id.
+
+### Losable gear (optional)
+store.sku("wick_charm", { coins: 150, grants: { gear: "tallow_oil", loseBelow: 0.25 } });
+Gear is owned in the player's profile and sells for coins only. It brings one
+level of its declared upgrade into every staked run, and is lost when that run
+makes less than loseBelow of its most earn. Its coins stay in the reward pool.
+
+### Coins: earn and the store
+
+Every game has coins: 1 coin = 1 of the game's own token, and players see
+them under the token's own name, symbol and logo (never "coins" or "tokens"
+as a label). Earn rules pay coins (`pay` is whole coins). The recommended
+coin model (the default, no declaration) sells cosmetics, unlocks and
+in-run consumables, never permanent stat power:
+
+store.sku("revive", { coins: 50 });                                   // in-run: used while downed
+store.sku("skin_ossuary", { coins: 300, grants: { cosmetic: 1 } });    // a look, owned for good
+
+Keep them and the wick_charm gear exactly: the client is wired to them (price, look id and gear). Owned
+looks and unlocks are saved on the room server in the player's profile. Players spend
+earned coins first (instantly, no wallet prompt), then their wallet. Before
+the game launches coins are play money; the Kit switches by itself, so
+nothing in game.ts depends on it. Price in coins against what a run pays
+(the four rules here pay up to 80 a run): a revive is under a run, a
+cosmetic a few runs.
+
+### Sell a keeper unlock (a character, a starting loadout, a sidegrade)
+keeper("tinker", { name: "Tinker", text: "Darts and a wide glass.", weapon: "wax_dart", passive: "stained_glass" });   // no unlock
+store.sku("unlock_tinker", { coins: 400, grants: { keeper: "tinker" } });
+A keeper is earned (unlock: an achievement) or bought (a SKU), never both:
+the build refuses a sold keeper that also declares an unlock. Never sell
+the first keeper (everyone's free default). An unlock is a different way to
+play, never more power. Before launch coins are play money and buy only
+in-run items; looks and unlocks open at launch.
+
+### Cosmetics only ("no pay to win")
+economy({ store: "cosmetics" });
+Then every SKU must be a look (grants: { cosmetic: n }); drop revive.
+
+### Permanent upgrades for coins (opt-in meta upgrades)
+economy({ metaUpgrades: true });
+metaUpgrade("hearth", { stat: "maxHealth", step: 0.05, levels: 3, cost: 120, growth: 2 });  // 120, 240, 480 coins
+metaUpgrade("stride", { stat: "speed", step: 0.03, levels: 3, cost: 100, growth: 1.8 });
+Only when the creator asks for permanent upgrades. Stats: speed, maxHealth,
+magnet, might, haste, area. The engine refuses more than +15% to one stat
+or +30% in all, more than 5 levels, or growth under 1.5, and applies a
+player's levels at the start of every run. The store shows each level.
+
+### Add a keeper (a playable character)
+keeper("vesper", { name: "Vesper", text: "Arcs that leap between the dead.", model: "style.lowpoly.mini_female_c", tint: "#7ad7ff", weapon: "vesper_arc", passive: "bellows", unlock: "knight_felled" });
+A keeper starts every run with its weapon and its passive at level 1;
+players pick one before their first level and on the end screen. At most
+15; the first declared keeper is everyone's default, and at least one
+keeper has no unlock (declare a free one first). Keepers unlock with
+achievements, or with coins through a SKU with grants: { keeper }. The room
+server checks every pick against the player's saved unlocks.
+With keepers declared, players.weapon is optional.
+
+### Add achievements, daily goals and end-screen titles
+achievement("evolver", { title: "Evolved", text: "Evolve a weapon.", when: "player.evolved" });
+mission("elite", { text: "Kill an elite", when: "elite.killed" });
+title("butcher", { text: "The Butcher", most: "kills" });
+Achievements and missions count a game event per player in one run (n
+times) and pay nothing (coins come only from earn rules). The room server
+grants them from the run and saves them per player (wallet, or guest until
+sign-in), so they follow the player to every device. The HUD shows
+three missions a day. Titles rank players at the end of a run by most or
+least of: kills, damage, revives, downs, level, pickups. Events to count:
+anything you emit, "<prefab>.killed" ("marrow_knight.killed"),
+"elite.killed", "player.evolved", "player.revived", "chest.collected",
+"miniboss.killed", "boss.killed", "room.cleared".
+
+### Co-op that feels shared
+players: { share: "nearby" }        // default: half of each gem to teammates within 20 m
+players: { share: "all" }           // or "collector", or { mode, fraction, radius }
+players: { reviveBuff: { seconds: 5, damage: 1.3, speed: 1.15 } }  // the reviver burns hotter
+players: { downed: { seconds: 12, crawl: 0.35, selfRevives: 0, respawn: 0 } }  // permadeath (this game): back only when a room is cleared
+players: { lateJoinBehind: 2 }      // a late joiner starts 2 levels under the team, cards waiting
+players: { crit: { chance: 0.08, multiplier: 2 } }  // crits show as gold numbers
+The end screen votes "Play again" (everyone ready starts the next run; it
+starts by itself after 10 s) and shows each keeper's build, damage per
+weapon, what downed them, coins and titles.
+
+### Make co-op 8 players
+players.max: 8. The hosted Net Forge room server seats at most 8 in a
+co-op room (the dungeon room seats 4 today), so 8 is the most a game can
+ask for.
+
+## Models and appearances (the asset library)
+
+Every model is a real CC0 model from the asset library, by id. Enemies are
+drawn about 3.2 hit radii tall, keepers 1.8 m; animated ones walk, run and
+die by themselves. An appearance dresses a model into your own original:
+appearance: { tint: "#rrggbb", accent: "#rrggbb", scale: 0.4 to 3, parts: up to 4 }.
+
+### Make the dead look like slimes
+prefab("bone_rattler", { model: "style.lowpoly.slime_green", ... });
+prefab("grave_shambler", { model: "style.lowpoly.slime_spiky", ... });
+prefab("ossuary_brute", { model: "style.lowpoly.slime_pink", appearance: { scale: 1.3 }, ... });
+
+### A goblin warren instead of a crypt
+prefab("bone_rattler", { model: "style.lowpoly.goblin", ... }); keep the ids or rename
+them everywhere (ENCOUNTERS and DEAD too), and retell it in names.json.
+
+### A hero described by the creator
+players: { prefab: "style.lowpoly.worker", appearance: { tint: "#2e7d32", accent: "#3b2a1a", parts: ["mustache", "hat_cap"] }, ... }
+Name it something new in names.json. A creature the library lacks: the
+nearest base plus parts, e.g. model "style.lowpoly.shiba" with
+appearance { tint: "#5ec8ff", parts: ["antenna", "tail_bolt"] }.
+
+## Look and feel (engine render stack and feel kit)
+
+How the game looks and how hits feel are declarations too. They are
+presentation only (never the simulation), so tune them freely. The full
+reference is packages/engine/llms.txt.
+
+### Change the look
+game({ ..., look: { preset: "dusk", bloom: 1.4, fog: 0.3, tint: "#ffd9a0" } });
+presets: "night" (default), "dusk", "day", "studio". Also shadows (off here unless
+look.shadows is true), outline,
+exposure, saturation, contrast, vignette.
+
+### Make a death or a hit feel bigger
+prefab("brute", { ..., feel: { particles: "burst", decal: "scorch", sound: "boom", shake: 0.5, hitStop: 0.06, color: "#ff4d5e" } });
+Without feel, big enemies (bosses, radius 0.5 m or more) burst, scorch and
+shake, and small ones burst, splat and crunch.
+
+### Make a weapon's impacts feel different
+weapon("frost_ring", { ..., feel: { particles: "magic", decal: "ring", color: "#7ad7ff", shake: 0.1 } });
+Novas use it when they go off; bolts and lances when they hit.
+
+### Heavier or lighter knockback
+weapon knockback (m/s) pushes enemies, divided by their mass. Knocked
+enemies stagger, slide, bounce off walls and pillars and shove the
+enemies behind them. Bolts stop at walls and pillars.
+
+## Systems API
+
+every(seconds, n => ...), after(seconds, fn), onTick(fn), spawn(prefab, [x,y,z], { elite? }),
+spawnPickup(prefab, [x,y,z]), announce(text, { tone }), bossAlive(),
+pauseDirector(seconds), surge(multiplier, seconds), xpBoost(multiplier, seconds),
+scatter(prefab, count), clear(prefab), upcoming(label, seconds) (a HUD countdown:
+upcoming("THE BELL WARDEN", 240)),
+spawnEdge(prefab, { count, around?, side?, spread?, scale? }) (just off screen;
+side: "any" | "ahead" | "behind" | "north" | "south" | "east" | "west"),
+spawnRing(prefab, { count, radius, around? }), alive(prefab?), players(),
+emit(event), on(event, players => ...), respawnDead(), end("won" | "lost"),
+onScreen(x, z) (true when a player who is up can see that ground point),
+random(), tick(), time().
+
+## Test
+
+engine.test.run({ ticks: 30 * 180, bots: 4, assert: [...] }) plays the game
+on the server sim with bots and reports kills, wave, maxLevel, earned by
+rule, deaths, runs won and lost, softlock and ms per tick (wave is
+1 + rooms cleared). With
+bot: "human" a human-like bot plays (200 ms reactions, kiting, a second per
+card) and report.fun has the fun metrics: first threat, first level,
+level at 1/3/6/9 minutes, downs before 1:00, enemies on screen at 0:30,
+touches in minute 1, spawns on screen, survival. Net Forge's gate scores
+them; `pnpm --filter @netforge/template-dungeon fun` prints the table.

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@netforge/template-dungeon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Co-op dungeon crawler game template for Net Forge: 4 players, procedural rooms, loot and permadeath runs (CRYPTWICK).",
+  "keywords": [
+    "game-template",
+    "multiplayer",
+    "browser-game",
+    "html5-game",
+    "threejs",
+    "game-engine",
+    "typescript",
+    "gamedev",
+    "ai-agents",
+    "mcp",
+    "net-forge",
+    "dungeon-crawler",
+    "roguelike"
+  ],
+  "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/dungeon",
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/netnetdev/net-forge.git",
+    "directory": "packages/template-dungeon"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "nipplejs": "1.0.4",
+    "three": "0.186.1",
+    "@netforge/engine": "0.2.0",
+    "@netforge/engine-sim": "0.2.0",
+    "@netforge/asset-library": "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",
+    "bots": "tsx scripts/load-bots.ts",
+    "fun": "tsx scripts/fun.ts",
+    "bench": "tsx scripts/bench.ts"
+  }
 }