@netforge/engine 0.0.0-stage → 0.1.0

package/dist/api/idle.js

@@ -0,0 +1,104 @@
+/**
+ * Idle declarations (game({ template: "idle" })). The template already runs
+ * the works, the production chain (pumps make brine, pans boil it into salt,
+ * kilns cut crystals), buying and levelling plants, raking, the shared
+ * contract, the shift clock and the referee. A game declares its flat (the
+ * shift, the tending window, raking, the chain's ratios, the contract) and
+ * its plants.
+ *
+ *   saltFlat({ shift: 900, tend: 120, start: 20, rake: { salt: 3, cooldown: 0.4 }, contract: { crystals: 60 } });
+ *   plant("hand_pump", { model: "style.lowpoly.barrel", kind: "pump", cost: 15, growth: 1.15, rate: 2 });
+ *
+ * Production runs only on the room's ticks while the player is in the room
+ * and has tended the works within `tend` seconds: there is no offline
+ * production and nothing a client reports counts.
+ */
+import { z } from "zod";
+import { contentOf, declareContent } from "./registry.js";
+import { assetIdSchema, GameDefinitionError, idSchema, parseOrThrow } from "./schemas.js";
+/** The shortest shift (seconds): earn rules pay once a shift, so this bounds what one seat can earn an hour. */
+export const IDLE_MIN_SHIFT = 600;
+/** The longest tending window (seconds): a works nobody touches for this long stops. */
+export const IDLE_MAX_TEND = 300;
+export const saltFlatSchema = z
+    .object({
+    /** Seconds in a shift. The shift ends for everyone, the end screen shows, a new shift starts from nothing. */
+    shift: z.number().min(IDLE_MIN_SHIFT, `a shift is at least ${IDLE_MIN_SHIFT} seconds (earn pays once a shift)`).max(3600),
+    /** Seconds the works keep running after the player last tended them (raked, bought, shipped). */
+    tend: z.number().min(30).max(IDLE_MAX_TEND, `the works stop at most ${IDLE_MAX_TEND} seconds after the last tend`).default(120),
+    /** Salt (kg) each player starts a shift with. */
+    start: z.number().min(0).max(10_000).default(20),
+    /** Raking: salt (kg) a rake brings in, and seconds between rakes. */
+    rake: z.object({ salt: z.number().min(0.1).max(1000), cooldown: z.number().min(0.2).max(10) }).strict().default({ salt: 3, cooldown: 0.4 }),
+    /** Litres of brine a pan boils into one kg of salt. */
+    brinePerSalt: z.number().min(0.5).max(100).default(3),
+    /** Kg of salt a kiln cuts into one crystal. */
+    saltPerCrystal: z.number().min(1).max(10_000).default(25),
+    /** Every this many kg of salt a player makes raises "salt.packed" (one crate). */
+    packEvery: z.number().min(10).max(100_000).default(100),
+    /** The shared contract: crystals everyone ships together this shift. */
+    contract: z.object({ crystals: z.number().int().min(1).max(100_000) }).strict().default({ crystals: 60 }),
+})
+    .strict();
+export const PLANT_KINDS = ["pump", "pan", "kiln"];
+/**
+ * A plant a player buys and levels with salt. kind "pump" makes `rate`
+ * litres of brine a second a level; "pan" boils up to `rate` kg of salt a
+ * second a level (from brine); "kiln" cuts up to `rate` crystals a second a
+ * level (from salt). The first level costs `cost` kg of salt, each next one
+ * `growth` times the last.
+ */
+export const plantSchema = z
+    .object({
+    model: assetIdSchema,
+    kind: z.enum(PLANT_KINDS, { error: `plant kinds are: ${PLANT_KINDS.join(", ")}` }),
+    cost: z.number().min(1).max(10_000_000),
+    growth: z.number().min(1.05, "growth is at least 1.05 (costs rise every level)").max(3).default(1.15),
+    rate: z.number().positive().max(100_000),
+    /** Most levels a player can buy in a shift. */
+    max: z.number().int().min(1).max(100).default(30),
+})
+    .strict();
+/** The flat: shift length, tending, raking, the chain's ratios and the shared contract (one per game). */
+export function saltFlat(def) {
+    const parsed = parseOrThrow(saltFlatSchema, def, "saltFlat()");
+    declareContent("saltFlat", "flat", parsed);
+    return parsed;
+}
+/** A plant players buy and level (at most 8). */
+export function plant(id, def) {
+    parseOrThrow(idSchema, id, "plant id");
+    const parsed = parseOrThrow(plantSchema, def, `plant("${id}")`);
+    declareContent("plant", id, parsed);
+    return parsed;
+}
+/** Store upgrade stats an idle game reads: plant output (might), raking speed (haste), salt a rake (amount). */
+export const IDLE_STATS = ["might", "haste", "amount"];
+/** The idle content of a manifest, cross-checked (one line per issue). */
+export function idleContent(m) {
+    const issues = [];
+    const flat = contentOf(m, "saltFlat")[0]?.[1];
+    const plants = contentOf(m, "plant");
+    if (!flat)
+        issues.push("declare the flat: saltFlat({ shift, tend, start, rake, contract })");
+    if (plants.length === 0)
+        issues.push('declare at least one plant: plant("hand_pump", { model, kind: "pump", cost, growth, rate })');
+    if (plants.length > 8)
+        issues.push("at most 8 plants per game");
+    for (const k of PLANT_KINDS)
+        if (plants.length > 0 && !plants.some(([, p]) => p.kind === k))
+            issues.push(`declare a "${k}" plant: the chain is pump (brine), pan (salt), kiln (crystals)`);
+    if (m.weapons.size > 0)
+        issues.push("weapon(...) is for the survivor and arena templates; an idle game declares plant(...)");
+    if (m.prefabs.size > 0)
+        issues.push("prefab(...) is not used by the idle template; plants are plant(...)");
+    for (const [id, u] of m.upgrades)
+        if (!IDLE_STATS.includes(u.stat))
+            issues.push(`upgrade("${id}") raises ${u.stat}; the idle template reads ${IDLE_STATS.join(", ")} (plant output, raking speed, salt a rake)`);
+    for (const [id, r] of m.earnRules)
+        if (r.oncePer !== "run")
+            issues.push(`earn.rule("${id}") must be oncePer: "run" (a run is a shift; that is what bounds an idle game's earn)`);
+    if (issues.length > 0 || !flat)
+        throw new GameDefinitionError("idle", issues);
+    return { flat, plants };
+}

