@flayerlabs/gamemode-cli 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Flayer Labs
+
+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,50 @@
+# @flayerlabs/gamemode-cli
+
+Create a playable Flaunch Game Mode and check that its rules use deterministic inputs.
+
+## Requirements
+
+You need Node.js 20 or later and pnpm.
+
+## Create a game
+
+Run:
+
+```bash
+pnpm dlx @flayerlabs/gamemode-cli new my-game
+cd my-game
+pnpm install
+pnpm dev
+```
+
+The command creates a working number game. It includes:
+
+- server-authoritative rules in `src/game/rules.ts`
+- a browser game that uses the offline room
+- rule tests and a deterministic rules check
+- an `AGENTS.md` file with the rules an agent must follow
+- a `$build-game-mode` repository skill for supported agents
+
+The offline room runs the real rules without a gate, chain or wallet. The scaffold does not create a
+live gate or trusted wallet integration.
+
+## Check an existing rules file
+
+Install the CLI in the game project, then run the check:
+
+```bash
+pnpm add --save-dev @flayerlabs/gamemode-cli
+pnpm exec gamemode check src/game/rules.ts
+```
+
+The check rejects known uses of clocks, random values, network access and system access. It also
+rejects top-level `let` and `var` declarations. Run the project's tests and type check as well.
+
+## Build a secure game
+
+Use the repository guidance to continue:
+
+- [build a Game Mode](https://github.com/flayerlabs/gamemode-sdk/blob/main/docs/guides/build-a-game.md)
+- [read the generated-game agent rules](https://github.com/flayerlabs/gamemode-sdk/blob/main/packages/cli/templates/game/AGENTS.template.md)
+- [compare the quiz and arrow examples](https://github.com/flayerlabs/gamemode-sdk/blob/main/examples/README.md)
+- [review the Game Mode SDK repository](https://github.com/flayerlabs/gamemode-sdk)

package/dist/AGENTS.md

@@ -0,0 +1,213 @@
+# Build a Flaunch Game Mode
+
+This repository contains a game that awards points during a Flaunch token launch. The game can use
+any presentation or control scheme. The server rules decide which actions earn points.
+
+Use `$build-game-mode` when the skill is available. It gives you the safest order for changing the
+rules, tests and browser game.
+
+## Know what runs where
+
+The project starts with these files:
+
+```text
+src/game/rules.ts   pure server rules and scoring
+src/play.ts         browser game and room subscriptions
+test/rules.test.ts  replay, scoring and secrecy checks
+```
+
+The browser proposes actions. It never awards points.
+
+The gate runs `src/game/rules.ts` and stores every accepted event. A replay of the same commands
+must always produce the same state and score.
+
+## Use the development loop
+
+Run these commands:
+
+```bash
+pnpm dev
+pnpm test
+pnpm typecheck
+```
+
+`pnpm dev` runs the real rules in a local mock room. It needs no chain, server or wallet.
+
+`pnpm test` runs the rules check and game tests. `pnpm typecheck` checks the whole project. Both
+must pass before you finish.
+
+The scaffold does not include a live gate. Add `dev:live` only when you have a real gate harness to
+run. Follow the [live gate guide](https://github.com/flayerlabs/gamemode-sdk/blob/main/docs/guides/run-a-gate.md)
+instead of inventing a second protocol.
+
+## Keep the rules deterministic
+
+Keep `decide()` and `evolve()` pure.
+
+Do not use these values or operations in the rules module:
+
+- a process or device clock
+- random values that do not come from the supplied seed
+- network, file or database access
+- environment variables
+- mutable module-level state
+
+Time arrives as `command.at`. Player randomness arrives as a join seed. Derive any game variation
+from those values.
+
+`gamemode check` catches common nondeterministic calls, Node imports and module-level `let` or
+`var`. It is a guard, not a proof. Keep replay tests for every scoring path.
+
+## Treat every action as untrusted
+
+`room.send(action)` proposes an action. `decide()` accepts or refuses it.
+
+Do not send a score, hit, kill or trusted timestamp from the browser. Send the smallest input the
+server needs to verify the result.
+
+For a shooter, send bounded movement, aim and fire input. The rules should enforce sequence,
+cooldown, ammunition and hit logic. The browser may predict and animate at its own frame rate.
+
+Use `parseAction()` to reject malformed and oversized values before `decide()` sees them. Use game
+state in `decide()` to enforce limits such as one answer, one shot or one batch at a time.
+
+## Keep private state out of public types
+
+`publicView()` goes to every player and spectator. `playerView()` goes to one player.
+
+If a value must stay private, leave it out of the `publicView()` return type. Do not return it and
+filter it later.
+
+For example, keep a quiz answer out of the public type until the reveal. Add a test that serialises
+the public view and proves the secret is absent.
+
+## Choose when to award points
+
+Award points when the result should become known.
+
+An arrow score can be public as soon as the arrow lands. Award it with the accepted action.
+
+A quiz answer should stay private until the reveal. Store the answer event first. Award points from
+the later wake that reveals the result. Otherwise the player's allowance exposes the answer early.
+
+## Keep wallets outside the game
+
+Creator code must not access a wallet, private key, RPC endpoint or transaction calldata.
+
+Use the room economy:
+
+```ts
+await room.economy.buy(maxSpendWei)
+```
+
+The trusted parent validates the gate authorisation, builds the transaction and asks the player to
+approve it. Game code never handles `hookData`.
+
+## Declare the maximum score
+
+`rewardBounds(config)` must return the highest score one player can earn.
+
+Derive the number from the rules. For example, multiply the shot budget by the best shot, or add
+the points for every question.
+
+Do not use an estimate. The platform uses this bound to check the launch wallet cap. Points above
+an understated bound cannot become spending allowance.
+
+## Build fixed timelines once
+
+Use `scheduleWithin()` for a fixed series of phases:
+
+```ts
+import { scheduleWithin } from '@flayerlabs/gamemode-spec/schedule'
+```
+
+It checks that the full schedule fits between `opensAt` and `closesAt`. It also gives each phase an
+absolute time, so a delayed server wake does not move every later phase.
+
+Every `nextWakeAt()` value must be later than the wake being served. Return `null` when the game has
+no more timed work.
+
+## Model readiness as a game rule
+
+Presence tells you how many players are connected. It does not start the game.
+
+If players must ready up, define a ready action and store it in game state:
+
+```ts
+{ kind: 'ready', ready: true }
+```
+
+This lets `decide()` apply the rule. It also makes readiness replayable after a restart.
+
+## Use the module contract
+
+Implement the complete rules module:
+
+```ts
+export const rules = defineGame<Config, State, Event, Action, PublicView, PlayerView>({
+  id: 'my-game',
+  parseAction,
+  initRound,
+  decide,
+  evolve,
+  publicView,
+  playerView,
+  nextWakeAt,
+  rewardBounds,
+})
+```
+
+Commands reaching `decide()` are `join`, `leave`, `action` and `wake`. Each command includes the
+authoritative `at` time.
+
+A decision returns events and may return awards. `evolve()` applies events in order. A refusal
+returns a stable code:
+
+```ts
+return { refuse: 'answer.window_closed' }
+```
+
+Do not rename a refusal code after use. Add a new code. Keep player-facing copy in the browser.
+
+## Use the room capabilities
+
+The browser uses this surface:
+
+```ts
+room.subscribe(render)
+await room.send(action)
+room.now()
+
+room.launch.current()
+room.connection.subscribe(renderConnection)
+room.economy.subscribe(renderEconomy)
+room.economy.buy(maxSpendWei)
+room.market.subscribe(renderMarket)
+await room.identity.resolve(playerIds)
+room.presence.subscribe(renderPresence)
+room.social.react(id)
+room.social.onReaction(renderReaction)
+```
+
+Use `room.now()` for every visible timer. Do not use `Date.now()` in a countdown.
+
+The local mock implements the same room surface. Build against it before adding live
+infrastructure.
+
+## Finish with evidence
+
+Before you finish, check that:
+
+- correct play earns the expected points
+- invalid and repeated actions are refused
+- action sizes and rates are bounded
+- public views contain no secrets
+- private views contain only that player's data
+- delayed wakes keep the authored schedule
+- replaying the same commands gives the same result
+- `rewardBounds()` matches the best possible score
+- `pnpm test` passes
+- `pnpm typecheck` passes
+
+If the SDK contract does not fit the game, stop and explain the missing capability. Do not bypass a
+trust boundary in browser code.

package/dist/build-game-mode/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: build-game-mode
+description: Builds or changes a creator Game Mode with @flayerlabs/gamemode-spec and @flayerlabs/gamemode-client. Use when working on rules, actions, views, scoring, room capabilities, browser play, mock rooms or conformance tests in this SDK or a generated game. Do not use for trusted parent, registry writer or platform-owned gate changes.
+---
+
+# Build a Game Mode
+
+Follow the local `AGENTS.md` as the contract. Keep this skill focused on the workflow and do not replace those rules with guesses.
+
+## Find the working context
+
+1. Read the nearest `AGENTS.md` in full before editing anything.
+2. Inspect `package.json`, the game rules and their tests.
+3. If this is the SDK, read the closest reference game. Use `examples/arrow` for continuous public scoring. Use `examples/quiz` for hidden answers, phases and deferred awards.
+4. If this is a generated game, keep the shipped rules and tests as the working starting point.
+
+## Define the game before editing
+
+State assumptions and set verifiable success criteria for:
+
+- the authoritative state and accepted commands
+- the source of time and deterministic variation
+- hidden values and their reveal point
+- action shape, size, cooldown and round limits
+- acceptance, scoring and award timing
+- the maximum possible reward
+- refusal codes and observable outcomes
+
+If the SDK interface cannot represent the game safely, stop and describe the missing seam. Do not build a parallel protocol.
+
+## Build the smallest complete loop
+
+1. Write or update tests for the intended rule change.
+2. Define every shared shape once. Import SDK contract types instead of copying them.
+3. Bound malformed and oversized input in `parseAction`.
+4. Implement `decide` and `evolve` as pure functions. Derive time and variation only from supplied inputs.
+5. Make hidden data absent from public view types. Reveal it only when the rules allow.
+6. Keep action acceptance separate from awards when an early balance change would leak a result.
+7. Calculate `rewardBounds` from the rules, including the best possible play.
+8. Build the browser around `Room` capabilities. Keep scoring, wallets, keys and calldata out of creator client code.
+9. Prove the loop with the mock room before adding a project-specific live harness.
+
+## Verify the result
+
+In a generated game:
+
+1. Run `pnpm test`.
+2. Run `pnpm typecheck`.
+3. Run `pnpm dev` and check the changed play loop when presentation changed.
+
+In the SDK:
+
+1. Run the affected example or package tests and typecheck.
+2. Run the root typecheck and required repository tests.
+3. Run `pnpm release:check` when a published contract or package surface changed.
+
+Check replay, reconnect, hidden-data leaks, late actions, duplicate actions, oversized input, wake timing and the reward ceiling where they apply. If infrastructure blocks a check, report the exact check you could not run. Do not weaken or skip it.

package/dist/build-game-mode/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Build Game Mode"
+  short_description: "Build secure creator games with the SDK"
+  default_prompt: "Use $build-game-mode to build or change this Flaunch Game Mode and verify its rules."

package/dist/lint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checking that a game's rules are pure.
+ *
+ * `decide` and `evolve` must give the same answer for the same input, forever. Replay, reconnect,
+ * audit and anti-cheat all rest on it, and every one of them fails quietly rather than loudly when
+ * it stops being true — a round that scores differently on replay does not announce itself.
+ *
+ * Text rather than a full parse, deliberately. An agent writing `Date.now()` in a reducer is the
+ * failure this catches, and it catches that perfectly. A syntax tree would catch cleverer evasions
+ * that nobody is attempting, at the cost of a dependency and a lot of code.
+ */
+export interface Finding {
+    line: number;
+    found: string;
+    why: string;
+}
+export declare function lintRules(source: string): Finding[];
+/** What a person reads. No codes, no rule names — the line, what is there, and what to do. */
+export declare function report(file: string, findings: Finding[]): string;
+//# sourceMappingURL=lint.d.ts.map

package/dist/lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAmCD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EAAE,CAoBnD;AAED,8FAA8F;AAC9F,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAUhE"}

package/dist/lint.js

@@ -0,0 +1,70 @@
+/**
+ * Checking that a game's rules are pure.
+ *
+ * `decide` and `evolve` must give the same answer for the same input, forever. Replay, reconnect,
+ * audit and anti-cheat all rest on it, and every one of them fails quietly rather than loudly when
+ * it stops being true — a round that scores differently on replay does not announce itself.
+ *
+ * Text rather than a full parse, deliberately. An agent writing `Date.now()` in a reducer is the
+ * failure this catches, and it catches that perfectly. A syntax tree would catch cleverer evasions
+ * that nobody is attempting, at the cost of a dependency and a lot of code.
+ */
+const RULES = [
+    { pattern: /\bDate\s*\.\s*now\s*\(/, why: 'time must come from the command, as command.at' },
+    { pattern: /\bnew\s+Date\s*\(/, why: 'time must come from the command, as command.at' },
+    { pattern: /\bperformance\s*\.\s*now\s*\(/, why: 'time must come from the command, as command.at' },
+    { pattern: /\bMath\s*\.\s*random\s*\(/, why: 'randomness must be derived from the seed on the join command' },
+    { pattern: /\bcrypto\s*\.\s*(getRandomValues|randomUUID)\s*\(/, why: 'randomness must be derived from the seed on the join command' },
+    { pattern: /\bfetch\s*\(/, why: 'rules cannot reach the network' },
+    { pattern: /\brequire\s*\(\s*['"]node:/, why: 'rules cannot reach the system' },
+    { pattern: /\bfrom\s+['"]node:/, why: 'rules cannot reach the system' },
+    { pattern: /\bprocess\s*\.\s*env\b/, why: 'rules cannot read configuration; it belongs in the round config' },
+    { pattern: /\bglobalThis\b/, why: 'rules cannot reach outside themselves' },
+];
+/** Lines that are only a comment. A rule named in prose is documentation, not a violation. */
+function isComment(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*');
+}
+/**
+ * Module-level mutable state: a `let` or `var` at column zero.
+ *
+ * Two calls with the same arguments must not differ because of something one of them left behind.
+ */
+function moduleState(line) {
+    return /^(let|var)\s+\w/.test(line);
+}
+export function lintRules(source) {
+    const findings = [];
+    source.split('\n').forEach((line, index) => {
+        if (isComment(line))
+            return;
+        for (const rule of RULES) {
+            const match = rule.pattern.exec(line);
+            if (match)
+                findings.push({ line: index + 1, found: match[0].replace(/\s+/g, ''), why: rule.why });
+        }
+        if (moduleState(line)) {
+            findings.push({
+                line: index + 1,
+                found: line.trim().split(/\s+/).slice(0, 2).join(' '),
+                why: 'rules cannot keep state between calls; it belongs in the game state',
+            });
+        }
+    });
+    return findings;
+}
+/** What a person reads. No codes, no rule names — the line, what is there, and what to do. */
+export function report(file, findings) {
+    if (findings.length === 0)
+        return `${file}: rules look pure.`;
+    return [
+        `${file}: ${findings.length} thing${findings.length === 1 ? '' : 's'} to fix.`,
+        '',
+        ...findings.map((f) => `  line ${f.line}: ${f.found} — ${f.why}`),
+        '',
+        'These have to go. Same input, same answer, every time — replay, reconnect and anti-cheat',
+        'all depend on it, and each of them fails quietly rather than loudly when it stops being true.',
+    ].join('\n');
+}
+//# sourceMappingURL=lint.js.map

package/dist/lint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.js","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"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"}

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":""}

package/dist/main.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { lintRules, report } from './lint.js';
+import { scaffold } from './scaffold.js';
+/**
+ * The whole command line.
+ *
+ * Four things, because four is what it takes to go from nothing to a game somebody can play, and a
+ * fifth would be something to learn rather than something to use.
+ */
+const USAGE = `
+gamemode — build a game for a Flaunch launch
+
+  gamemode new <name>     start a new game you can play straight away
+  gamemode check [file]   check your rules are pure (default: src/game/rules.ts)
+
+Once you have a game:
+
+  pnpm dev                play it, with no server and no wallet
+  pnpm test               check it still works
+`;
+async function main(argv) {
+    const [command, argument] = argv;
+    if (!command || command === 'help' || command === '--help') {
+        console.log(USAGE.trim());
+        return 0;
+    }
+    if (command === 'new') {
+        if (!argument) {
+            console.error('What should it be called?  gamemode new my-game');
+            return 1;
+        }
+        const created = await scaffold(argument);
+        console.log(`\n  Made ${created}\n`);
+        console.log('  Next:');
+        console.log(`    cd ${argument}`);
+        console.log('    pnpm install');
+        console.log('    pnpm dev\n');
+        return 0;
+    }
+    if (command === 'check') {
+        const file = argument ?? 'src/game/rules.ts';
+        let source;
+        try {
+            source = readFileSync(file, 'utf8');
+        }
+        catch {
+            console.error(`Could not read ${file}.`);
+            return 1;
+        }
+        const findings = lintRules(source);
+        console.log(report(file, findings));
+        return findings.length === 0 ? 0 : 1;
+    }
+    console.error(`Not a command: ${command}`);
+    console.error(USAGE.trim());
+    return 1;
+}
+main(process.argv.slice(2))
+    .then((code) => process.exit(code))
+    .catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,KAAK,GAAG;;;;;;;;;;CAUb,CAAC;AAEF,KAAK,UAAU,IAAI,CAAC,IAAc;IAChC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;IAEjC,IAAI,CAAC,OAAO,IAAI,OAAO,KAAK,MAAM,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;QAC3D,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;YACjE,OAAO,CAAC,CAAC;QACX,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,CAAC,GAAG,CAAC,YAAY,OAAO,IAAI,CAAC,CAAC;QACrC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,UAAU,QAAQ,EAAE,CAAC,CAAC;QAClC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC9B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,QAAQ,IAAI,mBAAmB,CAAC;QAC7C,IAAI,MAAc,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACtC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,KAAK,CAAC,kBAAkB,IAAI,GAAG,CAAC,CAAC;YACzC,OAAO,CAAC,CAAC;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QACnC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QACpC,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC;IAED,OAAO,CAAC,KAAK,CAAC,kBAAkB,OAAO,EAAE,CAAC,CAAC;IAC3C,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5B,OAAO,CAAC,CAAC;AACX,CAAC;AAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KACxB,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAClC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;IACxB,OAAO,CAAC,KAAK,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC9D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/scaffold.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A new game, playable before it does anything.
+ *
+ * The first command has to produce something that runs. A scaffold that needs a database, a chain
+ * and a wallet before it shows anything is a scaffold most people abandon, and an agent given one
+ * has nothing to check its work against.
+ *
+ * So what comes out is a complete, working guessing game: rules, a page, and tests that pass. It is
+ * meant to be edited into something else, not read and replaced.
+ */
+export declare function scaffold(name: string): Promise<string>;
+export declare function dependencyVersionFor(version: unknown): string;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAc5D;AA+BD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAW7D"}