@idosgames/game-kit 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,2032 @@
+import { W as World, C as CastDef, A as ArtLook, E as Entity, a as ActorAct, F as FxEvent, b as ActorPose, c as ComponentType } from './view-CS-ixOId.js';
+export { D as DEFAULT_CAST, d as DEFAULT_LOOK, e as DEFAULT_PALETTE, f as EventHandler, g as FX_TOPIC, I as INPUT_TOPIC, h as InputEvent, R as Rng, S as System, i as Transform, T as TransformData, j as VIEW_RESIZED_TOPIC, k as Visual, V as VisualData, l as WorldOptions, m as WorldVar, n as createFixedStepper, o as createRng, p as defineComponent, q as mergePalette, r as resolveColor } from './view-CS-ixOId.js';
+
+/** Every entry has a stable id and a version (bumped on an incompatible change of the entry). */
+interface RegistryEntry {
+    readonly id: string;
+    readonly version: number;
+}
+/** A typed kind token. */
+interface RegistryKind<T extends RegistryEntry> {
+    readonly name: string;
+    /** Phantom: carries the entry type, never set at runtime. */
+    readonly __entry?: T;
+}
+/** A kind token for entries of type T. Kind names are lower-kebab ("asset-pack"). */
+declare function defineKind<T extends RegistryEntry>(name: string): RegistryKind<T>;
+/** Entry ids: lower-kebab, optionally namespaced by dots ("runner", "acme.lava-runner"). */
+declare const ENTRY_ID_RE: RegExp;
+interface DefineOptions {
+    /**
+     * Replace an entry with the same id. Off by default: two packages that both define "runner" is a
+     * bug, and silently keeping the last one would hide it. A project overrides deliberately.
+     */
+    readonly override?: boolean;
+}
+interface Registry {
+    define<T extends RegistryEntry>(kind: RegistryKind<T>, entry: T, options?: DefineOptions): T;
+    get<T extends RegistryEntry>(kind: RegistryKind<T>, id: string): T | undefined;
+    /** Like get, but throws a readable error when the entry is missing. */
+    require<T extends RegistryEntry>(kind: RegistryKind<T>, id: string): T;
+    has<T extends RegistryEntry>(kind: RegistryKind<T>, id: string): boolean;
+    /** Every entry of a kind, in id order (stable, independent of registration order). */
+    list<T extends RegistryEntry>(kind: RegistryKind<T>): T[];
+    /** A child registry: sees every entry of this one, defines its own on top (a project over the platform). */
+    extend(): Registry;
+}
+declare function createRegistry(parent?: Registry): Registry;
+
+type ExprValue = number | boolean | string;
+/** What a formula reads: nested plain objects, numbers, strings and booleans. */
+interface ExprScope {
+    readonly [name: string]: unknown;
+}
+/** A parsed formula. */
+interface Expr {
+    readonly source: string;
+    /** Evaluate against a scope. */
+    eval(scope?: ExprScope): ExprValue;
+    /** Evaluate and coerce to a finite number (NaN / Infinity → 0). */
+    num(scope?: ExprScope): number;
+    /** Evaluate and coerce to a boolean. */
+    bool(scope?: ExprScope): boolean;
+    /** Every variable path the formula reads, e.g. ["event.damage", "vars.level"]. */
+    readonly reads: readonly string[];
+}
+declare class ExprError extends Error {
+    readonly source: string;
+    readonly at: number;
+    constructor(message: string, source: string, at: number);
+}
+/** The only functions a formula may call. Each takes numbers. */
+declare const FUNCTIONS: Readonly<Record<string, (...args: number[]) => number>>;
+/** Parse a formula. Throws ExprError on a syntax error. Parsed formulas are shared by source text. */
+declare function compileExpr(source: string): Expr;
+/** A syntax check without throwing: null when the formula parses, else the error text. */
+declare function checkExpr(source: string): string | null;
+/** A number field of the spec: a plain number, or a formula string evaluated against the scope. */
+type NumberOrFormula = number | string;
+/** Evaluate a number-or-formula field. */
+declare function evalNumber(value: NumberOrFormula | undefined, scope?: ExprScope, fallback?: number): number;
+
+/**
+ * A finding of spec validation. `error` makes the spec unusable (the game would not run or would
+ * run wrong); `warning` was repaired on the way (a clamped number, a dropped unknown parameter).
+ */
+interface Issue {
+    readonly level: "error" | "warning";
+    /** Where, as a dotted path into the spec: "modes.0.params.speed". */
+    readonly path: string;
+    /** A stable code for programs (the config agent, the dashboard): "MODE_PRESET_UNKNOWN". */
+    readonly code: string;
+    /** Plain English for logs and the agent. */
+    readonly message: string;
+}
+declare const hasErrors: (issues: readonly Issue[]) => boolean;
+
+/** One effect of a rule: its type names an EFFECTS entry, the rest are its parameters. */
+interface EffectSpec {
+    readonly type: string;
+    readonly [param: string]: unknown;
+}
+interface RuleDef {
+    readonly id: string;
+    /** Event topic that triggers the rule ("enemy-killed", "level-cleared", "tick"). */
+    readonly on: string;
+    /** Formula; the rule runs only when it is true. Reads `event.*`, `vars.*`, `tick`, `time`. */
+    readonly when?: string;
+    readonly do: readonly EffectSpec[];
+    /** Run at most once per world. */
+    readonly once?: boolean;
+    /** Run on every N-th matching event only (every 3rd hit). */
+    readonly every?: number;
+    /** Minimum seconds of world time between two runs. */
+    readonly cooldown?: number;
+}
+/** What an effect receives. */
+interface EffectContext {
+    readonly world: World;
+    readonly rule: RuleDef;
+    readonly event: Readonly<Record<string, unknown>>;
+    /** The scope formulas of this run evaluate against. */
+    readonly scope: ExprScope;
+    /** Evaluate a number-or-formula parameter of the effect. */
+    num(value: unknown, fallback?: number): number;
+}
+interface EffectDef extends RegistryEntry {
+    /** Parameters that are formulas (checked when the spec is validated). */
+    readonly formulas?: readonly string[];
+    /** Required parameters. */
+    readonly required?: readonly string[];
+    run(ctx: EffectContext, params: EffectSpec): void;
+}
+declare const EFFECTS: RegistryKind<EffectDef>;
+/** The generic effects every game has. Blocks add their own. */
+declare const CORE_EFFECTS: readonly EffectDef[];
+/** Registers CORE_EFFECTS (once per registry). */
+declare function registerCoreEffects(registry: Registry): void;
+/** Check rules without running them (used by spec validation). */
+declare function checkRules(rules: readonly RuleDef[], registry: Registry, path: string, issues: Issue[]): void;
+/**
+ * Attach rules to a world. Rules run when their event is delivered (after the step's systems).
+ * An effect that throws is skipped and reported through `onError`: one bad rule must not stop the game.
+ * Returns a detach function.
+ */
+declare function attachRules(world: World, rules: readonly RuleDef[], registry: Registry, options?: {
+    onError?: (rule: RuleDef, error: unknown) => void;
+}): () => void;
+
+type ParamValue = number | string | boolean;
+type ParamDef = {
+    readonly type: "number";
+    readonly default: number;
+    readonly min?: number;
+    readonly max?: number;
+    /** Round to an integer. */
+    readonly integer?: boolean;
+    /** Text key describing the parameter (for the config agent and the editor). */
+    readonly label?: string;
+} | {
+    readonly type: "enum";
+    readonly default: string;
+    readonly values: readonly string[];
+    readonly label?: string;
+} | {
+    readonly type: "boolean";
+    readonly default: boolean;
+    readonly label?: string;
+} | {
+    readonly type: "string";
+    readonly default: string;
+    readonly maxLength?: number;
+    readonly label?: string;
+};
+type ParamDefs = Readonly<Record<string, ParamDef>>;
+/**
+ * Defaults merged with the given values. Unknown names are dropped with a warning (a typo must not
+ * silently do nothing AND must not break the game); bad types fall back to the default.
+ */
+declare function resolveParams(defs: ParamDefs, given: Readonly<Record<string, unknown>> | undefined, path: string, issues: Issue[]): Record<string, ParamValue>;
+
+declare const SPEC_VERSION = 1;
+interface ModeSpec {
+    /** Snake-case id, unique in the spec ("main", "city"). */
+    readonly id: string;
+    /** PRESETS entry id. */
+    readonly preset: string;
+    /** core: what the player plays; meta: what they come back for; embedded: called from another mode. */
+    readonly role?: "core" | "meta" | "embedded";
+    readonly params?: Readonly<Record<string, unknown>>;
+    /** Overrides of block parameters: `{ "waves": { "count": 12 } }`. */
+    readonly blockParams?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Rules of this mode, after the preset's own. */
+    readonly rules?: readonly RuleDef[];
+    /**
+     * Which rows of the genre's own lists this game leaves out (tuning knobs, 08.11.2026): `{ "powers":
+     * { "without": ["flight"] } }`. The kinds are the genre's (runner: powers, obstacles; survivors:
+     * foes). A block never ends up with nothing: leaving out every row of a kind keeps them all.
+     */
+    readonly content?: Readonly<Record<string, Readonly<{
+        without?: readonly string[];
+    }>>>;
+}
+interface ResourceSpec {
+    /** Snake-case id, readable in formulas as `res.<id>`. */
+    readonly id: string;
+    /**
+     * currency / item: kept on the server (an engine currency or item: `ref` is its id), need a source
+     * and a sink; score: a round's result (goes to a leaderboard); local: lives inside a round.
+     */
+    readonly kind: "currency" | "item" | "score" | "local";
+    readonly ref?: string;
+    /** Text key of the name. */
+    readonly name?: string;
+}
+interface FlowSpec {
+    readonly resource: string;
+    /** A mode id of the spec, or "system:<id>" (store, quests, reward-window, idle…). */
+    readonly by: string;
+    readonly kind: "source" | "sink";
+    /** How much, as a number or a formula ("10 + vars.level * 2"). */
+    readonly amount?: NumberOrFormula;
+}
+interface RewardsSpec {
+    /**
+     * The server's reward window (`Reward.Windows[window]` of the title config) the round's coins are
+     * claimed through. The server owns the real multipliers and caps; the two below are what the
+     * creation path writes into that window.
+     */
+    readonly window?: string;
+    /** "x3 for an ad". Ads exist only in the mobile app; elsewhere the button is not drawn. */
+    readonly adMultiplier?: number;
+    /** "x5 for VIP", no ad. */
+    readonly vipMultiplier?: number;
+}
+interface GameSpec {
+    readonly v: number;
+    readonly engine: Engine;
+    readonly seed?: string;
+    readonly modes: readonly ModeSpec[];
+    readonly resources?: readonly ResourceSpec[];
+    readonly flows?: readonly FlowSpec[];
+    /** Game-wide rules (links between modes, quests of the run). */
+    readonly rules?: readonly RuleDef[];
+    readonly vars?: Readonly<Record<string, number | string | boolean>>;
+    /** Taxonomy ids. */
+    readonly setting?: string;
+    readonly style?: string;
+    /** Asset pack id. */
+    readonly assets?: string;
+    /** Role → colour: `{ "primary": "#ff8800" }`. */
+    readonly palette?: Readonly<Record<string, string>>;
+    /** Text key → language → text: `{ "title": { "en": "Lava Run", "ru": "Лавовый забег" } }`. */
+    readonly texts?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    /** Who the actors are, over the asset pack's cast, role by role: `{ "hero": { "preset": "viking", "races": ["dwarf"] } }`. */
+    readonly cast?: Readonly<Record<string, Partial<CastDef>>>;
+    readonly rewards?: RewardsSpec;
+    readonly multiplayer?: "none" | "async" | "coop" | "pvp";
+    /** Unknown fields are kept. */
+    readonly [extra: string]: unknown;
+}
+interface ResolvedMode {
+    readonly id: string;
+    readonly role: "core" | "meta" | "embedded";
+    readonly preset: PresetDef;
+    readonly params: Readonly<Record<string, ParamValue>>;
+    /** Block id → its resolved parameters. */
+    readonly blockParams: Readonly<Record<string, Readonly<Record<string, ParamValue>>>>;
+    /** Preset rules, then the mode's own. */
+    readonly rules: readonly RuleDef[];
+    /** Kind → the row ids this game leaves out (see ModeSpec.content); read through `contentOf`. */
+    readonly content: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * The rows of a genre list this mode plays with: `all` without the ones the spec leaves out. Never
+ * empty: a spec that leaves out every row keeps them all (a game must stay playable).
+ */
+declare function contentOf<T extends string>(mode: Pick<ResolvedMode, "content"> | undefined, kind: string, all: readonly T[]): readonly T[];
+interface ResolvedSpec {
+    readonly spec: GameSpec;
+    readonly engine: Engine;
+    readonly seed: string;
+    readonly modes: readonly ResolvedMode[];
+    readonly resources: readonly ResourceSpec[];
+    readonly flows: readonly FlowSpec[];
+    readonly rules: readonly RuleDef[];
+    readonly vars: Readonly<Record<string, number | string | boolean>>;
+    readonly rewards: Required<RewardsSpec>;
+    readonly multiplayer: "none" | "async" | "coop" | "pvp";
+    /** Every palette role: the defaults ← the asset pack's ← the spec's own. */
+    readonly palette: Readonly<Record<string, string>>;
+    /** Texts: the asset pack's defaults ← the spec's own, key by key and language by language. */
+    readonly texts: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    /** The art style and the cast: the asset pack's over the kit's defaults. */
+    readonly look: ArtLook;
+}
+declare const DEFAULT_REWARDS: Required<RewardsSpec>;
+/** Bring a spec to SPEC_VERSION. A spec without `v` is treated as version 1. */
+declare function migrateSpec(raw: Record<string, unknown>, issues: Issue[]): Record<string, unknown> | null;
+interface SpecResult {
+    /** No errors (warnings are allowed: they were repaired). */
+    readonly ok: boolean;
+    readonly issues: readonly Issue[];
+    /** The migrated spec, unknown fields kept. Present when the shape could be read. */
+    readonly spec?: GameSpec;
+    /** Everything resolved against the registry. Present only when ok. */
+    readonly resolved?: ResolvedSpec;
+}
+/** Validate a spec from any source (JSON from the title's config, an AI, a remix). Never throws. */
+declare function validateSpec(input: unknown, registry: Registry): SpecResult;
+
+/** Rendering family. The kit's logic is engine-free; a preset says which adapter draws it. */
+type Engine = "phaser" | "three" | "dom";
+declare const ENGINES: readonly Engine[];
+/** What a block's setup receives for one mode of a game. */
+interface BlockContext {
+    readonly world: World;
+    readonly spec: ResolvedSpec;
+    readonly mode: ResolvedMode;
+    /** This block's own parameters (block defaults ← preset values ← spec values). */
+    readonly params: Readonly<Record<string, ParamValue>>;
+    readonly registry: Registry;
+}
+interface BlockDef extends RegistryEntry {
+    /** Engines the block's logic is drawn by; omitted = any (pure logic). */
+    readonly engines?: readonly Engine[];
+    readonly params?: ParamDefs;
+    /** Blocks that must be in the same mode (a "waves" block needs "combat"). */
+    readonly requires?: readonly string[];
+    /** Add systems, entities and event handlers to the world. */
+    setup?(ctx: BlockContext): void;
+}
+/** A rewarded-ad spot a preset offers (shown only where ads exist: the mobile app). */
+interface RewardedPlacementDef {
+    /** Placement id, written into the title's Advertising section on creation. */
+    readonly id: string;
+    readonly kind: "reward-window" | "revive" | "chest" | "energy" | "timer" | "retry";
+    /** Views per player per day; omitted = the title's default. */
+    readonly dailyLimit?: number;
+}
+interface PresetDef extends RegistryEntry {
+    readonly engine: Engine;
+    /** Genre id (the constructor's genre list: "runner", "match3", "tower-defense", …). */
+    readonly genre: string;
+    /** Text key of the preset's name. */
+    readonly name?: string;
+    /** Block ids in setup order. */
+    readonly blocks: readonly string[];
+    /** The preset's own parameters (what the decision model's score questions and the config agent set). */
+    readonly params?: ParamDefs;
+    /**
+     * Values the preset gives its blocks' parameters: `{ "waves": { "count": 10 } }`. For a number or
+     * true/false parameter a string is a formula over the preset's own `params.*`
+     * (`"count": "6 + params.difficulty * 8"`). The spec's own blockParams win over these.
+     */
+    readonly blockParams?: Readonly<Record<string, Readonly<Record<string, ParamValue>>>>;
+    /** Default rules of the genre (a spec's mode rules come after them). */
+    readonly rules?: readonly RuleDef[];
+    /** Resource roles the genre produces / consumes ("soft", "score", "stars"), for links. */
+    readonly produces?: readonly string[];
+    readonly consumes?: readonly string[];
+    readonly placements?: readonly RewardedPlacementDef[];
+}
+declare const BLOCKS: RegistryKind<BlockDef>;
+declare const PRESETS: RegistryKind<PresetDef>;
+
+/**
+ * Who may produce or consume besides the spec's own modes: the platform's systems ("system:store",
+ * "system:quests"…) and the kit's shared blocks. An unknown system is a warning, not an error: a
+ * project may add its own.
+ */
+declare const KNOWN_SYSTEMS: readonly string[];
+declare function checkEconomy(modes: readonly ModeSpec[], resources: readonly ResourceSpec[], flows: readonly FlowSpec[], issues: Issue[]): void;
+
+/** A registry with the kit's generic effects in it: the base every platform or project registry extends. */
+declare function createKitRegistry(): Registry;
+interface RunningMode {
+    readonly world: World;
+    readonly mode: ResolvedMode;
+    /** Detach rules and drop the world's handlers. */
+    stop(): void;
+}
+interface StartModeOptions {
+    /**
+     * Extra seed material (a run number, a daily seed, the opponent's id in async PvP). The same spec,
+     * mode and salt give the same run.
+     */
+    readonly salt?: string;
+    /** A rule effect threw: the rule is skipped, the game goes on. */
+    readonly onRuleError?: (rule: RuleDef, error: unknown) => void;
+}
+declare function startMode(resolved: ResolvedSpec, modeId: string, registry: Registry, options?: StartModeOptions): RunningMode;
+
+type Hex = string;
+
+interface ArtContext {
+    readonly style: string;
+    /** A palette role or #hex → #rrggbb. */
+    readonly c: (role: string) => Hex;
+    /** The visual's colour (resolved), or the entry's default role. */
+    readonly main: Hex;
+    /** The outline colour of the style. */
+    readonly ink: Hex;
+    /** The box asked for, logical px ("exact" art draws at it). */
+    readonly w: number;
+    readonly h: number;
+}
+interface ArtDef {
+    /** The viewBox (ignored for exact art). */
+    readonly w: number;
+    readonly h: number;
+    /** Drawn at the asked box itself, not stretched. */
+    readonly exact?: boolean;
+    /** A band that repeats only sideways (a backdrop layer): its texture gets an empty row under it, so
+     *  the GPU's wrap never pulls the bottom edge over the top one (a thin line across the sky). */
+    readonly band?: boolean;
+    /** The colour role used when the visual names none. */
+    readonly main?: string;
+    draw(c: ArtContext): string;
+}
+/** Every picture of the kit, by id. */
+declare const ART: Readonly<Record<string, ArtDef>>;
+declare const hasArt: (id: string) => boolean;
+/** The art's own aspect (w / h) — exact art has the box's. */
+declare function artAspect(id: string, box: {
+    w: number;
+    h: number;
+}): number;
+/**
+ * A whole SVG document of a picture, `px` pixels big (the adapter's raster size). Null for an unknown id.
+ * `box` is the logical box the visual asked for (exact art draws at it).
+ */
+declare function artDocument(id: string, options: {
+    style: string;
+    palette: Readonly<Record<string, string>>;
+    color?: string;
+    box: {
+        w: number;
+        h: number;
+    };
+    px: {
+        w: number;
+        h: number;
+    };
+    /** Empty px added under the picture (bands). */
+    padBottom?: number;
+}): string | null;
+
+interface ViewSize {
+    readonly w: number;
+    readonly h: number;
+}
+/** The logical view the adapter keeps in vars (720 × 1280 before the first resize). */
+declare const viewOf: (world: World) => ViewSize;
+/** What the player holds now: arrows / WASD and the pointer (pressed + where). */
+interface Controls {
+    readonly keys: ReadonlySet<string>;
+    readonly pointer: {
+        readonly down: boolean;
+        readonly x: number;
+        readonly y: number;
+    };
+    /** -1..1 per axis from the held keys. */
+    axis(): {
+        x: number;
+        y: number;
+    };
+}
+/** Tracks held keys and the pointer from the input topic (the adapter sends press / move / release / key / key-up). */
+declare function trackControls(world: World): Controls;
+/** A square board centred in the view: cell size and the top-left corner. */
+interface Board {
+    readonly cols: number;
+    readonly rows: number;
+    readonly cell: number;
+    readonly left: number;
+    readonly top: number;
+}
+declare function boardOf(view: ViewSize, cols: number, rows: number, area: {
+    top: number;
+    bottom: number;
+    widthShare?: number;
+}): Board;
+declare const cellCenter: (b: Board, col: number, row: number) => {
+    x: number;
+    y: number;
+};
+/** The cell under a point, or null outside the board. */
+declare function cellAt(b: Board, x: number, y: number): {
+    col: number;
+    row: number;
+} | null;
+/** The board's piece colours (palette roles piece1..piece6). */
+declare const PIECE_COLORS: readonly ["piece1", "piece2", "piece3", "piece4", "piece5", "piece6"];
+/** Asks the adapter for an effect (sparks, a rising number, a shake). Logic never depends on it. */
+declare const fx: (world: World, ev: FxEvent) => void;
+/**
+ * Puts the backdrop behind the play: "side" — the sky, the sun, the far and near layers standing on
+ * `horizon` (a y in the view), "top" — the floor seen from above with scattered decor, "board" — a
+ * side backdrop dimmed behind a board. Called again on a resize: it replaces what it put.
+ */
+declare function placeBackdrop(world: World, kind: "side" | "top" | "board", horizon?: number, options?: {
+    pan?: boolean;
+}): void;
+/** The world scrolled by `dx` logical px (positive: the ground moved left): the layers follow at their speeds. */
+declare function scrollBackdrop(world: World, dx: number): void;
+/** Sets an actor's pose (and keeps the rest of its Visual). */
+declare function setPose(world: World, e: Entity, pose: ActorPose): void;
+/** Plays a one-shot on an actor (attack, hit, jump...). */
+declare function act(world: World, e: Entity, a: ActorAct): void;
+
+/** A stat bought between rounds. */
+interface MetaStatDef {
+    /** The Character stat id (`StatID`). */
+    readonly id: string;
+    /** The world var the block reads (`meta:…`). */
+    readonly var: string;
+    readonly art: string;
+    readonly color: string;
+    /** Value per level (percent stats in percent, seconds stats in seconds). */
+    readonly perLevel: number;
+    /** "%" — a percent (the var gets value / 100); "s" — seconds; "" — a plain number. */
+    readonly unit: "%" | "s" | "";
+    readonly maxLevel: number;
+    /** Price of level 1 in the soft currency; each level costs `growth` more (geometric). */
+    readonly price: number;
+    readonly growth: number;
+}
+/** A hero of the game: who plays (a cast role of the pack) and the gems to open it (0 — everyone's). */
+interface MetaHeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly gems: number;
+}
+interface MetaGameDef {
+    /** The preset id it belongs to ("survivors", "runner"). */
+    readonly game: string;
+    /** The Character id of the stats; the progress key and the heroes' Character ids are made from it. */
+    readonly character: string;
+    readonly stats: readonly MetaStatDef[];
+    readonly heroes: readonly MetaHeroDef[];
+    /** How many levels (chapters) there are. */
+    readonly levels: number;
+    /** The soft coins the first finish of a level pays. */
+    firstClearGold(level: number): number;
+    /** Stars a level can give (0 — the game has none). */
+    readonly stars: number;
+    /** Stars (of all levels together) needed to play a level: a world's gate. None — only the level before. */
+    starsToEnter?(level: number): number;
+}
+/** The Character id of a hero that has to be opened (the first hero is everyone's and has none). */
+declare const heroCharacterOf: (def: MetaGameDef, heroID: string) => string;
+
+/**
+ * What stands on the road, and the one answer to each:
+ *   wall    — tall: only another lane gets you past;
+ *   barrier — low: jump it or take another lane;
+ *   pit     — a hole in the lane: only a jump gets you over;
+ *   mover   — a foe running at you; it switches lane once, blinking first;
+ *   train   — a long wagon over several rows; its ramp takes you up onto the roof (coins up there),
+ *             a wagon without a ramp is a long wall;
+ *   rock    — falls from above: its shadow runs on the lane first, then it lands and stays like a wall.
+ */
+type ObstacleKind = "wall" | "barrier" | "pit" | "mover" | "train" | "rock";
+declare const OBSTACLE_KINDS: readonly ObstacleKind[];
+type PowerId = "magnet" | "shield" | "double" | "dash" | "flight";
+declare const POWER_IDS: readonly PowerId[];
+interface PowerDef {
+    readonly art: string;
+    readonly color: string;
+    /** Seconds it lasts before the meta's upgrades. */
+    readonly seconds: number;
+    /** The meta var that adds seconds to it. */
+    readonly var: string;
+    /** How often it turns up among the power-ups of the road. */
+    readonly weight: number;
+}
+declare const POWERS: Readonly<Record<PowerId, PowerDef>>;
+/** Levels of the game: each opens when the one before is finished. */
+declare const RUNNER_LEVELS = 20;
+interface RunnerLevel {
+    readonly level: number;
+    /** The road's length to the finish, px. */
+    readonly length: number;
+    /** Starting speed and the speed it reaches at the finish, px / s. */
+    readonly speed: number;
+    readonly topSpeed: number;
+    /** How busy the rows are (0..1). */
+    readonly density: number;
+    /** The kinds on this level. */
+    readonly kinds: readonly ObstacleKind[];
+    /** The newest kind (the level teaches it first). */
+    readonly fresh: ObstacleKind | null;
+    /** Share of the coins of the level that gives the second star. */
+    readonly coinStar: number;
+    /** Soft coins its first finish pays. */
+    readonly firstClearGold: number;
+}
+/**
+ * A level by its number (1-based, clamped). `difficulty` (0..1, the preset's knob) moves the speed and the
+ * density of all levels together; the level number moves them along the map.
+ */
+declare function levelOf$5(level: number, difficulty?: number): RunnerLevel;
+/** The meters a distance shows (px of the road / 30). */
+declare const metersOf: (px: number) => number;
+/** A hero's own bonus in a run. */
+type RunnerPerk = "none" | "heart" | "power";
+interface RunnerHeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly gems: number;
+    /** heart — one more heart; power — every power-up lasts a quarter longer. */
+    readonly perk: RunnerPerk;
+}
+declare const RUNNER_HEROES: readonly RunnerHeroDef[];
+/** The Character id of the runner's stats (the seed of kit-game; the heroes are `kit-runner-hero2/3`). */
+declare const RUNNER_CHARACTER = "kit-runner";
+/**
+ * Stats bought between runs with the soft currency (the server's Character system). ⚠ The seed mirrors these
+ * numbers (`KitGameStarterFixtures` of the engine): the constructor's page draws by them without a server.
+ */
+declare const RUNNER_META_STATS: readonly MetaStatDef[];
+declare const RUNNER_META: MetaGameDef;
+
+type ItemKind = ObstacleKind | "ramp" | "coin" | "power" | "finish";
+/** A thing on the road: its lane, what touching it does, how far it reaches along the road. */
+declare const RoadItem: ComponentType<{
+    lane: number;
+    kind: ItemKind;
+    /** Width of its body along the road (a train, a pit: long). */
+    size: number;
+    /** Height above the road a coin floats at (a power-up too). */
+    alt: number;
+    power?: PowerId;
+    /** A mover: the lane it is heading to, the seconds of its warning. */
+    to?: number;
+    warn?: number;
+    /** A rock: landed. */
+    landed?: boolean;
+    /** A coin pulled by the magnet. */
+    pulled?: boolean;
+}>;
+/** The hero: its lane, its height over the road and its vertical speed. */
+declare const Runner: ComponentType<{
+    lane: number;
+    size: number;
+    alt: number;
+    vy: number;
+}>;
+declare const laneRunnerBlock: BlockDef;
+
+/** Weapons the hero carries (up to `MAX_WEAPONS`), each fires by itself. */
+type WeaponId = "blaster" | "blades" | "aura" | "boomerang" | "lightning" | "drone";
+/** Passives (up to `MAX_PASSIVES`): every level adds to one number of the hero. */
+type PassiveId = "might" | "haste" | "area" | "swift" | "vigor" | "armor" | "magnet" | "luck" | "growth";
+declare const MAX_LEVEL = 5;
+declare const MAX_WEAPONS = 6;
+declare const MAX_PASSIVES = 6;
+/** Per level (index 0 = level 1). Level 5 is the weapon's strong form (a card says so). */
+interface WeaponDef {
+    readonly id: WeaponId;
+    /** The kit's art drawn on its card and on the HUD. */
+    readonly art: string;
+    readonly color: string;
+    readonly damage: readonly number[];
+    /** Seconds between uses (blades and aura: the time a foe waits before the same blade or aura hurts it again). */
+    readonly cooldown: readonly number[];
+    /** Bullets, blades, boomerangs, chain jumps or drones. */
+    readonly count: readonly number[];
+    /** Foes one bullet goes through (blaster). */
+    readonly pierce?: readonly number[];
+    /** Reach, in units of the view's short side (blades' circle, aura's radius, boomerang's throw, chain's jump). */
+    readonly reach?: readonly number[];
+}
+declare const WEAPONS: Readonly<Record<WeaponId, WeaponDef>>;
+declare const WEAPON_IDS: WeaponId[];
+interface PassiveDef {
+    readonly id: PassiveId;
+    readonly art: string;
+    readonly color: string;
+    /** What one level adds (a share for percents, a number for hit points and armour). */
+    readonly step: number;
+}
+declare const PASSIVES: Readonly<Record<PassiveId, PassiveDef>>;
+declare const PASSIVE_IDS: PassiveId[];
+/** One choice of a level-up (or a chest): a new weapon / passive, or its next level; `heal` and `gold` when all is full. */
+interface UpgradeOption {
+    readonly kind: "weapon" | "passive" | "heal" | "gold";
+    readonly id: string;
+    /** The level it brings (1 = new). */
+    readonly level: number;
+}
+type FoeKind = "swarm" | "grunt" | "archer" | "brute" | "charger" | "bomber" | "miniboss" | "boss";
+interface FoeDef {
+    readonly kind: FoeKind;
+    /** The asset pack's cast role that plays it. */
+    readonly cast: string;
+    /** Hit points in units of the chapter's base foe. */
+    readonly hp: number;
+    /** Speed, px a second at 720. */
+    readonly speed: number;
+    /** Body size, share of the view's short side. */
+    readonly size: number;
+    /** Damage of a touch (archer: of its arrow). */
+    readonly damage: number;
+    /** Crystals of experience it drops. */
+    readonly xp: number;
+    /** Minutes (with the chapter's head start) before it joins the stream. */
+    readonly from: number;
+    /** Weight in the stream once it has joined. */
+    readonly weight: number;
+}
+declare const FOES: Readonly<Record<FoeKind, FoeDef>>;
+declare const CHAPTERS = 10;
+/** A chapter's numbers: later chapters are longer, their foes tougher, the stream starts further in. */
+declare function chapterOf(chapter: number, baseSeconds: number): {
+    chapter: number;
+    /** Seconds to the final boss. */
+    duration: number;
+    /** Foe hit points ×. */
+    hp: number;
+    /** Foe damage ×. */
+    damage: number;
+    /** Minutes the stream is ahead (late kinds come sooner). */
+    headStart: number;
+    /** Gold of the first clear. */
+    firstClearGold: number;
+};
+/** Heroes: who plays (a cast role of the pack), the weapon they start with, their own bonus. */
+interface HeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly weapon: WeaponId;
+    /** One passive at level 1 from the start (null — none). */
+    readonly passive: PassiveId | null;
+    /** Price to open it in gems (0 — open from the start). */
+    readonly gems: number;
+}
+declare const HEROES: readonly HeroDef[];
+
+declare const META_STATS: readonly MetaStatDef[];
+/** The Character id of the survivors' meta stats (one for every hero: the upgrades are the player's). */
+declare const META_CHARACTER = "kit-survivors";
+/** Gems a revive / a reroll of the cards cost on the test page; a title charges the price of its spends (`Currency.Spends`). */
+declare const REVIVE_GEMS = 30;
+declare const REROLL_GEMS = 10;
+/** The survivors' meta as the host shows it (chapters, upgrades, heroes). */
+declare const SURVIVORS_META: MetaGameDef;
+
+declare const ROUND_STARTED = "round-started";
+declare const ROUND_OVER = "round-over";
+declare const ROUND_ENDED = "round-ended";
+declare const START_ROUND = "start-round";
+/** The UI goes back to the game's home after a result (the start button again, the meta around it). */
+declare const SHOW_START = "show-start";
+/** A run's hero fell and may come back once: the host offers a revive (gems or an ad) and answers below. */
+declare const REVIVE_OFFER = "revive-offer";
+/** The host paid for the revive: the run goes on. */
+declare const REVIVE = "revive";
+/** The player said no to the revive: the run ends. */
+declare const GIVE_UP = "give-up";
+type RoundState = "ready" | "playing" | "ended";
+declare const roundBlock: BlockDef;
+
+declare const LEVEL_CLEARED = "level-cleared";
+type ThingKind = "walker" | "spiky" | "hopper" | "flyer" | "gunner" | "boss" | "bullet" | "wave" | "coin" | "star" | "heart" | "key" | "chest" | "spring" | "mover" | "checkpoint" | "flag";
+/** A body in the level, in tiles: x is its middle, y its bottom (feet). */
+declare const Body: ComponentType<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+/** Something of the level that is not a tile: an enemy, a pickup, a spring, a moving platform… */
+declare const Thing: ComponentType<{
+    kind: ThingKind;
+    vx: number;
+    vy: number;
+    dir: number;
+    t: number;
+    baseX: number;
+    baseY: number;
+    hp: number;
+    /** A star's index (0..2), a boss's attack. */
+    tag: string;
+    /** Seconds it cannot be hurt (a boss after a stomp). */
+    safe: number;
+}>;
+/** The hero. */
+declare const Jumper: ComponentType<{
+    vx: number;
+    vy: number;
+    grounded: boolean;
+    facing: number;
+    jumps: number;
+    coyote: number;
+    buffer: number;
+    dash: number;
+    dashCd: number;
+    /** -1 / 1 — touching a wall on that side in the air. */
+    wall: number;
+    /** Seconds left of a sword swing, and before the next one. */
+    swing: number;
+    swingCd: number;
+}>;
+declare const platformerBlock: BlockDef;
+
+/**
+ * A room of a level: rows of tiles, row 0 at the top, ROOM_ROWS rows.
+ *   #  ground (solid)          =  a platform (stand on it, jump through it from below)
+ *   _  a crumbling platform     ^  spikes
+ *   M  a moving platform        T  a spring
+ *   o  a coin                   H  a heart          *  a big star's spot (the level keeps three)
+ *   K  a key                    B  a chest (opens with the key)
+ *   W  walker (stomp it)        S  spiky walker (never stomp: go round or dash)
+ *   J  hopper (jumps in place)  F  flyer (flies a wave)     G  gunner (shoots along the ground)
+ *   P  the start                C  a checkpoint             E  the exit flag
+ */
+declare const ROOM_ROWS = 10;
+/** What a room shows the player (a level opens them in order: the first levels teach one thing each). */
+type RoomFeature = "walker" | "gaps" | "spikes" | "stairs" | "pits" | "spring" | "hopper" | "crumble" | "spiky" | "moving" | "flyer" | "key" | "gunner";
+interface RoomDef {
+    readonly id: string;
+    readonly needs: readonly RoomFeature[];
+    readonly rows: readonly string[];
+}
+declare const ROOMS: readonly RoomDef[];
+/** Worlds and their levels: the last level of a world is its boss. */
+declare const WORLDS = 4;
+declare const LEVELS_PER_WORLD = 5;
+declare const PLATFORMER_LEVELS: number;
+/** Stars needed to enter each world (all stars of the game: 3 a level, 60 in all). */
+declare const WORLD_STARS: readonly number[];
+interface PlatformerLevel {
+    readonly level: number;
+    readonly world: number;
+    /** 1..LEVELS_PER_WORLD inside its world. */
+    readonly index: number;
+    readonly boss: boolean;
+    readonly features: readonly RoomFeature[];
+    /** The newest feature (its room goes first). */
+    readonly fresh: RoomFeature | null;
+    /** Rooms between the start and the end (the checkpoint in the middle). */
+    readonly rooms: number;
+    /** The enemies' speed ×. */
+    readonly pace: number;
+    /** The boss's hit points (boss levels). */
+    readonly bossHp: number;
+    readonly firstClearGold: number;
+}
+declare function levelOf$4(level: number, difficulty?: number): PlatformerLevel;
+/** Stars needed to play a level (its world's gate). */
+declare const starsToEnter: (level: number) => number;
+/** Abilities opened by all the stars the player has (they also open the hidden stars of earlier levels). */
+type AbilityId = "double" | "dash" | "wall";
+declare const ABILITIES: readonly {
+    readonly id: AbilityId;
+    readonly stars: number;
+}[];
+declare const abilitiesFor: (stars: number) => AbilityId[];
+type PlatformerPerk = "none" | "heart" | "jump";
+interface PlatformerHeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly gems: number;
+    /** heart — one more heart; jump — jumps 15% higher. */
+    readonly perk: PlatformerPerk;
+}
+declare const PLATFORMER_HEROES: readonly PlatformerHeroDef[];
+declare const PLATFORMER_CHARACTER = "kit-platformer";
+/**
+ * Stats bought between levels with the soft currency (the server's Character system). ⚠ The seed mirrors these
+ * numbers (`KitGameStarterFixtures` of the engine).
+ */
+declare const PLATFORMER_META_STATS: readonly MetaStatDef[];
+declare const PLATFORMER_META: MetaGameDef;
+
+declare const Survivor: ComponentType<{
+    size: number;
+}>;
+declare const Foe: ComponentType<{
+    kind: FoeKind;
+    hp: number;
+    maxHp: number;
+    speed: number;
+    size: number;
+    damage: number;
+    xp: number;
+    elite: boolean;
+    /** A timer of its own move (an archer's shot, a charger's dash, a boss's attack). */
+    t: number;
+    phase: "walk" | "wind" | "dash";
+    vx: number;
+    vy: number;
+    /** World time each weapon last hurt it (blades, aura: one hurt per their cooldown). */
+    hurtAt: Partial<Record<string, number>>;
+    /** Next attack of a boss. */
+    next: number;
+}>;
+/** The hero's bullet (blaster, drones): flies, goes through `pierce` foes. */
+declare const Shot: ComponentType<{
+    vx: number;
+    vy: number;
+    life: number;
+    damage: number;
+    pierce: number;
+    hit: number[];
+    by: string;
+}>;
+/** A foe's bullet (archers, the boss's ring). */
+declare const Bullet: ComponentType<{
+    vx: number;
+    vy: number;
+    life: number;
+    damage: number;
+}>;
+declare const Drop: ComponentType<{
+    kind: "xp" | "coin" | "food" | "magnet" | "bomb" | "chest";
+    value: number;
+    pulled: boolean;
+}>;
+declare const LEVEL_UP = "level-up";
+declare const UPGRADE_PICKED = "upgrade-picked";
+declare const UPGRADE_PICK = "upgrade-pick";
+declare const UPGRADE_REROLL = "upgrade-reroll";
+
+declare const BOSS_SPAWNED = "boss-spawned";
+declare const BOSS_DEFEATED = "boss-defeated";
+/** The hero's build: weapon / passive → level. */
+interface SurvivorsBuild {
+    readonly weapons: Readonly<Partial<Record<WeaponId, number>>>;
+    readonly passives: Readonly<Partial<Record<PassiveId, number>>>;
+}
+/** A build written into a var ("w:blaster:2,p:might:1") — the host reads it after a remount. */
+declare const buildToVar: (b: SurvivorsBuild) => string;
+declare const buildFromVar: (s: unknown) => SurvivorsBuild;
+declare const offerToVar: (o: readonly UpgradeOption[]) => string;
+declare const offerFromVar: (s: unknown) => UpgradeOption[];
+declare const survivorsBlock: BlockDef;
+
+/** physical — cut by armour; magic — cut by resistance; true — cut by nothing. */
+type DamageType = "physical" | "magic" | "true";
+/** What a tower's shot does. Optional fields add an effect; a tower mixes as many as it needs. */
+interface TowerStats {
+    readonly damage: number;
+    readonly type: DamageType;
+    /** Cells. */
+    readonly range: number;
+    /** Shots a second. */
+    readonly rate: number;
+    /** It hits flyers. */
+    readonly air: boolean;
+    /** It hits walkers. */
+    readonly ground: boolean;
+    /** The picture of the shot and its speed (cells a second). */
+    readonly shot: string;
+    readonly shotSpeed: number;
+    /** The shot flies in an arc (a shell). */
+    readonly lob?: boolean;
+    /** The hit is instant: a zap from the tower to the foe (and on along the chain). */
+    readonly beam?: boolean;
+    /** Damage around the hit, cells. */
+    readonly splash?: number;
+    /** Speed × (1 − slow) for slowTime seconds. */
+    readonly slow?: number;
+    readonly slowTime?: number;
+    /** The hit jumps on to this many more foes (each takes 70% of the one before). */
+    readonly chain?: number;
+    /** Damage a second for burnTime seconds (true damage). */
+    readonly burn?: number;
+    readonly burnTime?: number;
+    /** A chance to stop the foe for stunTime seconds. */
+    readonly stun?: number;
+    readonly stunTime?: number;
+    /** The share of armour it ignores (0..1). */
+    readonly pierce?: number;
+    /** A chance of a double hit. */
+    readonly crit?: number;
+    /** Foes shot at once (the furthest ones in range). */
+    readonly multishot?: number;
+}
+interface TowerTierDef {
+    /** Gold to reach this tier (the first: to build). */
+    readonly cost: number;
+    /** What changes from the tier below. */
+    readonly stats: Partial<TowerStats>;
+    readonly art: string;
+}
+interface TowerBranchDef {
+    readonly id: string;
+    readonly cost: number;
+    /** What changes from the last tier. */
+    readonly stats: Partial<TowerStats>;
+    readonly art: string;
+}
+interface TowerDef {
+    readonly id: string;
+    /** Tier 1's stats; tiers add to them. */
+    readonly base: TowerStats;
+    readonly tiers: readonly TowerTierDef[];
+    /** The fourth level: one of these (opened at BRANCH_LEVEL). */
+    readonly branches: readonly TowerBranchDef[];
+    /** The first level it can be built on. */
+    readonly unlockLevel: number;
+    /** The meta var that adds to its power (damage, slow time, burn), a share: 0.12 = +12%. */
+    readonly metaVar: string;
+}
+declare const TOWERS: readonly TowerDef[];
+/** The level the fourth-level branches open on. */
+declare const BRANCH_LEVEL = 6;
+/** The share of the gold spent on a tower that selling gives back. */
+declare const SELL_SHARE = 0.7;
+declare const towerOf: (id: string) => TowerDef | undefined;
+/** A tower's stats at `tier` (1..tiers), or its branch. */
+declare function towerStats(def: TowerDef, tier: number, branch?: string | null): TowerStats;
+/** The gold spent on a tower so far. */
+declare function towerSpent(def: TowerDef, tier: number, branch?: string | null): number;
+declare const towerArt: (def: TowerDef, tier: number, branch?: string | null) => string;
+interface EnemyDef$1 {
+    readonly id: string;
+    /** The asset pack's cast (its look). */
+    readonly cast: string;
+    readonly variant?: number;
+    /** Hit points, × the level's base. */
+    readonly hp: number;
+    /** Cells a second. */
+    readonly speed: number;
+    /** Physical damage cut (0..0.9). */
+    readonly armor: number;
+    /** Magic damage cut (0..0.9). */
+    readonly resist: number;
+    /** Flies over the road: walls of soldiers and shells do not reach it. */
+    readonly flying?: boolean;
+    /** Gold for felling it. */
+    readonly bounty: number;
+    /** Lives it takes through the gate. */
+    readonly leak: number;
+    /** Its height, × a cell. */
+    readonly size: number;
+    /** Damage a second to a soldier holding it, × the level's base hp. */
+    readonly hit: number;
+    /** Heals the foes around it: `share` of their max hit points every `every` seconds. */
+    readonly heals?: {
+        readonly radius: number;
+        readonly share: number;
+        readonly every: number;
+    };
+    /** Falls apart into smaller foes. */
+    readonly splits?: {
+        readonly into: string;
+        readonly count: number;
+    };
+    /** Calls foes onto the road behind it. */
+    readonly summons?: {
+        readonly id: string;
+        readonly count: number;
+        readonly every: number;
+    };
+    /** Below `below` of its hit points it runs `speed` × faster. */
+    readonly enrage?: {
+        readonly below: number;
+        readonly speed: number;
+    };
+    /** A world's boss (the last wave of its last level). */
+    readonly boss?: number;
+    /** The first level it walks in waves (0: never by itself — a split, a summon, a boss). */
+    readonly firstLevel: number;
+    /** Wave budget it takes. */
+    readonly cost: number;
+    /** A small picture over its hit points (what it resists). */
+    readonly badge?: string;
+}
+declare const ENEMIES$1: readonly EnemyDef$1[];
+declare const enemyOf$1: (id: string) => EnemyDef$1 | undefined;
+interface SpellDef {
+    readonly id: string;
+    readonly icon: string;
+    /** strike — meteors on a spot; summon — soldiers on the road who hold the foes. */
+    readonly kind: "strike" | "summon";
+    /** Seconds. */
+    readonly cooldown: number;
+    readonly unlockLevel: number;
+    /** strike: damage of one meteor (× the level's base hp), how many, their radius (cells). */
+    readonly damage?: number;
+    readonly count?: number;
+    readonly radius?: number;
+    readonly burn?: number;
+    /** summon: the soldiers' look, hit points and damage a second (× the level's base hp), seconds they stay. */
+    readonly cast?: string;
+    readonly hp?: number;
+    readonly dps?: number;
+    readonly time?: number;
+}
+declare const SPELLS: readonly SpellDef[];
+/**
+ * A map: MAP_ROWS rows of MAP_COLS cells, row 0 at the top.
+ *   .  grass     #  road      S  an entry (foes come in here; on an edge they walk in from outside)
+ *   X  the gate (a foe that reaches it takes lives)     o  a build spot (the only cells towers stand on)
+ *   t  a tree    r  a rock    ~  water    *  a bush
+ * The road is traced from each entry to the gate (always the step nearer the gate), so two roads may merge.
+ */
+declare const MAP_COLS = 9;
+declare const MAP_ROWS = 13;
+interface MapDef {
+    readonly id: string;
+    readonly rows: readonly string[];
+}
+declare const MAPS: readonly MapDef[];
+type Mirror = "none" | "x" | "y";
+/** A map turned over (a level may play one the other way round). */
+declare function mirrored(map: MapDef, mirror: Mirror): readonly string[];
+interface Cell {
+    readonly col: number;
+    readonly row: number;
+}
+interface TracedMap {
+    readonly rows: readonly string[];
+    /** One road a entry, from the entry to the gate (cells). */
+    readonly paths: readonly (readonly Cell[])[];
+    readonly gate: Cell;
+    readonly spots: readonly Cell[];
+}
+/** The roads of a map: from every entry, always the step nearer the gate. Throws on a broken map (tests run it). */
+declare function traceMap(rows: readonly string[]): TracedMap;
+declare const TD_WORLDS = 4;
+declare const TD_LEVELS_PER_WORLD = 5;
+declare const TD_LEVELS: number;
+/** Stars needed to enter each world (3 a level, 60 in all). */
+declare const TD_WORLD_STARS: readonly number[];
+/** The map of every level, in order (the fourth level of a world plays an earlier map turned over). */
+declare const LEVEL_MAPS: readonly {
+    readonly map: string;
+    readonly mirror: Mirror;
+}[];
+/** A group of one kind of foe in a wave: `count` of them, `gap` seconds apart, from `delay` into the wave. */
+interface WaveGroup {
+    readonly enemy: string;
+    readonly count: number;
+    readonly gap: number;
+    readonly delay: number;
+    /** Which entry (an index into the map's entries; wraps). */
+    readonly entry: number;
+}
+interface WaveDef {
+    readonly groups: readonly WaveGroup[];
+}
+interface TdLevel {
+    readonly level: number;
+    readonly world: number;
+    readonly index: number;
+    readonly boss: boolean;
+    readonly map: string;
+    readonly mirror: Mirror;
+    /** A foe's hit points at hp × 1 (grows a level, and wave by wave inside it). */
+    readonly hp: number;
+    readonly waves: readonly WaveDef[];
+    readonly gold: number;
+    /** Bounties × (later levels pay more). */
+    readonly bounty: number;
+    readonly towers: readonly string[];
+    readonly spells: readonly string[];
+    readonly branches: boolean;
+    /** The foe new on this level, or null. */
+    readonly fresh: string | null;
+    readonly enemies: readonly string[];
+    readonly firstClearGold: number;
+}
+/**
+ * The waves of a level: a budget a wave, spent on the foes open by then; the new foe shows itself early.
+ * `foes`: the wave foes this game plays with (GameSpec content), every one when omitted.
+ */
+declare function wavesOf(level: number, entries: number, foes?: readonly string[]): WaveDef[];
+declare function levelOf$3(level: number, difficulty?: number, foes?: readonly string[]): TdLevel;
+/** Stars needed to play a level (its world's gate). */
+declare const tdStarsToEnter: (level: number) => number;
+/** The stars a cleared level gives by the lives kept: all of them nearly — three. */
+declare const starsFor: (lives: number, start: number) => number;
+/** Lives a revive gives back. */
+declare const REVIVE_LIVES = 5;
+/** Lives at a level's start (before the meta's). */
+declare const TD_LIVES = 20;
+/** gold — 25% more gold at the start; spells — spells come back 30% sooner. */
+type TdPerk = "none" | "gold" | "spells";
+interface TdHeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly gems: number;
+    readonly perk: TdPerk;
+}
+declare const TD_HEROES: readonly TdHeroDef[];
+declare const TD_CHARACTER = "kit-td";
+/**
+ * Upgrades bought between levels with the soft currency (the server's Character system): one a tower (a new
+ * tower gets its own row here and in the seed), the start gold, lives, spells. ⚠ The seed mirrors these numbers
+ * (`KitGameStarterFixtures` of the engine).
+ */
+declare const TD_META_STATS: readonly MetaStatDef[];
+declare const TD_META: MetaGameDef;
+
+declare const WAVE_STARTED = "wave-started";
+/** A build spot of the map. */
+declare const Spot: ComponentType<{
+    index: number;
+    col: number;
+    row: number;
+}>;
+/** A tower on a spot: its kind (a TOWERS id), tier, branch ("" — none yet). */
+declare const Tower: ComponentType<{
+    spot: number;
+    kind: string;
+    tier: number;
+    branch: string;
+    cooldown: number;
+}>;
+/** A foe on the road: its kind (an ENEMIES id), where it is on its route (cells walked), what is on it. */
+declare const Raider: ComponentType<{
+    kind: string;
+    hp: number;
+    maxHp: number;
+    route: number;
+    progress: number;
+    /** Cells, refreshed each frame. */
+    x: number;
+    y: number;
+    slow: number;
+    slowLeft: number;
+    stun: number;
+    burn: number;
+    burnLeft: number;
+    healCd: number;
+    summonCd: number;
+    /** The soldier holding it, or -1. */
+    heldBy: number;
+    enraged: boolean;
+    /** The wave it came with (its hit points grow with it). */
+    wave: number;
+}>;
+/** A shot in flight (px). */
+declare const Missile: ComponentType<{
+    target: number;
+    x: number;
+    y: number;
+    ax: number;
+    ay: number;
+    dist0: number;
+    went: number;
+    stats: TowerStats;
+    power: number;
+    crit: boolean;
+}>;
+/** A soldier of the reinforcement spell, on a route. */
+declare const Soldier: ComponentType<{
+    hp: number;
+    maxHp: number;
+    dps: number;
+    left: number;
+    route: number;
+    progress: number;
+    swing: number;
+}>;
+declare const towerDefenseBlock: BlockDef;
+
+/** A piece on the screen: its id in the board's logic and the cell it moves to. */
+declare const Gem: ComponentType<{
+    id: number;
+    col: number;
+    row: number;
+    kind: number;
+}>;
+declare const match3Block: BlockDef;
+
+type SpecialKind = string;
+interface SpecialDef {
+    readonly id: SpecialKind;
+    /** The cells it clears when it fires: row, col, cross, cross:N, area:N, color, all. */
+    readonly shape: string;
+    /** Drawn over the piece (the rainbow is a piece of its own). */
+    readonly art: string;
+    /** Does a match group make it: its longest run, whether runs cross (L / T), the longest run's direction. */
+    readonly make: ((longest: number, crossing: boolean, dir: "h" | "v") => boolean) | null;
+}
+/** The first row whose `make` fits wins (so five in a row is a rainbow before it is a bomb). */
+declare const SPECIALS: readonly SpecialDef[];
+interface ObstacleDef$1 {
+    readonly id: string;
+    /** under — under a piece (hit when it is cleared); over — over it (it cannot move; a clear breaks the layer);
+     *  block — instead of a piece (hit by a match next to it, `hitByNear`, or by an effect on it). */
+    readonly layer: "under" | "over" | "block";
+    /** Hit points it gets when an enemy puts it down. */
+    readonly hp: number;
+    readonly art: string;
+    readonly hitByNear?: boolean;
+    /** Grows to a neighbour after a move that cleared none of it. */
+    readonly spreads?: boolean;
+    /** At most this many on the board from enemies' spells (so a board never chokes). */
+    readonly max?: number;
+}
+declare const OBSTACLES$1: Readonly<Record<string, ObstacleDef$1>>;
+type Element = "fire" | "water" | "nature" | "light" | "dark";
+/** What an element is strong against (×1.5 on it; the same element ×0.5). */
+declare const ELEMENTS: Readonly<Record<Element, {
+    readonly beats: readonly Element[];
+    readonly color: string;
+}>>;
+interface PieceDef {
+    /** The colour index on the board. */
+    readonly index: number;
+    readonly art: string;
+    readonly color: string;
+    /** attack — hits the foe with its element; heal — heals the hero; shield — blocks the next blow. */
+    readonly role: "attack" | "heal" | "shield";
+    readonly element?: Element;
+}
+declare const PIECES: readonly PieceDef[];
+/** What a foe does on its turn after striking. */
+type EnemySkill = {
+    readonly kind: "sow";
+    readonly obstacle: string;
+    readonly count: number;
+} | {
+    readonly kind: "heal";
+    readonly share: number;
+} | {
+    readonly kind: "rage";
+    readonly mult: number;
+};
+interface EnemyDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly variant?: number;
+    readonly element: Element;
+    /** Hit points and a blow, × the level's base. */
+    readonly hp: number;
+    readonly attack: number;
+    /** Moves between its blows. */
+    readonly every: number;
+    readonly skill?: EnemySkill;
+    readonly boss?: boolean;
+    /** Below this share of its hit points it strikes every `every - 1` moves. */
+    readonly enrage?: number;
+    readonly size: number;
+}
+declare const ENEMIES: readonly EnemyDef[];
+declare const enemyOf: (id: string) => EnemyDef | undefined;
+interface SkillDef$2 {
+    readonly id: string;
+    readonly art: string;
+    /** Mana to cast. */
+    readonly mana: number;
+    /** shape — clears a shape round the cell the player taps (bigger from `bigAt` skill power); storm — turns pieces
+     *  into specials and fires them (more with power). */
+    readonly kind: "shape" | "storm";
+    readonly shape?: string;
+    readonly bigShape?: string;
+    readonly bigAt?: number;
+    readonly count?: number;
+    /** Bonus damage to the foe, × the hero's attack. */
+    readonly damage: number;
+}
+declare const SKILLS$2: readonly SkillDef$2[];
+declare const skillOf$2: (id: string) => SkillDef$2 | undefined;
+interface M3HeroDef {
+    readonly id: string;
+    readonly cast: string;
+    readonly gems: number;
+    readonly element: Element;
+    readonly skill: string;
+}
+declare const M3_HEROES: readonly M3HeroDef[];
+type GoalDef$1 = {
+    readonly kind: "color";
+    readonly color: number;
+    readonly count: number;
+} | {
+    readonly kind: "clear";
+    readonly obstacle: string;
+} | {
+    readonly kind: "drops";
+    readonly count: number;
+} | {
+    readonly kind: "score";
+    readonly value: number;
+};
+type LevelDef$2 = {
+    readonly kind: "goal";
+    readonly board: string;
+    readonly moves: number;
+    readonly colors: number;
+    readonly goals: readonly GoalDef$1[];
+    readonly drops?: number;
+} | {
+    readonly kind: "battle";
+    readonly board: string;
+    readonly elements: number;
+    readonly enemies: readonly string[];
+};
+/** 4 worlds × 10: two goal levels, a battle, … the tenth a boss. */
+declare const LEVELS$2: readonly LevelDef$2[];
+declare const M3_LEVELS_PER_WORLD = 10;
+declare const M3_WORLDS = 4;
+declare const M3_LEVELS: number;
+/** Stars needed to enter each world (3 a level, 120 in all). */
+declare const M3_WORLD_STARS: readonly number[];
+interface M3Level {
+    readonly level: number;
+    readonly world: number;
+    readonly index: number;
+    readonly def: LevelDef$2;
+    readonly boss: boolean;
+    /** The board's colour indices. */
+    readonly colors: readonly number[];
+    /** A foe's hit points and blow at × 1. */
+    readonly enemyHp: number;
+    readonly enemyAttack: number;
+    readonly firstClearGold: number;
+}
+declare function levelOf$2(level: number, difficulty?: number): M3Level;
+declare const m3StarsToEnter: (level: number) => number;
+declare const M3_CHARACTER = "kit-match3";
+/**
+ * The hero's upgrades bought between levels with the soft currency (the server's Character system). ⚠ The seed
+ * mirrors these numbers (`KitGameStarterFixtures` of the engine).
+ */
+declare const M3_META_STATS: readonly MetaStatDef[];
+declare const M3_META: MetaGameDef;
+
+/** Colours by [row][col]; null — no matchable piece. */
+type KindGrid = Array<Array<number | null>>;
+/** Every cell in a run of three or more of one colour, as "col,row". */
+declare function findMatches(grid: KindGrid): Set<string>;
+/** Is there a swap of neighbours that makes a match (on a plain grid). */
+declare function hasMove(grid: KindGrid): boolean;
+
+/** A thing on the screen: its id in the board's logic and its cell. */
+declare const MergeItem: ComponentType<{
+    id: number;
+    col: number;
+    row: number;
+}>;
+/** A waiting customer's order (its slot over the board). */
+declare const Order: ComponentType<{
+    slot: number;
+}>;
+declare const mergeBlock: BlockDef;
+
+interface ChainDef {
+    readonly id: string;
+    /** The art of level n is `${prefix}${n}`. */
+    readonly prefix: string;
+    readonly levels: number;
+    /** The palette role of its rings and sparks. */
+    readonly color: string;
+    /** The generator's art (a tier badge is drawn over it). */
+    readonly gen: string;
+}
+declare const CHAINS: readonly ChainDef[];
+declare const chainOf: (id: string) => ChainDef | undefined;
+interface ObstacleDef {
+    readonly id: string;
+    /** block — instead of an item (the cell is taken); cover — over an item (it cannot be moved). */
+    readonly layer: "block" | "cover";
+    /** The art by hit points left (index hp - 1; the last one for more). */
+    readonly art: readonly string[];
+    /** A merge in a cell next to it takes a hit point. */
+    readonly neighbour: boolean;
+    /** The item under it is hidden (fog). */
+    readonly hides?: boolean;
+    /** An item of the same chain and level may be merged into the covered one (the cover goes). */
+    readonly mergeInto?: boolean;
+    /** Generator taps until it bursts and takes its item with it (a bubble). */
+    readonly ttl?: number;
+    /** Coins it gives when it goes. */
+    readonly coins?: number;
+}
+declare const OBSTACLES: Readonly<Record<string, ObstacleDef>>;
+interface SpecialItemDef {
+    readonly id: string;
+    readonly art: string;
+    /** joker — dropped onto an item, makes it its next level; split — dropped onto an item of level 2+, makes it two of
+     *  the level below; chest — a tap: `amount` free items; energy — a tap: `amount` energy. */
+    readonly effect: "joker" | "split" | "chest" | "energy";
+    readonly amount?: number;
+}
+declare const SPECIAL_ITEMS: readonly SpecialItemDef[];
+declare const specialOf: (id: string) => SpecialItemDef | undefined;
+declare const MG_COLS = 7;
+declare const MG_ROWS = 8;
+declare const BOARDS: Readonly<Record<string, readonly string[]>>;
+interface SkillDef$1 {
+    readonly id: string;
+    readonly art: string;
+    /** Merges to charge it. */
+    readonly charge: number;
+    /** upgrade — `count` items go a level up by themselves (those an order wants next first); free — the next `count`
+     *  generator taps cost no energy; joker — puts `count` jokers on the board for the player to use. */
+    readonly effect: "upgrade" | "free" | "joker";
+    readonly count: number;
+}
+declare const SKILLS$1: readonly SkillDef$1[];
+declare const skillOf$1: (id: string) => SkillDef$1 | undefined;
+interface MergeHeroDef extends MetaHeroDef {
+    readonly skill: string;
+}
+declare const MG_HEROES: readonly MergeHeroDef[];
+interface LevelDef$1 {
+    readonly board: string;
+    /** The chains of the level (CHAINS ids): the board's A–D and a–d are these. */
+    readonly chains: readonly string[];
+    /** Customers in all, one after another. */
+    readonly orders: number;
+    /** The highest level an order asks. */
+    readonly top: number;
+    /** The share of orders that ask two things. */
+    readonly double: number;
+    /** Customers waiting at once. */
+    readonly visible: number;
+    /** The energy over what the orders cost (× 1 — just enough with no luck). */
+    readonly slack?: number;
+    /** × the energy the formula gives (a level the bot found too tight or too loose). */
+    readonly extra?: number;
+    /** The last customer of a world: asks the most and pays the most. */
+    readonly vip?: boolean;
+}
+/** 4 worlds × 10 levels: world 1 — the garden and the bakery, boxes and fog; 2 — jewels, webs, scissors; 3 —
+ *  potions, bubbles, holes; 4 — everything. */
+declare const LEVELS$1: readonly LevelDef$1[];
+declare const MG_LEVELS_PER_WORLD = 10;
+declare const MG_WORLDS = 4;
+declare const MG_LEVELS: number;
+/** Stars needed to enter each world (3 a level, 120 in all). */
+declare const MG_WORLD_STARS: readonly number[];
+interface WantDef {
+    readonly chain: string;
+    readonly level: number;
+}
+interface OrderDef {
+    readonly wants: readonly WantDef[];
+    /** The VIP's order: pays three times. */
+    readonly vip: boolean;
+}
+interface MergeLevel {
+    readonly level: number;
+    readonly world: number;
+    readonly index: number;
+    readonly def: LevelDef$1;
+    readonly boss: boolean;
+    readonly orders: readonly OrderDef[];
+    /** The energy to start with (before the upgrades). */
+    readonly energy: number;
+    readonly firstClearGold: number;
+}
+declare function levelOf$1(level: number, difficulty?: number): MergeLevel;
+declare const mgStarsToEnter: (level: number) => number;
+/** Stars of a won level by the share of the energy left. */
+declare const mgStarsFor: (share: number) => number;
+/** A revive: this much energy and a joker on the board. */
+declare const MG_REVIVE_ENERGY = 15;
+declare const MG_CHARACTER = "kit-merge";
+/**
+ * The upgrades bought between levels with the soft currency (the server's Character system). ⚠ The seed mirrors these
+ * numbers (`KitGameStarterFixtures` of the engine).
+ */
+declare const MG_META_STATS: readonly MetaStatDef[];
+declare const MG_META: MetaGameDef;
+
+interface BusinessDef {
+    readonly id: string;
+    readonly art: string;
+    /** The palette role of its bar and sparks. */
+    readonly color: string;
+    /** The price to open it (level 1); level n+1 costs `cost × growth^n`. */
+    readonly cost: number;
+    /** What one cycle pays per level. */
+    readonly income: number;
+    /** Seconds of a cycle at level 1. */
+    readonly cycle: number;
+    readonly growth: number;
+    /** The price of its manager (collects every cycle by itself). */
+    readonly manager: number;
+}
+declare const BUSINESSES: readonly BusinessDef[];
+declare const businessOf: (id: string) => BusinessDef | undefined;
+interface MilestoneDef {
+    /** The level of a business that reaches it. */
+    readonly at: number;
+    /** × the speed (a cycle is this many times shorter). */
+    readonly speed?: number;
+    /** × what a cycle pays. */
+    readonly income?: number;
+}
+declare const MILESTONES: readonly MilestoneDef[];
+interface UpgradeDef {
+    readonly id: string;
+    /** one: every business of the city gets its own; all: one for the city. */
+    readonly scope: "one" | "all";
+    readonly art: string;
+    /** × what a cycle pays. */
+    readonly mult: number;
+    /** × the business's opening price (scope all: of the city's dearest business). */
+    readonly price: number;
+    /** Shown when the business is at this level (scope all: the city's first business). */
+    readonly after: number;
+}
+declare const UPGRADES: readonly UpgradeDef[];
+interface EventDef {
+    readonly id: string;
+    readonly art: string;
+    /** rush: a business glows: a tap on it, ×`mult` for `seconds`; break: a business stops until `taps` taps;
+     *  invest: an investor: `now` seconds of the city's income at once, or ×`mult` for `seconds`; courier: a chest
+     *  goes by: a tap, `now` seconds of income and `coins` soft coins. */
+    readonly effect: "rush" | "break" | "invest" | "courier";
+    readonly weight: number;
+    /** Seconds it waits for the player. */
+    readonly ttl: number;
+    readonly mult?: number;
+    readonly seconds?: number;
+    readonly taps?: number;
+    readonly now?: number;
+    readonly coins?: number;
+}
+declare const EVENTS: readonly EventDef[];
+declare const eventOf: (id: string) => EventDef | undefined;
+interface SkillDef {
+    readonly id: string;
+    readonly art: string;
+    /** Seconds to charge it (taps and events add to it). */
+    readonly charge: number;
+    /** rush: every business ×`mult` for `seconds`; instant: every open business pays `cycles` cycles at once; sale :
+     *  prices × `mult` for `seconds`. The meta's skill power stretches the seconds and the cycles. */
+    readonly effect: "rush" | "instant" | "sale";
+    readonly mult?: number;
+    readonly seconds?: number;
+    readonly cycles?: number;
+}
+declare const SKILLS: readonly SkillDef[];
+declare const skillOf: (id: string) => SkillDef | undefined;
+interface TycoonHeroDef extends MetaHeroDef {
+    readonly skill: string;
+}
+declare const TY_HEROES: readonly TycoonHeroDef[];
+interface GoalDef {
+    /** cash: earn `n` in the day; level: the business `biz` to level `n`; managers: `n` managers hired. */
+    readonly kind: "cash" | "level" | "managers";
+    readonly n: number;
+    readonly biz?: string;
+}
+interface LevelDef {
+    /** The city's businesses, cheapest first (BUSINESSES ids); the first one is open at the start. */
+    readonly businesses: readonly string[];
+    readonly goals: readonly GoalDef[];
+    /** Cash at the start (default: twice the second business's price). */
+    readonly cash?: number;
+    /** The events of the day (EVENTS ids). */
+    readonly events: readonly string[];
+    /** × the day's length the formula gives (a city the bot found too tight or too loose). */
+    readonly extra?: number;
+    /** The big city at the end of a world: more goals, more coins. */
+    readonly vip?: boolean;
+}
+/** 4 worlds × 10 cities: 1: lemonade to the workshop, rushes and couriers; 2: the bakery to the cinema,
+ *  breakdowns; 3: the cafe to the hotel, investors; 4: the workshop to the spaceport, everything. */
+declare const LEVELS: readonly LevelDef[];
+declare const TY_LEVELS_PER_WORLD = 10;
+declare const TY_WORLDS = 4;
+declare const TY_LEVELS: number;
+/** Stars needed to enter each world (3 a city, 120 in all). */
+declare const TY_WORLD_STARS: readonly number[];
+declare const tyStarsToEnter: (level: number) => number;
+/** Stars of a won city by the share of the day left. */
+declare const tyStarsFor: (share: number) => number;
+/** A revive: this many seconds more of the day. */
+declare const TY_REVIVE_SECONDS = 30;
+declare const TY_CHARACTER = "kit-tycoon";
+/**
+ * The upgrades bought between cities with the soft currency (the server's Character system). ⚠ The seed mirrors these
+ * numbers (`KitGameStarterFixtures` of the engine).
+ */
+declare const TY_META_STATS: readonly MetaStatDef[];
+declare const TY_META: MetaGameDef;
+
+interface Biz {
+    readonly def: BusinessDef;
+    level: number;
+    /** 0..1 of the cycle. */
+    progress: number;
+    /** A finished cycle waits for a tap (no manager). */
+    ready: boolean;
+    manager: boolean;
+    /** × what a cycle pays (the upgrades bought). */
+    mult: number;
+    /** Seconds of a rush left, and its ×. */
+    rush: number;
+    rushMult: number;
+    /** Taps left to fix a breakdown (0: it works). */
+    broken: number;
+}
+/** A timed effect on the whole city (a skill, an investor's share). */
+interface Timed {
+    readonly id: string;
+    left: number;
+    readonly income: number;
+    readonly price: number;
+}
+interface Mods {
+    /** + share of what a cycle pays. */
+    readonly income: number;
+    /** + share of the speed. */
+    readonly speed: number;
+    /** − share of the prices (at most 0.9). */
+    readonly discount: number;
+}
+interface TycoonState {
+    readonly biz: Biz[];
+    cash: number;
+    earned: number;
+    /** × of the "all" upgrades. */
+    allMult: number;
+    readonly bought: Set<string>;
+    readonly timed: Timed[];
+    readonly mods: Mods;
+}
+interface TycoonLevel {
+    readonly level: number;
+    readonly world: number;
+    readonly index: number;
+    readonly def: LevelDef;
+    readonly boss: boolean;
+    /** Seconds of the day. */
+    readonly day: number;
+    readonly cash: number;
+    readonly coins: number;
+    readonly firstClearGold: number;
+}
+/** The bot's time on a level (once per level). */
+declare function botTimeOf(n: number): number;
+declare function levelOf(level: number, difficulty?: number): TycoonLevel;
+
+/** A manager standing by its building. */
+declare const Manager: ComponentType<{
+    index: number;
+}>;
+/** 1234 → "1.2K". */
+declare const shortCash: (n: number) => string;
+declare const tycoonStateOf: (w: World) => {
+    s: TycoonState;
+    level: TycoonLevel;
+} | undefined;
+declare const tycoonBlock: BlockDef;
+
+interface AssetPackDef extends RegistryEntry {
+    /** Taxonomy setting id ("fantasy", "sci-fi", "cozy", "post-apocalypse"). */
+    readonly setting: string;
+    /** Its name per language ("en" is the fallback). */
+    readonly names: Readonly<Record<string, string>>;
+    /** Colours by role (view.ts DEFAULT_PALETTE has every role). */
+    readonly palette: Readonly<Record<string, string>>;
+    /** Default texts (`res.coins`…) per language, under the spec's own. */
+    readonly texts?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+    /** Hero races (@idosgames/characters) that fit the setting, the first is the default. */
+    readonly races?: readonly string[];
+    /** The art style its pictures are drawn in (src/art); default: the pack's id. */
+    readonly style?: string;
+    /** Who plays the roles (hero, foe, foe2, boss, helper), over the kit's DEFAULT_CAST role by role. */
+    readonly cast?: Readonly<Record<string, CastDef>>;
+}
+interface LinkDef extends RegistryEntry {
+    /** Text key of its name. */
+    readonly name: string;
+    /** Genres of the core mode it fits. */
+    readonly core: readonly string[];
+    /** Platform systems the title must have (modules/<id>), installed by the creation path. */
+    readonly systems: readonly string[];
+    /** The spec with the link: resources, flows, maybe a mode. Pure: returns a new spec. */
+    apply(spec: GameSpec): GameSpec;
+}
+declare const ASSET_PACKS: RegistryKind<AssetPackDef>;
+declare const LINKS: RegistryKind<LinkDef>;
+/** A pack's name in a language, English when it has none there. */
+declare const packName: (pack: AssetPackDef, language?: string) => string;
+/**
+ * Applies a link to a spec: refused (issues, the spec unchanged) when the link is unknown or does not
+ * fit the genre of the spec's core mode.
+ */
+declare function applyLink(spec: GameSpec, linkId: string, registry: Registry): {
+    spec: GameSpec;
+    systems: readonly string[];
+    issues: Issue[];
+};
+
+declare const fantasyPack: AssetPackDef;
+declare const sciFiPack: AssetPackDef;
+declare const cozyPack: AssetPackDef;
+declare const postApocalypsePack: AssetPackDef;
+declare const PLATFORM_PACKS: readonly AssetPackDef[];
+declare const heroUpgradeLink: LinkDef;
+declare const puzzleCityLink: LinkDef;
+declare const runnerCollectionLink: LinkDef;
+declare const defenseBoostsLink: LinkDef;
+declare const PLATFORM_LINKS: readonly LinkDef[];
+
+/**
+ * Lane runner with levels to a finish (owner, 08.11.2026): swipe for a lane, tap to jump; six kinds of
+ * obstacles in patterns, power-ups, hearts, a revive, up to three stars a level; the meta (levels, upgrades,
+ * heroes) is the host's (RUNNER_META).
+ */
+declare const runnerPreset: PresetDef;
+/**
+ * Platformer with the player's own controls (owner, 08.11.2026): walk, jump (hold for higher), the abilities the
+ * stars open; worlds of levels from hand-made rooms, enemies, traps, a checkpoint, three stars a level, a boss at
+ * the end of a world; the meta (worlds, upgrades, heroes) is the host's (PLATFORMER_META).
+ */
+declare const platformerPreset: PresetDef;
+/**
+ * Survivors-like: walk, the weapons fire by themselves (six weapons, six passives, five levels each), foes of
+ * six kinds in a directed stream, elites with chests, mini-bosses, the chapter's boss; ten chapters and stats
+ * bought between runs (the meta: the host sets meta:* vars before a round).
+ */
+declare const survivorsPreset: PresetDef;
+/**
+ * Tower defense with ready-made build spots (owner, 08.11.2026): four towers of three tiers and a branch each, foes
+ * that fly, resist, heal, split and call, two spells, a commander; worlds of hand-made maps, a boss at the end of a
+ * world, three stars by the lives kept; the meta (worlds, upgrades, commanders) is the host's (TD_META). Towers,
+ * foes, maps and spells are rows of registries (kit/towerDefense/content.ts).
+ */
+declare const towerDefensePreset: PresetDef;
+/**
+ * Match-3 with a hero (owner, 08.11.2026): goal levels (colours, ice, stones, chains, cages, slime, drops) and battles
+ * (the hero against foes: element pieces hit, hearts heal, shields block; foes strike and spoil the board) in turn;
+ * specials and combos; the hero's skill from mana on every level; 4 worlds × 10 levels, a boss at the end of each;
+ * the meta (worlds, the hero's upgrades, heroes) is the host's (M3_META). Content: kit/match3/content.ts.
+ */
+declare const match3Preset: PresetDef;
+/**
+ * Merge with levels (owner, 08.11.2026): hand-made boards with generators of four chains (they merge too), boxes, fog,
+ * webs, bubbles and special items (a joker, scissors, a chest, a battery); customers come one after another with
+ * orders; all served → the level is won, three stars by the energy left; the hero's skill charged by merges; 4 worlds
+ * × 10 levels, a VIP at the end of each; the meta (worlds, upgrades, heroes) is the host's (MG_META). Content:
+ * kit/merge/content.ts.
+ */
+declare const mergePreset: PresetDef;
+/**
+ * Tycoon with levels (owner, 08.11.2026): cities of 2–4 businesses (eight in the registry) with goals (earn so much, a
+ * business to a level, managers hired) and a day of a few minutes (from a bot's play of the city); levels, milestones,
+ * managers, upgrades for the day's cash; events (a rush, a breakdown, an investor, a courier); the hero's skill charged
+ * by time and taps; all goals done → three stars by the time left; 4 worlds × 10 cities, a big city at the end of each;
+ * the meta (worlds, upgrades, heroes) is the host's (TY_META). Content: kit/tycoon/content.ts.
+ */
+declare const tycoonPreset: PresetDef;
+declare const PLATFORM_PRESETS: readonly PresetDef[];
+/** Core effects + the platform's blocks and presets. Safe to call once per registry. */
+declare function registerPlatformKit(registry: Registry): void;
+/**
+ * The spec a game runs when its title has none yet (a fresh title before the constructor wrote one,
+ * the playground). A complete, valid game on its own.
+ */
+declare const DEMO_SPEC: GameSpec;
+/**
+ * A complete, valid one-mode game of a preset: the base's coins (CO) from the round and spent in the
+ * store, the round's score, the texts and palette given. The creation path starts from this and the
+ * config agent edits it; links between modes are added on top (economy links).
+ */
+declare function specForPreset(presetId: string, options?: {
+    seed?: string;
+    params?: Readonly<Record<string, unknown>>;
+    texts?: GameSpec["texts"];
+    palette?: Readonly<Record<string, string>>;
+    /** Asset pack id ("fantasy"…). */
+    assets?: string;
+    coinRef?: string;
+}): GameSpec;
+
+/** Which part of the title a knob changes (the dashboard groups its cards by it). */
+type KnobGroup = "look" | "feel" | "economy" | "liveops" | "texts";
+/** When the decision model answers it: on creation (the one request that creates the title), on a later tune, or both. */
+type KnobStage = "create" | "tune";
+/** A text shown to the creator. English is required, other languages fall back to it. */
+type KnobText = Readonly<{
+    en: string;
+    ru?: string;
+} & Record<string, string | undefined>>;
+/**
+ * One change of one config section.
+ *
+ * `path` is a dot path inside the section; a segment `name[field=value]` picks the element of the
+ * array `name` whose `field` equals `value` (`modes[role=core].params.difficulty`); a key with a dot in
+ * it is quoted (`texts.'res.coins'.en`). Plain segments
+ * that are missing are created as objects; a missing array element is not created (the patch is
+ * skipped). An empty path is the section itself.
+ *
+ * The `GameSpec` section is a JSON string in the config: patches address the parsed object, the
+ * applier parses and serializes it.
+ */
+interface KnobPatch {
+    /** Config section: a property of the title's public configuration ("Look", "GameSpec", "Reward"…). */
+    readonly section: string;
+    /**
+     * set: put `value` (a level's value for a score knob); merge: deep-merge the object `value` (objects
+     * merge key by key, everything else is replaced); unset: remove; add / remove: put into / take out
+     * of the array at `path` each item of the array `value` (equal items once).
+     */
+    readonly op: "set" | "merge" | "unset" | "add" | "remove";
+    readonly path?: string;
+    readonly value?: unknown;
+    /**
+     * Score knobs only: the value from the answered level (0 = the first level, 1 = the last):
+     * `min + level × (max − min)`, rounded when `integer`, to `digits` places otherwise (default 2).
+     */
+    readonly range?: Readonly<{
+        min: number;
+        max: number;
+        integer?: boolean;
+        digits?: number;
+    }>;
+    /**
+     * Change only what the title already has: the patch is skipped when a key on its path (the last one
+     * too) is missing. Without it `set` / `merge` / `add` create the plain objects on the way, which is
+     * right for Look and GameSpec and wrong for content a seed brought (a quest, an event, a currency):
+     * a title without it would get a broken stub. The catalog sets it on every such section by itself.
+     */
+    readonly ifExists?: boolean;
+}
+/** An answer of a choice knob: what the decision model reads about it, what the creator sees, what it writes. */
+interface KnobOption {
+    /** Snake/kebab-case id, unique in its knob or list. */
+    readonly id: string;
+    readonly title: KnobText;
+    /** For the decision model: what this option is. */
+    readonly what: string;
+    /** For the decision model: what it is NOT for (keeps near options apart). */
+    readonly notFor?: string;
+    /** For the decision model: ideas it fits. */
+    readonly examples?: readonly string[];
+    /** Colour swatches or a preview hint for the dashboard card (#rrggbb). */
+    readonly swatch?: readonly string[];
+    readonly patches: readonly KnobPatch[];
+    /**
+     * Translations of the texts the patches write (`{ "ru": { "Gold": "Золото" } }`): the server puts them
+     * into the title's translation tables (only missing keys), like a seed's `$localization`.
+     */
+    readonly translations?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+}
+/** Which titles a knob is for. Omitted = every title. */
+interface KnobScope {
+    /** Any of these modules is in the title (a base or a system: "kit-game", "quests", "premium"). */
+    readonly modules?: readonly string[];
+    /** The title's constructor genre (the GameSpec core mode's preset): "runner", "tycoon"… */
+    readonly presets?: readonly string[];
+    /** Every one of these config sections has something in it (a knob of the daily calendar needs `Reward`). */
+    readonly sections?: readonly string[];
+}
+interface KnobBase {
+    /** Dotted id, unique in the catalog: "look.theme", "feel.runner.lanes". */
+    readonly id: string;
+    readonly group: KnobGroup;
+    readonly title: KnobText;
+    /** One line for the creator: what turning it changes. */
+    readonly hint?: KnobText;
+    readonly for?: KnobScope;
+    /** Omitted = both. */
+    readonly stages?: readonly KnobStage[];
+    /** The question for the decision model, in English. */
+    readonly question: string;
+}
+interface ChoiceKnob extends KnobBase {
+    readonly kind: "choice";
+    /** The options, or `list` (then the options are that list's items: a shared list, extendable in PlatformAdmin). */
+    readonly options?: readonly KnobOption[];
+    readonly list?: string;
+}
+interface ScoreKnob extends KnobBase {
+    readonly kind: "score";
+    /** 2..10 levels, from the first to the last; the decision model answers a fractional level. */
+    readonly levels: readonly string[];
+    /** What the creator sees on each level (short, per language), as many as `levels`: those are for the model. */
+    readonly levelTitles?: readonly KnobText[];
+    /** Applied with the answered level (their `range` gives the value). */
+    readonly patches: readonly KnobPatch[];
+}
+interface NoulKnob extends KnobBase {
+    readonly kind: "noul";
+    /** What "yes" and "no" mean, for the decision model. */
+    readonly yes: string;
+    readonly no: string;
+    readonly onYes: readonly KnobPatch[];
+    readonly onNo?: readonly KnobPatch[];
+}
+type KnobDef = ChoiceKnob | ScoreKnob | NoulKnob;
+/** The exported catalog: every knob, and the shared lists choice knobs point at. */
+interface KnobCatalog {
+    readonly version: number;
+    readonly knobs: readonly KnobDef[];
+    readonly lists: Readonly<Record<string, readonly KnobOption[]>>;
+}
+/** The decision model's limits (TypeSafe System One): options of a choice, levels of a score. */
+declare const DECISION_MAX_OPTIONS = 255;
+declare const DECISION_MAX_LEVELS = 10;
+
+/** One path segment: a key, or `key[field=value]` (an array element picked by a field). */
+interface Segment {
+    readonly key: string;
+    readonly match?: {
+        field: string;
+        value: string;
+    };
+}
+/** `modes[role=core].params.difficulty` → segments; `null` when a segment is malformed. */
+declare function parseKnobPath(path: string | undefined): Segment[] | null;
+/** A score answer (0..1) → the patch's value by its range; the patch's own value otherwise. */
+declare function patchValue(patch: KnobPatch, level?: number): unknown;
+/**
+ * Applies the patches in order to a section's value (a parsed object; `undefined` = the section is empty).
+ * Returns the new value and the indexes of the patches that could not be applied (a bad path, an array
+ * element that is not there, `add` to something that is not an array): they are skipped, the rest
+ * still applies. Never mutates the input.
+ */
+declare function applyPatches(section: unknown, patches: readonly KnobPatch[], level?: number): {
+    value: unknown;
+    skipped: number[];
+};
+/** Every (section, path) a list of patches writes: what a knob owns (pinning compares against it). */
+declare function patchTargets(patches: readonly KnobPatch[]): string[];
+
+declare const KNOB_CATALOG_VERSION = 1;
+declare const KNOBS: readonly KnobDef[];
+declare const KNOB_CATALOG: KnobCatalog;
+
+declare const UI_THEMES: readonly KnobOption[];
+declare const KIT_PALETTES: readonly KnobOption[];
+declare const HERO_LOOK_OPTIONS: readonly KnobOption[];
+declare const BACKGROUND_OPTIONS: readonly KnobOption[];
+declare const SOUND_SET_OPTIONS: readonly KnobOption[];
+/** Ids the UI kit must know how to draw / play (its own tests check them against these lists). */
+declare const LOOK_RUNTIME_IDS: {
+    readonly backgrounds: string[];
+    readonly soundSets: string[];
+};
+/** All shared lists by id. */
+declare const KNOB_LISTS: Readonly<Record<string, readonly KnobOption[]>>;
+
+/** Errors of a catalog; empty = good. */
+declare function validateKnobCatalog(catalog: KnobCatalog): string[];
+
+export { ABILITIES, ART, ASSET_PACKS, type AbilityId, ActorAct, ActorPose, type ArtContext, type ArtDef, ArtLook, type AssetPackDef, BACKGROUND_OPTIONS, BLOCKS, BOSS_DEFEATED, BOSS_SPAWNED, BRANCH_LEVEL, type BlockContext, type BlockDef, type Board, Body, Bullet, CHAPTERS, CORE_EFFECTS, CastDef, type ChoiceKnob, ComponentType, type Controls, DECISION_MAX_LEVELS, DECISION_MAX_OPTIONS, DEFAULT_REWARDS, DEMO_SPEC, type DamageType, type DefineOptions, Drop, EFFECTS, ENEMIES$1 as ENEMIES, ENGINES, ENTRY_ID_RE, type EffectContext, type EffectDef, type EffectSpec, type EnemyDef$1 as EnemyDef, type Engine, Entity, type Expr, ExprError, type ExprScope, type ExprValue, FOES, FUNCTIONS, type FlowSpec, Foe, type FoeKind, FxEvent, GIVE_UP, type GameSpec, Gem, HEROES, HERO_LOOK_OPTIONS, type HeroDef, type Issue, Jumper, KIT_PALETTES, KNOBS, KNOB_CATALOG, KNOB_CATALOG_VERSION, KNOB_LISTS, KNOWN_SYSTEMS, type KindGrid, type KnobCatalog, type KnobDef, type KnobGroup, type KnobOption, type KnobPatch, type KnobScope, type KnobStage, type KnobText, LEVELS_PER_WORLD, LEVEL_CLEARED, LEVEL_MAPS, LEVEL_UP, LINKS, LOOK_RUNTIME_IDS, type LinkDef, type EnemyDef as M3EnemyDef, type GoalDef$1 as M3GoalDef, type M3HeroDef, type M3Level, type LevelDef$2 as M3LevelDef, type SkillDef$2 as M3SkillDef, M3_CHARACTER, ELEMENTS as M3_ELEMENTS, ENEMIES as M3_ENEMIES, M3_HEROES, M3_LEVELS, M3_LEVELS_PER_WORLD, LEVELS$2 as M3_LEVEL_DEFS, M3_META, M3_META_STATS, OBSTACLES$1 as M3_OBSTACLES, PIECES as M3_PIECES, SKILLS$2 as M3_SKILLS, SPECIALS as M3_SPECIALS, M3_WORLDS, M3_WORLD_STARS, MAPS, MAP_COLS, MAP_ROWS, MAX_LEVEL, MAX_PASSIVES, MAX_WEAPONS, META_CHARACTER, META_STATS, BOARDS as MG_BOARDS, CHAINS as MG_CHAINS, MG_CHARACTER, MG_COLS, MG_HEROES, MG_LEVELS, MG_LEVELS_PER_WORLD, LEVELS$1 as MG_LEVEL_DEFS, MG_META, MG_META_STATS, OBSTACLES as MG_OBSTACLES, MG_REVIVE_ENERGY, MG_ROWS, SKILLS$1 as MG_SKILLS, SPECIAL_ITEMS as MG_SPECIAL_ITEMS, MG_WORLDS, MG_WORLD_STARS, type MapDef, type MergeHeroDef, MergeItem, type MergeLevel, type MetaGameDef, type MetaHeroDef, type MetaStatDef, type ChainDef as MgChainDef, type LevelDef$1 as MgLevelDef, type ObstacleDef as MgObstacleDef, type OrderDef as MgOrderDef, type SkillDef$1 as MgSkillDef, type SpecialItemDef as MgSpecialItemDef, type WantDef as MgWantDef, Missile, type ModeSpec, type NoulKnob, type NumberOrFormula, OBSTACLE_KINDS, type ObstacleKind, Order, PASSIVES, PASSIVE_IDS, PIECE_COLORS, PLATFORMER_CHARACTER, PLATFORMER_HEROES, PLATFORMER_LEVELS, PLATFORMER_META, PLATFORMER_META_STATS, PLATFORM_LINKS, PLATFORM_PACKS, PLATFORM_PRESETS, POWERS, POWER_IDS, PRESETS, type ParamDef, type ParamDefs, type ParamValue, type PassiveDef, type PassiveId, type PlatformerHeroDef, type PlatformerLevel, type PlatformerPerk, type PowerDef, type PowerId, type PresetDef, REROLL_GEMS, REVIVE, REVIVE_GEMS, REVIVE_OFFER, ROOMS, ROOM_ROWS, ROUND_ENDED, ROUND_OVER, ROUND_STARTED, RUNNER_CHARACTER, RUNNER_HEROES, RUNNER_LEVELS, RUNNER_META, RUNNER_META_STATS, Raider, type Registry, type RegistryEntry, type RegistryKind, type ResolvedMode, type ResolvedSpec, type ResourceSpec, type RewardedPlacementDef, type RewardsSpec, RoadItem, type RoomDef, type RoomFeature, type RoundState, type RuleDef, Runner, type RunnerHeroDef, type RunnerLevel, type RunnerPerk, type RunningMode, SELL_SHARE, SHOW_START, SOUND_SET_OPTIONS, SPEC_VERSION, SPELLS, START_ROUND, SURVIVORS_META, type ScoreKnob, Shot, Soldier, type SpecResult, type SpellDef, Spot, type StartModeOptions, Survivor, type SurvivorsBuild, TD_CHARACTER, TD_HEROES, TD_LEVELS, TD_LEVELS_PER_WORLD, TD_LIVES, TD_META, TD_META_STATS, REVIVE_LIVES as TD_REVIVE_LIVES, TD_WORLDS, TD_WORLD_STARS, TOWERS, BUSINESSES as TY_BUSINESSES, TY_CHARACTER, EVENTS as TY_EVENTS, TY_HEROES, TY_LEVELS, TY_LEVELS_PER_WORLD, LEVELS as TY_LEVEL_DEFS, TY_META, TY_META_STATS, MILESTONES as TY_MILESTONES, TY_REVIVE_SECONDS, SKILLS as TY_SKILLS, UPGRADES as TY_UPGRADES, TY_WORLDS, TY_WORLD_STARS, type TdHeroDef, type TdLevel, type TdPerk, Thing, Tower, type TowerBranchDef, type TowerDef, type TowerStats, type TowerTierDef, type TracedMap, type BusinessDef as TyBusinessDef, type EventDef as TyEventDef, type GoalDef as TyGoalDef, type LevelDef as TyLevelDef, Manager as TyManager, type SkillDef as TySkillDef, type UpgradeDef as TyUpgradeDef, type TycoonHeroDef, type TycoonLevel, UI_THEMES, UPGRADE_PICK, UPGRADE_PICKED, UPGRADE_REROLL, type UpgradeOption, type ViewSize, WAVE_STARTED, WEAPONS, WEAPON_IDS, WORLDS, WORLD_STARS, type WaveDef, type WaveGroup, type WeaponDef, type WeaponId, World, abilitiesFor, act, applyLink, applyPatches, artAspect, artDocument, attachRules, boardOf, buildFromVar, buildToVar, cellAt, cellCenter, chapterOf, checkEconomy, checkExpr, checkRules, compileExpr, contentOf, cozyPack, createKitRegistry, createRegistry, defenseBoostsLink, defineKind, enemyOf$1 as enemyOf, evalNumber, fantasyPack, findMatches, fx, hasArt, hasErrors, hasMove, heroCharacterOf, heroUpgradeLink, laneRunnerBlock, levelOf$5 as levelOf, enemyOf as m3EnemyOf, levelOf$2 as m3LevelOf, skillOf$2 as m3SkillOf, m3StarsToEnter, match3Block, match3Preset, mergeBlock, mergePreset, metersOf, chainOf as mgChainOf, levelOf$1 as mgLevelOf, skillOf$1 as mgSkillOf, specialOf as mgSpecialOf, mgStarsFor, mgStarsToEnter, migrateSpec, mirrored, offerFromVar, offerToVar, packName, parseKnobPath, patchTargets, patchValue, placeBackdrop, platformerBlock, levelOf$4 as platformerLevelOf, platformerPreset, postApocalypsePack, puzzleCityLink, registerCoreEffects, registerPlatformKit, resolveParams, roundBlock, runnerCollectionLink, runnerPreset, sciFiPack, scrollBackdrop, setPose, shortCash, specForPreset, starsToEnter, startMode, survivorsBlock, survivorsPreset, levelOf$3 as tdLevelOf, starsFor as tdStarsFor, tdStarsToEnter, wavesOf as tdWavesOf, towerArt, towerDefenseBlock, towerDefensePreset, towerOf, towerSpent, towerStats, traceMap, trackControls, botTimeOf as tyBotTimeOf, businessOf as tyBusinessOf, eventOf as tyEventOf, levelOf as tyLevelOf, skillOf as tySkillOf, tyStarsFor, tyStarsToEnter, tycoonBlock, tycoonPreset, tycoonStateOf, validateKnobCatalog, validateSpec, viewOf };