package/dist/api/race-harness.d.ts

@@ -0,0 +1,3 @@
+import type { GameManifest } from "./registry.js";
+import type { HarnessOptions, HarnessReport } from "./harness.js";
+export declare function runRaceHarness(manifest: GameManifest, opts: HarnessOptions): Promise<HarnessReport>;

package/dist/api/race-harness.js

@@ -0,0 +1,148 @@
+async function setup(manifest) {
+    const { compileGame } = await import("../game/compile.js");
+    const compiled = compileGame(manifest);
+    if (compiled.mode === "platformer" && compiled.platformer) {
+        const { PlatformCore, routeFor } = await import("../game/platformer.js");
+        const p = compiled.platformer;
+        // The start signal comes after the race runner's 3 s countdown.
+        const start = Math.round(3 * compiled.tickRate);
+        const routes = p.levels.map((level, course) => {
+            const tape = routeFor(level, compiled.tickRate, p.tuning, start);
+            return { course, found: tape !== null, seconds: tape ? Math.round((tape.length / compiled.tickRate) * 10) / 10 : null };
+        });
+        return { core: new PlatformCore(p, compiled.tickRate), tickRate: compiled.tickRate, bots: compiled.bots, roundSeconds: compiled.round?.seconds ?? null, courses: p.levels.length, routes, mishap: "player.fell" };
+    }
+    if (compiled.mode === "racer" && compiled.racer) {
+        const { KartCore } = await import("../game/racer.js");
+        const r = compiled.racer;
+        return { core: new KartCore(r, compiled.tickRate), tickRate: compiled.tickRate, bots: compiled.bots, roundSeconds: compiled.round?.seconds ?? null, courses: r.tracks.length, routes: [], mishap: "kart.bumped" };
+    }
+    throw new Error(`no race machinery for template "${manifest.game.template}"`);
+}
+export async function runRaceHarness(manifest, opts) {
+    const { initSim } = await import("@netforge/engine-sim");
+    const { RaceRunner } = await import("../game/race.js");
+    await initSim();
+    const s = await setup(manifest);
+    const runner = new RaceRunner(manifest, s.core, { bots: s.bots, roundSeconds: s.roundSeconds, courses: s.courses, seed: opts.seed ?? 1 });
+    const players = Math.max(0, Math.min(100, Math.floor(opts.bots)));
+    for (let i = 1; i <= players; i++)
+        runner.joined(i);
+    const skill = opts.bot === "human" ? 0.75 : 1;
+    const perf = globalThis.performance;
+    const now = () => (perf ? perf.now() : Date.now());
+    const times = [];
+    const earned = {};
+    let earnEmitted = 0;
+    let mishaps = 0;
+    const finishes = new Map();
+    const finishSeconds = [];
+    let firstCoin = null;
+    const runs = { won: 0, lost: 0 };
+    let rounds = 0;
+    let quiet = 0;
+    let softlock = false;
+    const best = new Map();
+    let raceTicks = 0;
+    for (let t = 0; t < opts.ticks; t++) {
+        const inputs = new Map();
+        for (let i = 1; i <= players; i++)
+            inputs.set(i, { ...s.core.botInput(i, t, skill), seq: t + 1 });
+        const a = now();
+        runner.beforeStep(inputs);
+        const phase = runner.phaseNow;
+        const info = phase === "racing" ? runner.info() : null;
+        const r = runner.afterStep(s.core.step(inputs));
+        times.push(now() - a);
+        for (const aw of r.awards) {
+            earned[aw.rule] = (earned[aw.rule] ?? 0) + aw.units;
+            earnEmitted += aw.units;
+        }
+        let moved = false;
+        for (const ev of r.events) {
+            const mine = ev.players.filter((p) => p >= 1 && p <= players);
+            if (mine.length === 0)
+                continue;
+            if (ev.name === s.mishap)
+                mishaps += mine.length;
+            if (ev.name === "coin.collected" && firstCoin === null)
+                firstCoin = raceTicks / s.tickRate;
+            if (ev.name === "player.finished") {
+                moved = true;
+                for (const p of mine)
+                    finishes.set(p, (finishes.get(p) ?? 0) + 1);
+                finishSeconds.push(info?.seconds ?? 0);
+            }
+        }
+        if (phase === "racing") {
+            raceTicks++;
+            for (let i = 1; i <= players; i++) {
+                const pr = s.core.progress(i);
+                if (pr > (best.get(i) ?? -1) + 0.002) {
+                    best.set(i, pr);
+                    moved = true;
+                }
+                if (s.core.finished(i))
+                    moved = true;
+            }
+            quiet = moved || players === 0 ? 0 : quiet + 1;
+            if (quiet >= 30 * s.tickRate)
+                softlock = true;
+        }
+        if (phase === "racing" && runner.phaseNow === "results") {
+            rounds++;
+            const done = [...Array(players)].every((_, k) => s.core.finished(k + 1));
+            if (done)
+                runs.won++;
+            else
+                runs.lost++;
+            best.clear();
+        }
+    }
+    const sorted = [...times].sort((x, y) => x - y);
+    const med = (v) => (v.length === 0 ? null : ([...v].sort((x, y) => x - y)[Math.floor(v.length / 2)] ?? null));
+    const totalFinishes = [...finishes.values()].reduce((x, y) => x + y, 0);
+    const fun = {
+        genre: "race",
+        firstThreatSeconds: null,
+        firstRewardSeconds: firstCoin,
+        levelAt: { "60": null, "180": null, "360": null, "540": null },
+        deathsBeforeMinute: null,
+        onScreenAt30: null,
+        contactHitsFirstMinute: null,
+        telegraphedDeathShare: null,
+        spawnsOnScreen: null,
+        survivalSeconds: null,
+        spawnToDamageSeconds: null,
+        spawnDeathShare: null,
+        killSpread: null,
+        leadChanges: null,
+        bossKills: [],
+        downsBySource: {},
+        finishSeconds: med(finishSeconds),
+        finishRate: rounds > 0 && players > 0 ? Math.round((totalFinishes / (rounds * players)) * 100) / 100 : null,
+        mishapsPerRound: rounds > 0 && players > 0 ? Math.round((mishaps / (Math.max(1, rounds) * players)) * 10) / 10 : null,
+        firstCoinSeconds: firstCoin,
+        routes: s.routes ?? [],
+    };
+    const base = {
+        ticks: opts.ticks,
+        bots: players,
+        deaths: mishaps,
+        kills: 0,
+        wave: rounds,
+        runs,
+        maxLevel: 0,
+        peakEnemies: 0,
+        topScore: Math.max(0, ...finishes.values()),
+        scorers: finishes.size,
+        earned,
+        msPerTick: times.reduce((x, y) => x + y, 0) / Math.max(1, times.length),
+        p99MsPerTick: sorted[Math.floor(0.99 * Math.max(0, sorted.length - 1))] ?? 0,
+        earnEmitted,
+        softlock,
+        fun,
+    };
+    const failed = (opts.assert ?? []).filter((x) => !x.check({ ...base, failed: [] })).map((x) => x.name);
+    return { ...base, failed };
+}

