@netforge/template-idle 0.1.0 → 0.2.0

package/AGENTS.md

@@ -0,0 +1,73 @@
+# Extending BRINEWORKS
+
+BRINEWORKS is the idle template of the Net Forge game engine. The template already has the works, the production chain, buying and levelling, raking, tending, the contract, the shift clock, netcode, rendering, earn and the store. You change the game by changing declarations. Read `llms.txt` for every field, and `llms-full.txt` for the complete worked example.
+
+## The one file to edit
+
+- `src/game.ts` is the whole game. Change declarations in place.
+- `src/names.json`, next to it, holds the title and every label. Plants go in `"weapons"` (`{ name, line }`), and `"enemies"` stays empty.
+- Everything else (`src/manifest.ts`, `src/store.ts`, `src/autopilot.ts`, `client/`, `test/`, `scripts/`) is template machinery. Do not edit it.
+
+## Imports
+
+`src/game.ts` imports only from `@netforge/engine`. The shipped game uses:
+
+```ts
+import { earn, game, plant, saltFlat, store, upgrade } from "@netforge/engine";
+```
+
+## Declarations
+
+- `game({ template: "idle", style, places, players: { prefab, max } })`, with `max` at most 8.
+- `saltFlat({ shift, tend, start, rake: { salt, cooldown }, brinePerSalt, saltPerCrystal, packEvery, contract: { crystals } })`, exactly one.
+- `plant(id, { model, kind: "pump" | "pan" | "kiln", cost, growth, rate })`, 1 to 8 of them. The bar shows plants in declaration order (keys 1 to 8).
+- `upgrade(id, { stat, step, maxLevel })` with stat `might` (plant output), `haste` (raking speed) or `amount` (salt a rake) only.
+- `earn.rule(id, { when, n, pay, oncePer: "run" })`. Events: `salt.packed`, `crystal.cut`, `crystal.shipped`, `plant.built`, `plant.upgraded` and `contract.filled`.
+- `earn.stake({ min, max, multiple })`, exactly one, on one top-level line.
+- `store.sku(id, { coins, grants? })`.
+
+## Rules the build enforces (the anti-farm rules)
+
+- Ids are lower_snake_case.
+- Every game declares at least one `earn.rule` and exactly one `earn.stake`. `"stake"` is reserved.
+- Plants include at least one `pump`, one `pan` and one `kiln`.
+- A shift is 600 to 3600 seconds. Every earn rule is `oncePer: "run"`.
+- `tend` is at most 300 seconds, so a works nobody tends stops.
+- No earn rule may pay sooner than 180 seconds into a fresh works, even with perfect play or raking as fast as the cooldown allows. If a change pays sooner, raise `packEvery` or the rule's `n`, or slow raking.
+- No `weapon()` or `prefab()`.
+- An earn rule must fire within about 4 minutes of 4-player play.
+- Asset ids are library ids such as `"style.lowpoly.barrel"`, never URLs or paths. Keep `game({ style })` as the creator picked it.
+- Keep the SKUs the client is wired to at their prices: `bellows`, `long_rake`, `quick_hands`, `skin_saltwhite`, `skin_rust` and `brass_bellows`.
+
+## Validate
+
+- With the MCP server (`npx -y @netforge/mcp`), call `netforge_validate_game` on `src/game.ts`. It returns one actionable line per problem, including the measured first payout when it is too early.
+- In this package, run the tests with vitest: `test/harness.test.ts` and `test/store.test.ts`.
+
+## Playtest
+
+- With the MCP server, call `netforge_run_playtest`.
+- In code, import the game module and run the headless harness:
+
+```ts
+import { engine } from "@netforge/engine";
+import "./src/game.js";
+
+const report = await engine.test.run({ ticks: 30 * 240, bots: 4, seed: 1 });
+console.log(report.kills, report.earned, report.rules?.checks);
+```
+
+The report has crates packed (as kills), earn by rule, softlock, ms per tick and the genre's checks (the farming bounds) under `rules.checks`.
+
+## Play locally
+
+In a folder with `netnet.json` (`{"template":"idle"}`) and `src/game.ts`, with `@netforge/kit-play` and `@netforge/engine` installed, run `npx kit-play`. It opens http://127.0.0.1:4663 with play money. The MCP tool `netforge_play_locally` gives the same steps.
+
+## Do not
+
+- Do not write renderers, netcode, physics or bot logic. The template has them.
+- Do not add offline production, wall-clock timers or client-reported numbers.
+- Do not reference assets by URL or file path.
+- Do not import anything other than `@netforge/engine` in `src/game.ts`.
+- Do not edit `client/`, `src/manifest.ts`, `src/store.ts` or `src/autopilot.ts`.
+- Do not rename or reprice the SKUs the client is wired to.

