@netforge/engine 0.0.0-stage → 0.2.0

package/dist/api/schemas.d.ts

@@ -0,0 +1,958 @@
+import { z } from "zod";
+/**
+ * Zod schemas for everything a game declares ("Everything
+ * is typed with Zod schemas, so a bad prefab fails at build with a message
+ * the agent can act on"). Messages are written for the agent that reads them.
+ */
+/** Templates carry the genre machinery; the model adds content and rules. */
+export declare const TEMPLATES: readonly ["survivor", "arena", "dungeon", "racer", "platformer", "tower-defense", "party", "idle", "cards", "collector"];
+/** Art styles of the asset library (§10). */
+export declare const STYLES: readonly ["pixel", "lowpoly", "toon", "voxel", "ps1", "handdrawn"];
+export declare const idSchema: z.ZodString;
+export declare const assetIdSchema: z.ZodString;
+export declare const vec3Schema: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+/** Lighting presets of the engine's render stack (sun, sky, fog and grading together). */
+export declare const LOOK_PRESETS: readonly ["night", "dusk", "day", "studio"];
+/** GPU particle presets the engine draws (one draw call for all of them). */
+export declare const PARTICLE_PRESETS: readonly ["sparks", "burst", "embers", "smoke", "hitSpark", "dust", "magic"];
+/** Ground decals left behind (scorch marks, splats, shock rings). */
+export declare const DECAL_PRESETS: readonly ["none", "scorch", "splat", "ring"];
+/** Procedural sound cues of the feel kit (no audio files needed). */
+export declare const SOUND_CUES: readonly ["none", "hit", "crunch", "boom", "zap", "chime", "thud"];
+/**
+ * How the game looks (the engine's render stack):
+ * one preset sets lighting, shadows, sky, fog and colour grading; the
+ * other fields fine-tune it. Quality tiers still scale everything down on
+ * slow devices, so turning things on here never breaks the frame-rate bar.
+ */
+export declare const lookSchema: z.ZodObject<{
+    preset: z.ZodDefault<z.ZodEnum<{
+        night: "night";
+        dusk: "dusk";
+        day: "day";
+        studio: "studio";
+    }>>;
+    bloom: z.ZodOptional<z.ZodNumber>;
+    shadows: z.ZodOptional<z.ZodBoolean>;
+    outline: z.ZodOptional<z.ZodBoolean>;
+    fog: z.ZodOptional<z.ZodNumber>;
+    exposure: z.ZodOptional<z.ZodNumber>;
+    saturation: z.ZodOptional<z.ZodNumber>;
+    contrast: z.ZodOptional<z.ZodNumber>;
+    vignette: z.ZodOptional<z.ZodNumber>;
+    tint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Game feel for a prefab or a weapon. On a prefab it
+ * is what its death and its hits look and sound like; on a weapon, its
+ * impacts. Everything is client-side presentation: it never changes the
+ * simulation, so it is safe to tune freely.
+ */
+export declare const feelSchema: z.ZodObject<{
+    shake: z.ZodOptional<z.ZodNumber>;
+    hitStop: z.ZodOptional<z.ZodNumber>;
+    particles: z.ZodOptional<z.ZodEnum<{
+        sparks: "sparks";
+        burst: "burst";
+        embers: "embers";
+        smoke: "smoke";
+        hitSpark: "hitSpark";
+        dust: "dust";
+        magic: "magic";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    decal: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        scorch: "scorch";
+        splat: "splat";
+        ring: "ring";
+    }>>;
+    sound: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        hit: "hit";
+        crunch: "crunch";
+        boom: "boom";
+        zap: "zap";
+        chime: "chime";
+        thud: "thud";
+    }>>;
+    flash: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const placeSchema: z.ZodObject<{
+    chunks: z.ZodString;
+    spawn: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+}, z.core.$strict>;
+/**
+ * Platformer: one course, side view, in metres. x runs right (start to
+ * flag), y runs up. Boxes are [x, y, width, height] with [x, y] the
+ * bottom-left corner; ledges are [x, y, width] one-way platforms (stand on
+ * top, jump up through, Down + Jump drops through).
+ */
+export declare const platformLevelSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    flag: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    killY: z.ZodOptional<z.ZodNumber>;
+    blocks: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    ledges: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    hazards: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    springs: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    movers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        at: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        to: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        seconds: z.ZodNumber;
+        phase: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    coins: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    checkpoints: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strict>;
+/** Platformer feel numbers (the defaults are tuned; change a few at a time). */
+export declare const motorSchema: z.ZodObject<{
+    runSpeed: z.ZodOptional<z.ZodNumber>;
+    jumpHeight: z.ZodOptional<z.ZodNumber>;
+    timeToApex: z.ZodOptional<z.ZodNumber>;
+    fallGravity: z.ZodOptional<z.ZodNumber>;
+    jumpCut: z.ZodOptional<z.ZodNumber>;
+    coyoteSeconds: z.ZodOptional<z.ZodNumber>;
+    bufferSeconds: z.ZodOptional<z.ZodNumber>;
+    airJumps: z.ZodOptional<z.ZodNumber>;
+    dashSpeed: z.ZodOptional<z.ZodNumber>;
+    airAccel: z.ZodOptional<z.ZodNumber>;
+    groundAccel: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Racer: one circuit, on the ground plane, in metres. points is the closed
+ * centreline in driving order (a smooth curve runs through them); boosts and
+ * coins are [lap fraction 0..1, lateral -1..1 of the half width].
+ */
+export declare const kartTrackSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    width: z.ZodNumber;
+    laps: z.ZodNumber;
+    verge: z.ZodOptional<z.ZodNumber>;
+    boosts: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    coins: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strict>;
+/** Racer handling (the defaults are tuned; change a few at a time). */
+export declare const kartTuningSchema: z.ZodObject<{
+    topSpeed: z.ZodOptional<z.ZodNumber>;
+    accel: z.ZodOptional<z.ZodNumber>;
+    turn: z.ZodOptional<z.ZodNumber>;
+    grip: z.ZodOptional<z.ZodNumber>;
+    driftGrip: z.ZodOptional<z.ZodNumber>;
+    grass: z.ZodOptional<z.ZodNumber>;
+    boostSpeed: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const gameSchema: z.ZodObject<{
+    template: z.ZodEnum<{
+        survivor: "survivor";
+        arena: "arena";
+        dungeon: "dungeon";
+        racer: "racer";
+        platformer: "platformer";
+        "tower-defense": "tower-defense";
+        party: "party";
+        idle: "idle";
+        cards: "cards";
+        collector: "collector";
+    }>;
+    style: z.ZodEnum<{
+        pixel: "pixel";
+        lowpoly: "lowpoly";
+        toon: "toon";
+        voxel: "voxel";
+        ps1: "ps1";
+        handdrawn: "handdrawn";
+    }>;
+    places: z.ZodRecord<z.ZodString, z.ZodObject<{
+        chunks: z.ZodString;
+        spawn: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strict>>;
+    players: z.ZodObject<{
+        prefab: z.ZodString;
+        max: z.ZodNumber;
+        weapon: z.ZodOptional<z.ZodString>;
+        xp: z.ZodOptional<z.ZodObject<{
+            base: z.ZodNumber;
+            growth: z.ZodNumber;
+            exponent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        rerolls: z.ZodOptional<z.ZodNumber>;
+        magnet: z.ZodOptional<z.ZodNumber>;
+        hitIframes: z.ZodOptional<z.ZodNumber>;
+        bossHealthPerPlayer: z.ZodOptional<z.ZodNumber>;
+        share: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            collector: "collector";
+            nearby: "nearby";
+            all: "all";
+        }>, z.ZodObject<{
+            mode: z.ZodEnum<{
+                collector: "collector";
+                nearby: "nearby";
+                all: "all";
+            }>;
+            fraction: z.ZodDefault<z.ZodNumber>;
+            radius: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        crit: z.ZodOptional<z.ZodObject<{
+            chance: z.ZodNumber;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        reviveBuff: z.ZodOptional<z.ZodObject<{
+            seconds: z.ZodNumber;
+            damage: z.ZodDefault<z.ZodNumber>;
+            speed: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        downed: z.ZodOptional<z.ZodObject<{
+            seconds: z.ZodDefault<z.ZodNumber>;
+            crawl: z.ZodDefault<z.ZodNumber>;
+            selfRevives: z.ZodDefault<z.ZodNumber>;
+            respawn: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        lateJoinBehind: z.ZodOptional<z.ZodNumber>;
+        loadout: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        bots: z.ZodOptional<z.ZodNumber>;
+        respawn: z.ZodOptional<z.ZodNumber>;
+        drop: z.ZodOptional<z.ZodString>;
+        appearance: z.ZodOptional<z.ZodObject<{
+            tint: z.ZodOptional<z.ZodString>;
+            accent: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodNumber>;
+            parts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                horns: "horns";
+                ears_long: "ears_long";
+                ears_round: "ears_round";
+                antenna: "antenna";
+                crown: "crown";
+                hat_cap: "hat_cap";
+                hat_top: "hat_top";
+                mustache: "mustache";
+                tail: "tail";
+                tail_bolt: "tail_bolt";
+                wings: "wings";
+                armor: "armor";
+                backpack: "backpack";
+                big_wheels: "big_wheels";
+            }>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    tickRate: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<30>, z.ZodLiteral<60>]>>;
+    arena: z.ZodOptional<z.ZodObject<{
+        halfSize: z.ZodNumber;
+        pillars: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        spawns: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strict>>;
+    field: z.ZodOptional<z.ZodObject<{
+        halfSize: z.ZodNumber;
+        pillars: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        walls: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        floors: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+    }, z.core.$strict>>;
+    levels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        flag: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        killY: z.ZodOptional<z.ZodNumber>;
+        blocks: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        ledges: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        hazards: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        springs: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+        movers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            at: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            to: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            seconds: z.ZodNumber;
+            phase: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        coins: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        checkpoints: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    }, z.core.$strict>>>;
+    motor: z.ZodOptional<z.ZodObject<{
+        runSpeed: z.ZodOptional<z.ZodNumber>;
+        jumpHeight: z.ZodOptional<z.ZodNumber>;
+        timeToApex: z.ZodOptional<z.ZodNumber>;
+        fallGravity: z.ZodOptional<z.ZodNumber>;
+        jumpCut: z.ZodOptional<z.ZodNumber>;
+        coyoteSeconds: z.ZodOptional<z.ZodNumber>;
+        bufferSeconds: z.ZodOptional<z.ZodNumber>;
+        airJumps: z.ZodOptional<z.ZodNumber>;
+        dashSpeed: z.ZodOptional<z.ZodNumber>;
+        airAccel: z.ZodOptional<z.ZodNumber>;
+        groundAccel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tracks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        width: z.ZodNumber;
+        laps: z.ZodNumber;
+        verge: z.ZodOptional<z.ZodNumber>;
+        boosts: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+        coins: z.ZodDefault<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    }, z.core.$strict>>>;
+    kart: z.ZodOptional<z.ZodObject<{
+        topSpeed: z.ZodOptional<z.ZodNumber>;
+        accel: z.ZodOptional<z.ZodNumber>;
+        turn: z.ZodOptional<z.ZodNumber>;
+        grip: z.ZodOptional<z.ZodNumber>;
+        driftGrip: z.ZodOptional<z.ZodNumber>;
+        grass: z.ZodOptional<z.ZodNumber>;
+        boostSpeed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    round: z.ZodOptional<z.ZodObject<{
+        seconds: z.ZodNumber;
+        frags: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    look: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodDefault<z.ZodEnum<{
+            night: "night";
+            dusk: "dusk";
+            day: "day";
+            studio: "studio";
+        }>>;
+        bloom: z.ZodOptional<z.ZodNumber>;
+        shadows: z.ZodOptional<z.ZodBoolean>;
+        outline: z.ZodOptional<z.ZodBoolean>;
+        fog: z.ZodOptional<z.ZodNumber>;
+        exposure: z.ZodOptional<z.ZodNumber>;
+        saturation: z.ZodOptional<z.ZodNumber>;
+        contrast: z.ZodOptional<z.ZodNumber>;
+        vignette: z.ZodOptional<z.ZodNumber>;
+        tint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * Enemy behaviours the sim runs (roles). Every big hit is telegraphed with
+ * a ground marker that fills before it lands.
+ *  - chase (default): runs at the nearest player. tank: chase, for slow heavy prefabs (give it mass).
+ *  - idle / none: stands still.
+ *  - runner: aims where the player will be in 0.5 s. Fast and fragile.
+ *  - charger: inside attack.range (6 m) stops, shows a lane for 0.55 s, dashes 3.4x along it for 0.6 s, recovers 1 s.
+ *  - ranged: keeps ~80% of attack.range (10 m), backs off, shows an aim line 0.3 s, fires a slow shot (attack.speed 7 m/s).
+ *  - bomber: next to a player stops, arms a 1 s fuse circle (attack.radius 2.5 m), explodes for 1.4x damage; the blast hurts enemies too.
+ *  - shielder: every 6 s shields the 6 nearest allies for 35% of their health, 8 s.
+ *  - healer: every 3.5 s heals the 6 nearest allies 7%.
+ *  - summoner: keeps its distance and calls attack.count (2) attack.summon adds every 7 s, at most 4 alive.
+ *  - flee: runs from the nearest player. wander: drifts.
+ * Anything else is rejected at build time, never silently ignored.
+ */
+export declare const AI_BEHAVIOURS: readonly ["none", "chase", "idle", "tank", "runner", "charger", "ranged", "bomber", "shielder", "healer", "summoner", "flee", "wander"];
+/** Attacks a boss can declare. Each one is telegraphed. */
+export declare const BOSS_ATTACKS: readonly ["slam", "dash", "leap", "rain", "ring", "fan", "summon"];
+/** Numbers for an enemy's role attack (all optional; the role's defaults fill the rest). Seconds and metres. */
+export declare const attackSchema: z.ZodObject<{
+    damage: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodNumber>;
+    windup: z.ZodOptional<z.ZodNumber>;
+    cooldown: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    radius: z.ZodOptional<z.ZodNumber>;
+    summon: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A boss's patterns: it alternates near and far modes every 4-9 s and picks
+ * telegraphed attacks: slam (circle around it, 0.85 s), dash (11 m lane,
+ * 0.75 s), leap (lands on a circle at the target, 1.15 s), rain (4 circles
+ * near players), ring (14 shots outward), fan (7 shots at the target),
+ * summon (adds). Below enrageAt of its health it moves 15% faster, winds up
+ * 20% quicker and throws more. A "mini" boss raises "miniboss.killed" when
+ * it dies; a "final" boss (default) raises "boss.killed".
+ */
+export declare const bossSchema: z.ZodObject<{
+    attacks: z.ZodArray<z.ZodEnum<{
+        ring: "ring";
+        slam: "slam";
+        dash: "dash";
+        leap: "leap";
+        rain: "rain";
+        fan: "fan";
+        summon: "summon";
+    }>>;
+    enrageAt: z.ZodDefault<z.ZodNumber>;
+    summon: z.ZodOptional<z.ZodString>;
+    rank: z.ZodDefault<z.ZodEnum<{
+        final: "final";
+        mini: "mini";
+    }>>;
+}, z.core.$strict>;
+export declare const prefabSchema: z.ZodObject<{
+    model: z.ZodString;
+    health: z.ZodNumber;
+    speed: z.ZodNumber;
+    ai: z.ZodOptional<z.ZodEnum<{
+        idle: "idle";
+        none: "none";
+        chase: "chase";
+        tank: "tank";
+        runner: "runner";
+        charger: "charger";
+        ranged: "ranged";
+        bomber: "bomber";
+        shielder: "shielder";
+        healer: "healer";
+        summoner: "summoner";
+        flee: "flee";
+        wander: "wander";
+    }>>;
+    attack: z.ZodOptional<z.ZodObject<{
+        damage: z.ZodOptional<z.ZodNumber>;
+        range: z.ZodOptional<z.ZodNumber>;
+        windup: z.ZodOptional<z.ZodNumber>;
+        cooldown: z.ZodOptional<z.ZodNumber>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        radius: z.ZodOptional<z.ZodNumber>;
+        summon: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    split: z.ZodOptional<z.ZodObject<{
+        into: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    radius: z.ZodOptional<z.ZodNumber>;
+    damage: z.ZodOptional<z.ZodNumber>;
+    drops: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        chance: z.ZodNumber;
+    }, z.core.$strict>]>>>;
+    pickup: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<{
+            heal: "heal";
+            vacuum: "vacuum";
+            bomb: "bomb";
+            chest: "chest";
+        }>;
+        amount: z.ZodOptional<z.ZodNumber>;
+        evolve: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    prop: z.ZodOptional<z.ZodBoolean>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        pickup: "pickup";
+        enemy: "enemy";
+    }>>;
+    value: z.ZodOptional<z.ZodNumber>;
+    boss: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        attacks: z.ZodArray<z.ZodEnum<{
+            ring: "ring";
+            slam: "slam";
+            dash: "dash";
+            leap: "leap";
+            rain: "rain";
+            fan: "fan";
+            summon: "summon";
+        }>>;
+        enrageAt: z.ZodDefault<z.ZodNumber>;
+        summon: z.ZodOptional<z.ZodString>;
+        rank: z.ZodDefault<z.ZodEnum<{
+            final: "final";
+            mini: "mini";
+        }>>;
+    }, z.core.$strict>]>>;
+    mass: z.ZodOptional<z.ZodNumber>;
+    feel: z.ZodOptional<z.ZodObject<{
+        shake: z.ZodOptional<z.ZodNumber>;
+        hitStop: z.ZodOptional<z.ZodNumber>;
+        particles: z.ZodOptional<z.ZodEnum<{
+            sparks: "sparks";
+            burst: "burst";
+            embers: "embers";
+            smoke: "smoke";
+            hitSpark: "hitSpark";
+            dust: "dust";
+            magic: "magic";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        decal: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            scorch: "scorch";
+            splat: "splat";
+            ring: "ring";
+        }>>;
+        sound: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            hit: "hit";
+            crunch: "crunch";
+            boom: "boom";
+            zap: "zap";
+            chime: "chime";
+            thud: "thud";
+        }>>;
+        flash: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    appearance: z.ZodOptional<z.ZodObject<{
+        tint: z.ZodOptional<z.ZodString>;
+        accent: z.ZodOptional<z.ZodString>;
+        scale: z.ZodOptional<z.ZodNumber>;
+        parts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            horns: "horns";
+            ears_long: "ears_long";
+            ears_round: "ears_round";
+            antenna: "antenna";
+            crown: "crown";
+            hat_cap: "hat_cap";
+            hat_top: "hat_top";
+            mustache: "mustache";
+            tail: "tail";
+            tail_bolt: "tail_bolt";
+            wings: "wings";
+            armor: "armor";
+            backpack: "backpack";
+            big_wheels: "big_wheels";
+        }>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WEAPON_KINDS: readonly ["nova", "bolt", "orbit", "blaster", "beam", "cone", "chain", "aura", "meteor", "boomerang"];
+/** Numbers a weapon level can change. */
+export declare const LEVEL_FIELDS: readonly ["damage", "cooldown", "count", "pierce", "range", "speed", "knockback", "spread"];
+export declare const weaponLevelSchema: z.ZodObject<{
+    damage: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    cooldown: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    count: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    pierce: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    range: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    speed: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    knockback: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    spread: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+}, z.core.$strict>;
+/**
+ * A weapon.
+ * Survivor template (fires by itself):
+ *  - nova: hits every enemy within `range` m, every `cooldown` s, when one is in range;
+ *  - bolt: shoots `count` projectiles at the nearest enemy within `range` m at `speed` m/s, each passing through `pierce` enemies;
+ *  - orbit: `count` blades circle at `range` m, `speed` rad/s, hitting what they touch;
+ *  - cone: sweeps `spread` degrees (360: all around) where the player faces, `range` m deep;
+ *  - chain: strikes the nearest enemy in `range`, then jumps `count` times to the nearest enemy within `speed` m (default 4);
+ *  - aura: a field of `range` m around the player, damaging everything inside every `cooldown` s;
+ *  - meteor: `count` circles of `blast` m land on random enemies within `range` m, 0.6 s after they show;
+ *  - boomerang: `count` blades fly out `range` m at `speed` m/s and come back, hitting everything both ways.
+ * levels: [...] declares each level's change (see weaponLevelSchema); without it each level adds 25%
+ * damage, cuts cooldowns 6%, adds a projectile or blade every second level and grows novas and auras 8%.
+ * evolve: { into, requires }: at max level, with the passive `requires` taken, the evolution card
+ * always shows; the weapon `into` (declared like any weapon, never offered on its own) replaces it.
+ * Arena template (fires while the player holds fire, along their aim):
+ *  - blaster: `count` projectiles fanned over `spread` degrees at `speed` m/s for `range` m;
+ *  - beam: an instant hit to `range` m, stopped by pillars (lag-compensated on the server);
+ *  - nova: hits every opponent within `range` m.
+ */
+export declare const weaponSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        nova: "nova";
+        bolt: "bolt";
+        orbit: "orbit";
+        blaster: "blaster";
+        beam: "beam";
+        cone: "cone";
+        chain: "chain";
+        aura: "aura";
+        meteor: "meteor";
+        boomerang: "boomerang";
+    }>;
+    damage: z.ZodNumber;
+    cooldown: z.ZodNumber;
+    range: z.ZodNumber;
+    count: z.ZodDefault<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    pierce: z.ZodDefault<z.ZodNumber>;
+    knockback: z.ZodDefault<z.ZodNumber>;
+    maxLevel: z.ZodOptional<z.ZodNumber>;
+    spread: z.ZodOptional<z.ZodNumber>;
+    blast: z.ZodOptional<z.ZodNumber>;
+    levels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        damage: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        cooldown: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        count: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        pierce: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        range: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        speed: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        knockback: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        spread: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    }, z.core.$strict>>>;
+    evolve: z.ZodOptional<z.ZodObject<{
+        into: z.ZodString;
+        requires: z.ZodString;
+    }, z.core.$strict>>;
+    feel: z.ZodOptional<z.ZodObject<{
+        shake: z.ZodOptional<z.ZodNumber>;
+        hitStop: z.ZodOptional<z.ZodNumber>;
+        particles: z.ZodOptional<z.ZodEnum<{
+            sparks: "sparks";
+            burst: "burst";
+            embers: "embers";
+            smoke: "smoke";
+            hitSpark: "hitSpark";
+            dust: "dust";
+            magic: "magic";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        decal: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            scorch: "scorch";
+            splat: "splat";
+            ring: "ring";
+        }>>;
+        sound: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            hit: "hit";
+            crunch: "crunch";
+            boom: "boom";
+            zap: "zap";
+            chime: "chime";
+            thud: "thud";
+        }>>;
+        flash: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const STAT_KINDS: readonly ["speed", "maxHealth", "magnet", "might", "haste", "regen", "armor", "area", "amount"];
+/**
+ * A passive upgrade offered at level-up. Per level: speed and might
+ * multiply by (1 + step x level); haste cuts cooldowns by step x level;
+ * maxHealth and magnet (m) add step x level; regen heals step x level per
+ * second; armor removes step x level from each hit (floor 1); area grows
+ * novas, auras, cones, meteors and orbits by (1 + step x level); amount adds
+ * step x level projectiles, blades, jumps or meteors. Up to 8 passives.
+ */
+export declare const upgradeSchema: z.ZodObject<{
+    stat: z.ZodEnum<{
+        armor: "armor";
+        magnet: "magnet";
+        speed: "speed";
+        amount: "amount";
+        maxHealth: "maxHealth";
+        might: "might";
+        haste: "haste";
+        regen: "regen";
+        area: "area";
+    }>;
+    step: z.ZodNumber;
+    maxLevel: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A value over run time: a constant, or keyframes [[seconds, value], ...]
+ * in increasing time, linear between them and held after the last one.
+ * "Make it harder" is a matter of raising the values.
+ */
+export declare const curveSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>;
+/** One enemy the director can spawn, and when. */
+export declare const directorEntrySchema: z.ZodObject<{
+    prefab: z.ZodString;
+    weight: z.ZodDefault<z.ZodNumber>;
+    from: z.ZodDefault<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodNumber>;
+    group: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+}, z.core.$strict>;
+/**
+ * The spawn director: one per game. It replaces "top the crowd up to N"
+ * loops. Every tick it spawns enemies from `pool` at `rate` per second,
+ * up to `alive` living enemies, just outside each player's screen (never
+ * on it), with new enemies' health, damage and XP scaled by the curves.
+ * More players raise `alive` and `rate` by `perPlayer` each; a living boss
+ * multiplies `rate` by `whileBoss`. At the cap, the bodies it could not
+ * spawn become `crowded` multipliers on the next spawns (tougher, not
+ * more). Stragglers far off screen are moved back to the edge ahead of a
+ * moving player (`recycle`).
+ */
+export declare const directorSchema: z.ZodObject<{
+    alive: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>;
+    rate: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>;
+    health: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>>;
+    damage: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>>;
+    xp: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>>;
+    speed: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>]>>;
+    pool: z.ZodArray<z.ZodObject<{
+        prefab: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        from: z.ZodDefault<z.ZodNumber>;
+        until: z.ZodOptional<z.ZodNumber>;
+        group: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+    }, z.core.$strict>>;
+    fade: z.ZodOptional<z.ZodObject<{
+        after: z.ZodNumber;
+        weight: z.ZodNumber;
+    }, z.core.$strict>>;
+    perPlayer: z.ZodDefault<z.ZodNumber>;
+    whileBoss: z.ZodDefault<z.ZodNumber>;
+    crowded: z.ZodDefault<z.ZodObject<{
+        health: z.ZodDefault<z.ZodNumber>;
+        damage: z.ZodDefault<z.ZodNumber>;
+        xp: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    recycle: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        seconds: z.ZodDefault<z.ZodNumber>;
+        margin: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    elites: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        every: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strict>>;
+    ahead: z.ZodDefault<z.ZodNumber>;
+    start: z.ZodDefault<z.ZodNumber>;
+    max: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const earnRuleSchema: z.ZodObject<{
+    when: z.ZodString;
+    n: z.ZodDefault<z.ZodNumber>;
+    pay: z.ZodNumber;
+    oncePer: z.ZodEnum<{
+        day: "day";
+        run: "run";
+        lifetime: "lifetime";
+    }>;
+}, z.core.$strict>;
+/**
+ * Buy-in runs, the mandatory sink loop (the sink loop is a
+ * stake). Earning above free play needs a
+ * stake of the game's coins at run start. The referee fixes the stake when
+ * the run starts (server state, never the client). A staked run pays its
+ * free earn as usual plus a share of `stake x multiple`: the share is the
+ * part of the run's free earn the player actually made (skill decides it).
+ * What the run does not win back stays in the RewardVault for other
+ * players. Every game declares one, on one line in game.ts:
+ * `earn.stake({ min: 20, max: 200, multiple: 2 });`
+ */
+/** PLACEHOLDER: the most a stake's payout ceiling may be, as a multiple of the stake. */
+export declare const STAKE_MAX_MULTIPLE = 2;
+/** Highest stake one run may take, in coins (the source reader's bound too). */
+export declare const STAKE_MAX_COINS = 1000000;
+export declare const earnStakeSchema: z.ZodObject<{
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+    multiple: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * PvP pots (the sink loop), for player-versus-
+ * player games (the arena template). Each player who wants in pays the
+ * same `entry` in coins before a round; at the round's end the pot, less
+ * the `recycle` share that stays in the reward pool, is split by how much
+ * of the round's earn each entrant made (the room's verified units, never
+ * a draw). A round where no entrant earned recycles the whole pot.
+ */
+export declare const earnPotSchema: z.ZodObject<{
+    entry: z.ZodNumber;
+    recycle: z.ZodNumber;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * What buying a SKU gives (the recommended coin model). Leave `grants` out for an in-run consumable: a
+ * room command applied once ("revive", or a run upgrade named after a
+ * declared passive). `{ cosmetic: n }` is a look the player owns for good
+ * (cosmetic id n, drawn by the client). `{ keeper: id }` unlocks a keeper
+ * for good: a character, a starting loadout or a sidegrade, never more
+ * power than the keepers anyone can earn. Owned grants live in the
+ * player's profile on the room server, never in the browser.
+ */
+export declare const skuGrantSchema: z.ZodUnion<readonly [z.ZodObject<{
+    cosmetic: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    keeper: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    gear: z.ZodString;
+    loseBelow: z.ZodNumber;
+}, z.core.$strict>]>;
+/**
+ * A store item. Every game has coins (1 coin = 1 game token, shown under
+ * the token's own name, symbol and logo): price cosmetics, unlocks and
+ * in-run consumables in `coins`. Players spend earned coins first, off
+ * chain, then their wallet. `usdg` sells the item for dollars as well.
+ * `token` is the old name for `coins` and reads as coins. Permanent stat
+ * power is never a SKU: it is a metaUpgrade, opt-in through economy().
+ */
+export declare const skuSchema: z.ZodPipe<z.ZodObject<{
+    coins: z.ZodOptional<z.ZodNumber>;
+    usdg: z.ZodOptional<z.ZodNumber>;
+    token: z.ZodOptional<z.ZodNumber>;
+    grants: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        cosmetic: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        keeper: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        gear: z.ZodString;
+        loseBelow: z.ZodNumber;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodTransform<{
+    grants?: {
+        cosmetic: number;
+    } | {
+        keeper: string;
+    } | {
+        gear: string;
+        loseBelow: number;
+    } | undefined;
+    usdg?: number | undefined;
+    coins?: number | undefined;
+}, {
+    coins?: number | undefined;
+    usdg?: number | undefined;
+    token?: number | undefined;
+    grants?: {
+        cosmetic: number;
+    } | {
+        keeper: string;
+    } | {
+        gear: string;
+        loseBelow: number;
+    } | undefined;
+}>>;
+/**
+ * The game's coin model. The
+ * default needs no declaration: coins buy cosmetics, unlocks (keepers,
+ * starting loadouts, sidegrades) and in-run consumables (a revive), and
+ * never permanent stat power.
+ *   economy({ store: "cosmetics" })     cosmetics only: no unlocks, no consumables.
+ *   economy({ metaUpgrades: true })     opt in to metaUpgrade(...): permanent stat
+ *                                       upgrades for coins, under the engine's caps.
+ */
+export declare const economySchema: z.ZodObject<{
+    store: z.ZodDefault<z.ZodEnum<{
+        default: "default";
+        cosmetics: "cosmetics";
+    }>>;
+    metaUpgrades: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Stats a meta upgrade may raise (each a percentage of the base). */
+export declare const META_STATS: readonly ["speed", "maxHealth", "magnet", "might", "haste", "area"];
+/** Hard caps (engine-enforced, not a game setting): +15% to any one stat from meta upgrades, +30% across all of them. */
+export declare const META_MAX_PER_STAT = 0.15;
+export declare const META_MAX_TOTAL = 0.3;
+/** Most levels of one meta upgrade, most meta upgrades per game, and the slowest cost growth (geometric). */
+export declare const META_MAX_LEVELS = 5;
+export declare const META_MAX_UPGRADES = 8;
+export declare const META_MIN_GROWTH = 1.5;
+/**
+ * A meta upgrade (opt-in: economy({ metaUpgrades: true })): a permanent,
+ * per-player stat bonus bought with coins, one level at a time. Level k
+ * costs round(cost x growth^(k-1)) coins and adds `step` (0.05 = +5%) to
+ * `stat`. speed, might and area multiply; haste cuts cooldowns; maxHealth
+ * and magnet add that share of the base. The engine caps the sum per stat
+ * at +15% and across stats at +30%, and the store shows each level's
+ * bonus and price.
+ */
+export declare const metaUpgradeSchema: z.ZodObject<{
+    stat: z.ZodEnum<{
+        magnet: "magnet";
+        speed: "speed";
+        maxHealth: "maxHealth";
+        might: "might";
+        haste: "haste";
+        area: "area";
+    }>;
+    step: z.ZodNumber;
+    levels: z.ZodNumber;
+    cost: z.ZodNumber;
+    growth: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A keeper (a playable character): its start weapon and one signature
+ * passive at level 1. `unlock` names an achievement that unlocks it (no
+ * unlock and not sold: available from the start). A keeper declared with
+ * no unlock can instead be sold for coins by a store SKU with
+ * { grants: { keeper } }; it is earned or bought, never both. The first
+ * keeper is everyone's default and is always free.
+ */
+export declare const keeperSchema: z.ZodObject<{
+    name: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    tint: z.ZodOptional<z.ZodString>;
+    weapon: z.ZodString;
+    passive: z.ZodOptional<z.ZodString>;
+    unlock: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * An achievement: a player reaches it when their count of `when` reaches
+ * `n` in one run ("evolve a weapon": { when: "player.evolved" }). It pays
+ * nothing; keepers can unlock with it.
+ */
+export declare const achievementSchema: z.ZodObject<{
+    title: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    when: z.ZodString;
+    n: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A daily goal ("kill an elite", "survive a Tide"): the HUD shows a few
+ * each day, chosen from those declared, with each player's count of `when`
+ * in the run. It pays nothing (coin rewards are earn rules).
+ */
+export declare const missionSchema: z.ZodObject<{
+    text: z.ZodString;
+    when: z.ZodString;
+    n: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** What end-screen titles rank players by. */
+export declare const TITLE_STATS: readonly ["kills", "damage", "revives", "downs", "level", "pickups"];
+/** An end-screen title: who had the most (or the least) of a stat this run ("The Butcher": { most: "kills" }). */
+export declare const titleSchema: z.ZodObject<{
+    text: z.ZodString;
+    most: z.ZodOptional<z.ZodEnum<{
+        damage: "damage";
+        kills: "kills";
+        revives: "revives";
+        downs: "downs";
+        level: "level";
+        pickups: "pickups";
+    }>>;
+    least: z.ZodOptional<z.ZodEnum<{
+        damage: "damage";
+        kills: "kills";
+        revives: "revives";
+        downs: "downs";
+        level: "level";
+        pickups: "pickups";
+    }>>;
+}, z.core.$strict>;
+export type SkuGrant = z.output<typeof skuGrantSchema>;
+export type EconomyInput = z.input<typeof economySchema>;
+export type EconomyDef = z.output<typeof economySchema>;
+export type MetaUpgradeInput = z.input<typeof metaUpgradeSchema>;
+export type MetaUpgradeDef = z.output<typeof metaUpgradeSchema>;
+export type MetaStat = (typeof META_STATS)[number];
+export type KeeperInput = z.input<typeof keeperSchema>;
+export type KeeperDef = z.output<typeof keeperSchema>;
+export type AchievementInput = z.input<typeof achievementSchema>;
+export type AchievementDef = z.output<typeof achievementSchema>;
+export type MissionInput = z.input<typeof missionSchema>;
+export type MissionDef = z.output<typeof missionSchema>;
+export type TitleInput = z.input<typeof titleSchema>;
+export type TitleDef = z.output<typeof titleSchema>;
+export type TitleStat = (typeof TITLE_STATS)[number];
+export type CurveInput = z.input<typeof curveSchema>;
+export type Curve = z.output<typeof curveSchema>;
+export type DirectorInput = z.input<typeof directorSchema>;
+export type DirectorDef = z.output<typeof directorSchema>;
+export type LookInput = z.input<typeof lookSchema>;
+export type LookDef = z.output<typeof lookSchema>;
+export type FeelDef = z.output<typeof feelSchema>;
+export type LookPreset = (typeof LOOK_PRESETS)[number];
+export type ParticlePreset = (typeof PARTICLE_PRESETS)[number];
+export type DecalPreset = (typeof DECAL_PRESETS)[number];
+export type SoundCue = (typeof SOUND_CUES)[number];
+export type GameInput = z.input<typeof gameSchema>;
+export type GameDef = z.output<typeof gameSchema>;
+export type PrefabInput = z.input<typeof prefabSchema>;
+export type PrefabDef = z.output<typeof prefabSchema>;
+export type EarnRuleInput = z.input<typeof earnRuleSchema>;
+export type EarnRuleDef = z.output<typeof earnRuleSchema>;
+export type EarnStakeInput = z.input<typeof earnStakeSchema>;
+export type EarnStakeDef = z.output<typeof earnStakeSchema>;
+export type EarnPotInput = z.input<typeof earnPotSchema>;
+export type EarnPotDef = z.output<typeof earnPotSchema>;
+export type SkuInput = z.input<typeof skuSchema>;
+export type WeaponInput = z.input<typeof weaponSchema>;
+export type WeaponDef = z.output<typeof weaponSchema>;
+export type UpgradeInput = z.input<typeof upgradeSchema>;
+export type UpgradeDef = z.output<typeof upgradeSchema>;
+export type SkuDef = z.output<typeof skuSchema>;
+export type AssetId = string;
+export type Template = (typeof TEMPLATES)[number];
+export type Style = (typeof STYLES)[number];
+/** Thrown for any invalid declaration; `issues` are agent-readable lines. */
+export declare class GameDefinitionError extends Error {
+    readonly issues: readonly string[];
+    constructor(where: string, issues: readonly string[]);
+}
+export declare function parseOrThrow<S extends z.ZodType>(schema: S, value: unknown, where: string): z.output<S>;
+export type PlatformLevelInput = z.input<typeof platformLevelSchema>;
+export type PlatformLevelDef = z.output<typeof platformLevelSchema>;
+export type MotorDef = z.output<typeof motorSchema>;
+export type KartTrackInput = z.input<typeof kartTrackSchema>;
+export type KartTrackDefSchema = z.output<typeof kartTrackSchema>;