package/dist/api/registry.d.ts

@@ -0,0 +1,241 @@
+import type { AchievementDef, AchievementInput, KeeperDef, KeeperInput, MissionDef, MissionInput, TitleDef, TitleInput, DirectorDef, DirectorInput, EarnRuleDef, EarnRuleInput, EarnStakeDef, EarnStakeInput, EarnPotDef, EarnPotInput, EconomyDef, EconomyInput, MetaUpgradeDef, MetaUpgradeInput, GameDef, GameInput, PrefabDef, PrefabInput, SkuDef, SkuInput, UpgradeDef, UpgradeInput, WeaponDef, WeaponInput } from "./schemas.js";
+/** A read-only view of one player, as game logic sees it. */
+export interface PlayerView {
+    readonly id: number;
+    readonly position: readonly [number, number, number];
+    readonly health: number;
+    readonly alive: boolean;
+    /** Kills this run: enemies (survivor) or opponents (arena). */
+    readonly kills: number;
+    /** Times this player died this run. */
+    readonly deaths: number;
+    /** A server bot filling an empty seat (bots never earn). */
+    readonly bot: boolean;
+}
+export interface SpawnRingOptions {
+    readonly count: number;
+    readonly radius: number;
+    /** Centre on this player; default: each spawn picks a living player at random. */
+    readonly around?: number;
+}
+/** Where `spawnEdge` places enemies around the target player's screen. */
+export type EdgeSide = "any" | "ahead" | "behind" | "north" | "south" | "east" | "west";
+export interface SpawnEdgeOptions {
+    readonly count: number;
+    /** The player whose screen edge to use; default: a living player at random for each spawn. */
+    readonly around?: number;
+    /**
+     * Which side: "any" (default), "ahead" or "behind" the player's movement,
+     * or a screen side ("north" is the top of the screen). A side spawns the
+     * whole count from one direction, like a tide or a stream.
+     */
+    readonly side?: EdgeSide;
+    /** Width of the arc on that side, degrees (default 50; ignored for "any"). */
+    readonly spread?: number;
+    /** Health, damage and XP multipliers for these spawns (default 1 each). */
+    readonly scale?: {
+        readonly health?: number;
+        readonly damage?: number;
+        readonly xp?: number;
+    };
+    /** Elites: x6 health, x1.5 damage, x5 XP and a gold rim. */
+    readonly elite?: boolean;
+}
+/**
+ * What a system can do. Deliberately small: no renderer, no network, no
+ * physics handles. Systems run only on the authoritative side (the room
+ * server and the headless harness); clients receive the results in
+ * snapshots. Everything here is still deterministic (tick timers and the
+ * sim's own random), because run verification replays it.
+ */
+export interface SystemContext {
+    /** Fixed ticks since the run started. */
+    readonly tick: () => number;
+    /** Seconds since the run started (tick / tickRate). */
+    readonly time: () => number;
+    /** Living and dead players, in id order. */
+    readonly players: () => readonly PlayerView[];
+    /** Run `fn(n)` every `seconds`, n = 1, 2, 3, ... */
+    readonly every: (seconds: number, fn: (n: number) => void) => void;
+    /** Run `fn` once after `seconds`. */
+    readonly after: (seconds: number, fn: () => void) => void;
+    /** Run `fn` every tick. */
+    readonly onTick: (fn: () => void) => void;
+    /** Spawn at a point. `elite`: x6 health, x1.5 damage, x5 XP, a gold rim (and, with pickups, a chest). Prefer spawnEdge. */
+    readonly spawn: (prefab: string, at: readonly [number, number, number], opts?: {
+        readonly elite?: boolean;
+    }) => void;
+    /** Spawn on a ring around players. Points outside the arena or in a pillar retry a new heading (never clamped to a wall). */
+    readonly spawnRing: (prefab: string, opts: SpawnRingOptions) => void;
+    /**
+     * Spawn just outside the screen (never on it): the right way to bring
+     * enemies in. Returns how many spawned (fewer when no valid spot).
+     */
+    readonly spawnEdge: (prefab: string, opts: SpawnEdgeOptions) => number;
+    /** Raise a game event (earn rules key on these, e.g. "wave.cleared"). It credits `players` (ids), or everyone present. */
+    readonly emit: (event: string, players?: readonly number[]) => void;
+    /** Seeded random 0..1 from the sim's PRNG. */
+    readonly random: () => number;
+    /** Living enemies of a prefab, or of every enemy prefab. */
+    readonly alive: (prefab?: string) => number;
+    /**
+     * Run `fn` when a game event happens: the sim's own ("enemy.killed",
+     * "boss.killed", "player.downed", "player.revived", "player.levelup",
+     * "player.died"; arena: "opponent.killed" crediting the killer,
+     * "round.top", "round.finished"; "run.started" when a player's
+     * earning run starts over, so a counter of yours can start over too) and
+     * any you `emit`. `players` are the
+     * ids it credits. A seat bot's death and a "round.top" with no other
+     * person in the round still arrive here, but pay no earn rule, and
+     * neither does anything you `emit` while handling them.
+     */
+    readonly on: (event: string, fn: (players: readonly number[]) => void) => void;
+    /** Bring players who bled out back beside a living teammate. */
+    readonly respawnDead: () => void;
+    /** End the run: "won" or "lost". The room shows the end screen, then starts a fresh run. */
+    readonly end: (outcome: "won" | "lost") => void;
+    /** Spawn a pickup prefab (a gem, or a special pickup: heal, vacuum, bomb, chest) at a point. */
+    readonly spawnPickup: (prefab: string, at: readonly [number, number, number]) => void;
+    /**
+     * A big centred banner every player sees ("THE TIDE RISES"). tone:
+     * "info" (default), "danger" (a threat is coming) or "reward". Keep it a
+     * few words; the HUD also points at off-screen bosses.
+     */
+    readonly announce: (text: string, opts?: {
+        readonly tone?: "info" | "danger" | "reward";
+    }) => void;
+    /** True while any boss is alive (events usually wait for it). */
+    readonly bossAlive: () => boolean;
+    /** Stop the spawn director for `seconds` (a set piece, a breather). */
+    readonly pauseDirector: (seconds: number) => void;
+    /** Multiply the director's spawn rate by `multiplier` for `seconds` (a surge). */
+    readonly surge: (multiplier: number, seconds: number) => void;
+    /**
+     * Put a countdown on the HUD: "THE BELL WARDEN" in `seconds`. The latest
+     * call replaces the last; it clears itself at zero.
+     */
+    readonly upcoming: (label: string, seconds: number) => void;
+    /** Multiply the XP of every gem dropped for `seconds` (an "ember hour"). */
+    readonly xpBoost: (multiplier: number, seconds: number) => void;
+    /** Scatter `count` of a prefab (props: urns, lanterns) over the field, off every screen. Returns how many. */
+    readonly scatter: (prefab: string, count: number) => number;
+    /** Remove every living enemy of a prefab at once (an event ends): no kills, no drops. Returns how many. */
+    readonly clear: (prefab: string) => number;
+    /**
+     * True when the ground point (x, z) is on the screen of any player who is
+     * up. Spawn where it is false (a dungeon room's far side), so enemies
+     * never pop in where a player is looking.
+     */
+    readonly onScreen: (x: number, z: number) => boolean;
+}
+export type SystemSetup = (ctx: SystemContext) => void;
+export interface GameManifest {
+    readonly game: GameDef;
+    readonly prefabs: ReadonlyMap<string, PrefabDef>;
+    readonly weapons: ReadonlyMap<string, WeaponDef>;
+    readonly upgrades: ReadonlyMap<string, UpgradeDef>;
+    readonly systems: ReadonlyMap<string, SystemSetup>;
+    readonly earnRules: ReadonlyMap<string, EarnRuleDef>;
+    /** The buy-in run terms (earn.stake; every game has one). */
+    readonly stake: EarnStakeDef;
+    /** A PvP pot (earn.pot), or null: arena games only, optional. */
+    readonly pot: EarnPotDef | null;
+    readonly skus: ReadonlyMap<string, SkuDef>;
+    /** The spawn director, if the game declared one. */
+    readonly director: DirectorDef | null;
+    /** Keepers in declaration order (the keeper index). */
+    readonly keepers: ReadonlyMap<string, KeeperDef>;
+    readonly achievements: ReadonlyMap<string, AchievementDef>;
+    readonly missions: ReadonlyMap<string, MissionDef>;
+    /** End-screen titles in declaration order. */
+    readonly titles: ReadonlyMap<string, TitleDef>;
+    /** The coin model (economy(...); the recommended default when not declared). */
+    readonly economy: EconomyDef;
+    /** Meta upgrades in declaration order (empty unless economy({ metaUpgrades: true })). */
+    readonly metaUpgrades: ReadonlyMap<string, MetaUpgradeDef>;
+    /**
+     * Genre content the board-style templates declare (tower defense, idle,
+     * cards, collector): their own typed declarations, validated by their own
+     * schemas, keyed "<kind>:<id>" in declaration order (see declareContent).
+     */
+    readonly content: ReadonlyMap<string, unknown>;
+}
+/** Declare the game. Exactly one per game module; it is the module's default export. */
+export declare function game(def: GameInput): GameDef;
+/** Declare a prefab: a spawnable entity template. */
+export declare function prefab(id: string, def: PrefabInput): PrefabDef;
+/** Declare a weapon (survivor template): it fires by itself; players gain and level weapons at level-up. */
+export declare function weapon(id: string, def: WeaponInput): WeaponDef;
+/** Declare a passive upgrade offered at level-up (survivor template). */
+export declare function upgrade(id: string, def: UpgradeInput): UpgradeDef;
+/**
+ * Declare the spawn director (at most one per game): who spawns, how many,
+ * how fast and how tough, over the run's clock. See directorSchema.
+ */
+export declare function director(def: DirectorInput): DirectorDef;
+/** Declare a system. `setup` runs once when a run starts and schedules work with `every`, `after`, `onTick`. */
+export declare function system(name: string, setup: SystemSetup): void;
+/**
+ * Declare a keeper (a playable character): a start weapon and a signature
+ * passive. Players pick one before their first level; at most 15.
+ */
+export declare function keeper(id: string, def: KeeperInput): KeeperDef;
+/** Declare an achievement (counted per player per run; it unlocks keepers, never coins). */
+export declare function achievement(id: string, def: AchievementInput): AchievementDef;
+/** Declare a daily goal (the HUD shows three a day; it pays nothing). */
+export declare function mission(id: string, def: MissionInput): MissionDef;
+/** Declare an end-screen title ("The Butcher": the most kills). */
+export declare function title(id: string, def: TitleInput): TitleDef;
+/**
+ * Declare the game's coin model (at most once). Without it a game uses the
+ * recommended default: coins buy cosmetics, unlocks and in-run consumables,
+ * never permanent stat power. economy({ store: "cosmetics" }) sells looks
+ * only; economy({ metaUpgrades: true }) opts in to metaUpgrade(...).
+ */
+export declare function economy(def?: EconomyInput): EconomyDef;
+/**
+ * Declare a meta upgrade: a permanent stat bonus a player buys with coins,
+ * level by level (opt-in: economy({ metaUpgrades: true })). The engine caps
+ * meta power at +15% per stat and +30% in total, and costs grow
+ * geometrically. The store shows every level's bonus and price.
+ */
+export declare function metaUpgrade(id: string, def: MetaUpgradeInput): MetaUpgradeDef;
+/** Earn rules (every game must have at least one). */
+export declare const earn: {
+    rule(id: string, def: EarnRuleInput): EarnRuleDef;
+    /**
+     * The buy-in run, the mandatory sink loop: earning
+     * above free play takes a stake of the game's coins at run start. One per
+     * game, written on one line so Net Forge's Launch panel can read and edit it.
+     */
+    stake(def: EarnStakeInput): EarnStakeDef;
+    /**
+     * A PvP pot, optional, for the arena
+     * template: entrants pay `entry` coins before a round, the result splits
+     * the pot, and `recycle` of it stays in the reward pool.
+     */
+    pot(def: EarnPotInput): EarnPotDef;
+};
+/** Store SKUs: upgrades and cosmetics priced in the game's coins (and/or USDG). */
+export declare const store: {
+    sku(id: string, def: SkuInput): SkuDef;
+};
+/**
+ * Collect and cross-check what the game module declared. Called by the
+ * build and the runtime after importing the module, not by game code.
+ */
+export declare function collectManifest(): GameManifest;
+/**
+ * A genre declaration (rules/genres: tower(...), board(...), card(...)):
+ * stored under "<kind>:<id>" for the genre's compile step to read. Ids are
+ * unique per kind. Game code calls the genre's own typed function, never this.
+ */
+export declare function declareContent(kind: string, id: string, value: unknown): void;
+/** Genre content of one kind, in declaration order (id, value). */
+export declare function contentOf<T>(m: Pick<GameManifest, "content">, kind: string): [string, T][];
+/** The coin spend reason a buy-in run's stake is spent under (the referee reads it at run start). */
+export declare const STAKE_REASON = "stake";
+/** The coin spend reason a PvP pot entry is spent under. */
+export declare const POT_REASON = "pot";
+/** Forget all declarations (the build and tests load several game modules in one process). */
+export declare function resetRegistry(): void;