package/CLAUDE.md

@@ -0,0 +1,11 @@
+# CLAUDE.md
+
+This package is BRINEWORKS, a Net Forge game template. Read AGENTS.md before changing this game. It lists the declarations this genre has, the rules the build enforces, and how to validate, playtest and play the game locally.
+
+The five hard rules:
+
+1. Edit only src/game.ts (and src/names.json for the labels players read).
+2. Import only from @netforge/engine.
+3. Ids are lower_snake_case.
+4. Declare at least one earn.rule and exactly one earn.stake.
+5. Never write renderers, netcode, physics or bot AI, and never reference assets by URL or file path (use library ids such as "style.lowpoly.frog").

package/README.md

@@ -1,43 +1,87 @@
-# BRINEWORKS (idle template)
+# @netforge/template-idle
 
-A white salt flat under a hot sky. Up to eight players each run a works:
-pumps draw brine, pans boil it into salt, kilns cut crystals, and salt buys
-more plants. A barge on the canal takes crystals for a contract everyone
-fills together. A shift lasts fifteen minutes; then a new one begins.
+A shared idle game template for Net Forge: a salt flat where up to eight players each run a works and fill one contract together (BRINEWORKS).
 
-A board genre (`packages/engine/src/rules/idle.ts`) on the shared runtime;
-client kit `@netforge/tabletop`. Room template `idle` (cap 8).
+A white salt flat under a hot sky. Pumps draw brine, pans boil it into salt, kilns cut crystals, and salt buys more plants. A barge on the canal takes crystals for a contract everyone fills together. A shift lasts fifteen minutes, and then a new one begins from nothing.
+
+## Install
+
+```sh
+npm install @netforge/template-idle
+```
+
+You rarely import this package directly. kit play (`@netforge/kit-play`) and the Net Forge MCP server use it to build and run a game whose `src/game.ts` you write.
+
+## Play it locally
+
+```sh
+mkdir -p my-game/src && cd my-game
+npm init -y && npm install @netforge/kit-play @netforge/engine @netforge/template-idle
+cp node_modules/@netforge/template-idle/src/game.ts src/
+echo '{"template":"idle"}' > netnet.json
+npx kit-play        # opens http://127.0.0.1:4663
+```
+
+Open the link in more tabs for more players. Coins are play money. Real-token earning, stakes and claims run only on the hosted Net Forge server.
+
+## Change the game
+
+Edit `src/game.ts` and run `npx kit-play` again. For example, make the hand pump cheaper to level for longer:
+
+```ts
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.1, rate: 3 });
+```
+
+Or lengthen the shift and enlarge the contract in `saltFlat({ ... })`:
+
+```ts
+shift: 1200,
+contract: { crystals: 120 },
+```
+
+Keep the first payout at least 180 s into a fresh works. The build measures it and fails with the number if a change pays sooner.
 
 ## Why it cannot be farmed
 
-- Production runs only in the room's sim, on its ticks, for players in the
-  room. No wall clock, no offline accrual, no client-reported numbers.
-- A works stalls two minutes after its last tend (rake, buy, ship): an idle
-  tab makes nothing.
-- Raking has a cooldown; mashing adds nothing.
-- Earn rules pay once a run. A seat that leaves and rejoins starts a fresh
-  works from 20 kg of salt. The genre's gate check simulates a fresh works
-  with perfect play and with pure raking: the first payout comes 199 s in
-  (the floor is 180 s), and the most one seat can earn is about 550 coins an
-  hour even rejoining every time a rule pays, before the per-wallet daily
-  cap, the free-play lifetime cap and the stake terms. With full shifts the
-  four rules pay at most 80 coins a shift (320 an hour).
-- One earning seat per wallet (the room's seat lock), and the run replays
-  from its inputs for the referee.
-
-## Run it
-
-This template runs on your own computer with play money through
-`kit play` (`@netforge/kit-play`). From the repository root:
+- Production runs only in the room's sim, on its ticks, for players in the room. There is no wall clock, no offline accrual and no client-reported number.
+- A works stalls two minutes after its last tend (rake, buy, ship), so an idle tab makes nothing.
+- Raking has a cooldown, so mashing adds nothing.
+- Earn rules pay once a run. A seat that leaves and rejoins starts a fresh works from 20 kg of salt. The genre's gate check simulates a fresh works with perfect play and with pure raking: the first payout comes 199 s in (the floor is 180 s). With full shifts the four rules pay at most 80 coins a shift.
+- One earning seat per wallet, and the run replays from its inputs for the referee.
+
+## Files
+
+| Path | What |
+|---|---|
+| `src/game.ts` | The game, as declarations only. This is the file you edit. |
+| `src/manifest.ts` | Loads the game; `idleAdapter()` for the room host and the client (up to 8 seats). |
+| `src/store.ts` | Coin prices the client is wired to. |
+| `src/autopilot.ts` | The autopilot the browser's `?autopilot=1` and the measure script use. |
+| `client/` | The browser client, drawn with `@netforge/tabletop`. |
+| `test/` | Playtest bots through `engine.test.run`, and the store test. |
+| `llms.txt`, `llms-full.txt` | How to change the game, for agents. |
+
+## Controls
+
+Space rakes (or click your plot), 1 to 5 buy a plant, S ships crystals.
+
+## For AI agents
+
+Read `AGENTS.md` and `llms.txt` before editing. The Net Forge MCP server gives a coding agent the templates, the API and a playtest loop:
 
 ```sh
-pnpm install --frozen-lockfile && pnpm build
-mkdir -p play-idle/src && cp packages/template-idle/src/game.ts play-idle/src/
-echo '{"template":"idle"}' > play-idle/netnet.json
-node packages/kit-play/dist/cli.js play-idle       # opens http://127.0.0.1:4663
+npx -y @netforge/mcp
 ```
 
-Edit `play-idle/src/game.ts` and run it again to try a change. Real-token
-earning, stakes and claims run only on the hosted Net Forge server.
+The package is `@netforge/mcp` and its bin is `netforge-mcp`. 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`.
+
+To set up a coding agent in a game project, run `npx netforge setup agent`. It writes AGENTS.md, CLAUDE.md, Cursor rules and `.mcp.json` into the project. In Claude Code you can also add the server directly with `claude mcp add netforge -- npx -y @netforge/mcp`.
+
+## Docs
+
+- https://forge.netnet.capital/docs/templates/idle
+- `llms.txt` and `llms-full.txt` in this package. The full file includes the complete `src/game.ts` and the validate and playtest steps.
+
+## License
 
-Space rakes (or click your plot), 1-5 buy a plant, S ships crystals.
+MIT. See LICENSE and NOTICE.

package/llms-full.txt

@@ -0,0 +1,209 @@
+# Net Forge idle template (BRINEWORKS)
+
+> A shared salt flat for up to 8 players. Each player runs a works on a
+> plot: pumps draw brine, pans boil it into salt, kilns cut salt into
+> crystals, and salt buys and levels more plants. Players rake by hand for
+> salt, and everyone ships crystals to one contract barge. A shift has a
+> fixed length; then a new shift starts from nothing.
+> You change the game by editing src/game.ts only. The template already has
+> the works, the production chain, buying and levelling, raking, tending,
+> the contract, the shift clock, netcode, rendering, earn and the store.
+
+## Files
+
+- src/game.ts: THE GAME. game(), saltFlat(), plant(), upgrade(),
+  earn.rule(), earn.stake(), store.sku().
+- src/names.json: the title and every label. Plants go in "weapons"
+  ({ name, line }); "enemies" stays empty.
+
+## Rules the build enforces (the anti-farm rules)
+
+- game({ template: "idle", style, places, players: { prefab, max } }), max at most 8.
+- Exactly one saltFlat(...); 1 to 8 plant(...)s with at least one "pump",
+  one "pan" and one "kiln" (the chain).
+- A shift is 600 to 3600 seconds. Every earn rule is oncePer: "run" (a run
+  is a shift, or a player's time in it).
+- tend is at most 300 seconds: a works nobody tends stops, so an idle tab
+  makes nothing. Production happens only on the room's clock while the
+  player is in the room; nothing is earned offline and a player who leaves
+  and comes back starts a fresh works.
+- No earn rule may pay sooner than 180 seconds into a fresh works, even
+  with perfect play or raking as fast as the cooldown allows. The gate
+  measures it; if a draft pays sooner it fails with the number. Raise
+  packEvery or the rule's n, or slow raking.
+- Upgrades read three stats: might (plant output), haste (raking speed),
+  amount (salt a rake). No weapon() or prefab().
+- An earn rule must fire within about 4 minutes of 4-player play.
+
+## Units
+
+Seconds, litres of brine, kg of salt, whole crystals. A plant's rate is a
+second, a level. Costs are kg of salt; each level costs growth times the last.
+
+## Common changes
+
+### Faster or slower progress
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+Lower growth makes levels cheap for longer; a higher rate makes each level count more.
+Keep the first payout at least 180 s away (the gate checks).
+
+### A new plant
+plant("deep_bore", { model: "style.lowpoly.generator_large", kind: "pump", cost: 5000, growth: 1.2, rate: 200 });
+Add its label to names.json weapons. The bar shows plants in order (keys 1-8).
+
+### Longer or shorter shifts
+saltFlat({ shift: 1200, ... }) (600 to 3600 s). A bigger contract: contract: { crystals: 120 }.
+
+### Earn rules
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+Events: salt.packed (one each packEvery kg a player makes), crystal.cut,
+crystal.shipped, plant.built, plant.upgraded (each credits the player),
+contract.filled (the players who shipped to it; world progress, so never a
+player whose run started after the shift began). Pays coins once a run.
+
+### The buy-in run (required)
+earn.stake({ min: 20, max: 200, multiple: 2 }); one top-level line. "stake" is reserved.
+
+### Coins: earn and the store
+store.sku("bellows", { coins: 40 });                               // one level of "bellows" for the shift
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });   // a finish for your foreman
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } }); // losable gear
+Keep the SKUs the client is wired to (bellows, long_rake, quick_hands,
+skin_saltwhite, skin_rust, brass_bellows) at their prices.
+
+## Test
+
+engine.test.run({ ticks: 30 * 240, bots: 4 }) plays the flat and reports
+crates packed (as kills), earned by rule, softlock, ms per tick and the
+genre's checks (the farming bounds) under rules.checks.
+
+## 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
+/**
+ * BRINEWORKS: the idle template (play style: idle).
+ *
+ * A white salt flat under a hot sky. Up to eight players each run a works on
+ * the flat: pumps draw brine, pans boil it into salt, kilns cut salt into
+ * crystals, and salt buys and levels more plants. A barge on the canal
+ * takes crystals for a contract everyone fills together. A shift lasts
+ * fifteen minutes; then the flat is raked clean and a new shift begins.
+ *
+ * Works run only while their player is on the flat and has tended them in
+ * the last two minutes (a rake, a purchase, a shipment): no offline
+ * production, nothing for an idle tab.
+ *
+ * This file is the whole game as the model writes it: declarations only,
+ * against the typed API in @netforge/engine.
+ */
+import { earn, game, plant, saltFlat, store, upgrade } from "@netforge/engine";
+
+export default game({
+  template: "idle",
+  style: "lowpoly",
+  places: { flat: { chunks: "places/flat", spawn: [0, 0, 0] } },
+  players: { prefab: "style.lowpoly.worker", max: 8 },
+});
+
+// The flat: a fifteen-minute shift, works that stall two minutes after the last tend,
+// a rake every 0.4 s for 3 kg, 3 L of brine to a kg of salt, 25 kg of salt to a crystal, a crate every 150 kg.
+saltFlat({
+  shift: 900,
+  tend: 120,
+  start: 20,
+  rake: { salt: 3, cooldown: 0.4 },
+  brinePerSalt: 3,
+  saltPerCrystal: 25,
+  packEvery: 150,
+  contract: { crystals: 60 },
+});
+
+// Plants. cost is kg of salt for the first level, growth the price rise a level; rate is a second, a level
+// (pumps: litres of brine; pans: kg of salt boiled; kilns: crystals cut).
+plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 3 });
+plant("boil_pan", { model: "style.lowpoly.crate", kind: "pan", cost: 25, growth: 1.15, rate: 1 });
+plant("steam_pump", { model: "style.lowpoly.generator", kind: "pump", cost: 400, growth: 1.18, rate: 30 });
+plant("sun_pan", { model: "style.lowpoly.barrels", kind: "pan", cost: 600, growth: 1.18, rate: 10 });
+plant("crystal_kiln", { model: "style.lowpoly.generator_large", kind: "kiln", cost: 900, growth: 1.25, rate: 0.05 });
+
+// Store upgrades: one level each, for the rest of the shift, on the buyer's own works.
+upgrade("bellows", { stat: "might", step: 0.15, maxLevel: 1 });
+upgrade("long_rake", { stat: "amount", step: 0.3, maxLevel: 1 });
+upgrade("quick_hands", { stat: "haste", step: 0.25, maxLevel: 1 });
+
+// Earn (mandatory). Pays the game's coins (1 coin = 1 token), once a shift each. Values are PLACEHOLDER.
+earn.rule("first_crate", { when: "salt.packed", n: 30, pay: 5, oncePer: "run" });
+earn.rule("long_haul", { when: "salt.packed", n: 300, pay: 20, oncePer: "run" });
+earn.rule("full_hold", { when: "contract.filled", n: 1, pay: 50, oncePer: "run" });
+earn.rule("cutter", { when: "crystal.cut", n: 30, pay: 5, oncePer: "run" });
+// Buy-in run (the mandatory sink loop): stake coins at shift start to earn above free play. Values are PLACEHOLDER.
+earn.stake({ min: 20, max: 200, multiple: 2 });
+
+// Store (the Kit), priced in coins: three shift upgrades, two finishes owned for good, one piece of losable gear.
+store.sku("bellows", { coins: 40 });
+store.sku("long_rake", { coins: 40 });
+store.sku("quick_hands", { coins: 60 });
+store.sku("skin_saltwhite", { coins: 300, grants: { cosmetic: 1 } });
+store.sku("skin_rust", { coins: 500, grants: { cosmetic: 2 } });
+// Losable gear: owned for good until lost. It brings one level of its upgrade into every staked shift,
+// and is lost when that shift makes less than loseBelow of its most earn. Values are PLACEHOLDER.
+store.sku("brass_bellows", { coins: 150, grants: { gear: "bellows", loseBelow: 0.25 } });
+```
+
+## 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 4 players for 4 minutes at 30 Hz.
+
+```ts
+import { engine } from "@netforge/engine";
+import "./src/game.js";
+
+const report = await engine.test.run({
+  ticks: 30 * 240,
+  bots: 4,
+  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 crates packed (as kills), earned by rule, softlock, ms per tick and the genre's checks (the farming bounds) 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-idle
+echo '{"template":"idle"}' > 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

@@ -1,4 +1,4 @@
-# BRINEWORKS: the idle template (NetNet game runtime, board genre)
+# Net Forge idle template (BRINEWORKS)
 
 > A shared salt flat for up to 8 players. Each player runs a works on a
 > plot: pumps draw brine, pans boil it into salt, kilns cut salt into

package/package.json

@@ -1,12 +1,34 @@
 {
   "name": "@netforge/template-idle",
-  "version": "0.1.0",
-  "description": "BRINEWORKS: the idle template of the NetNet game runtime, a shared salt flat for up to eight: pump brine, boil salt, cut crystals, fill the contract together. The game module, its browser client and its playtest bots.",
+  "version": "0.2.0",
+  "description": "Shared idle game template for Net Forge: up to 8 players pump, boil and cut salt to fill a contract together (BRINEWORKS).",
+  "keywords": [
+    "game-template",
+    "multiplayer",
+    "browser-game",
+    "html5-game",
+    "threejs",
+    "game-engine",
+    "typescript",
+    "gamedev",
+    "ai-agents",
+    "mcp",
+    "net-forge",
+    "idle-game"
+  ],
   "license": "MIT",
   "type": "module",
+  "sideEffects": [
+    "./src/game.ts",
+    "./src/manifest.ts",
+    "./client/**"
+  ],
   "exports": {
     ".": "./src/manifest.ts",
-    "./store": "./src/store.ts"
+    "./store": "./src/store.ts",
+    "./package.json": "./package.json",
+    "./llms.txt": "./llms.txt",
+    "./llms-full.txt": "./llms-full.txt"
   },
   "files": [
     "src",
@@ -15,26 +37,32 @@
     "llms.txt",
     "README.md",
     "NOTICE",
-    "LICENSE"
+    "LICENSE",
+    "llms-full.txt",
+    "AGENTS.md",
+    "CLAUDE.md"
   ],
   "publishConfig": {
     "access": "public"
   },
+  "homepage": "https://forge.netnet.capital/docs/templates/idle",
+  "bugs": {
+    "url": "https://github.com/netnetdev/net-forge/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/netnetdev/net-forge.git",
     "directory": "packages/template-idle"
   },
-  "homepage": "https://github.com/netnetdev/net-forge/tree/main/packages/template-idle#readme",
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
     "three": "0.186.1",
-    "@netforge/asset-library": "0.1.0",
-    "@netforge/engine-sim": "0.1.0",
-    "@netforge/engine": "0.1.0",
-    "@netforge/tabletop": "0.1.0"
+    "@netforge/asset-library": "0.2.0",
+    "@netforge/tabletop": "0.2.0",
+    "@netforge/engine": "0.2.0",
+    "@netforge/engine-sim": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "22.20.1",
@@ -44,9 +72,6 @@
     "vite": "6.4.3",
     "vitest": "3.2.7"
   },
-  "bugs": {
-    "url": "https://github.com/netnetdev/net-forge/issues"
-  },
   "scripts": {
     "build": "node ../engine/scripts/fresh-dist.mjs && vite build --config client/vite.config.ts",
     "typecheck": "tsc -p tsconfig.json",