@zylem/behaviors 0.8.10 → 0.8.11

package/dist/behavior-descriptor-NS_qnzzp.d.ts

@@ -0,0 +1,4527 @@
+import { B as BehaviorMetadata } from './behavior-metadata-Drm1zxI2.js';
+import { StageWasmExports, RuntimeCompatibility, RuntimeBehaviorName } from '@zylem/runtime';
+
+type VelocityIntentMode = 'replace' | 'add';
+interface VelocityIntent {
+    x?: number;
+    y?: number;
+    z?: number;
+    mode: VelocityIntentMode;
+    priority?: number;
+}
+/**
+ * Transform state managed by Valtio for per-frame physics intent accumulation.
+ *
+ * This store accumulates transformation intents during the frame,
+ * then applies them all at once after onUpdate() callbacks complete.
+ *
+ * Design decisions:
+ * - Position: Accumulated deltas (additive)
+ * - Rotation: Last value wins (replacement)
+ * - Velocity: Accumulated deltas (additive)
+ * - Angular velocity: Accumulated deltas (additive)
+ */
+interface TransformState {
+    /** Position deltas to be applied (accumulated) */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Rotation quaternion (last value wins) */
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    /** Linear velocity (accumulated) */
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Angular velocity (accumulated) */
+    angularVelocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Per-source velocity intents composed once per frame */
+    velocityChannels: Record<string, VelocityIntent>;
+    /** Dirty flags to track what needs to be applied */
+    dirty: {
+        position: boolean;
+        rotation: boolean;
+        velocityX: boolean;
+        velocityY: boolean;
+        velocityZ: boolean;
+        velocityChannels: boolean;
+        angularVelocity: boolean;
+    };
+}
+/**
+ * Create a new transform store with optional initial values.
+ * The store is a Valtio proxy, making it reactive for debugging/visualization.
+ *
+ * @param initial Optional initial state values
+ * @returns Reactive transform state
+ */
+declare function createTransformStore(initial?: Partial<TransformState>): TransformState;
+
+/**
+ * Minimal, runtime-agnostic entity options contract.
+ *
+ * The full engine entity (in `@zylem/game-lib`) provides a richer options type,
+ * but behaviors only rely on this loose shape.
+ */
+interface GameEntityOptions {
+    [key: string]: any;
+    name?: string;
+}
+/**
+ * Structural stand-in for the engine `GameEntity`.
+ *
+ * Behaviors annotate against this loose contract so that `@zylem/behaviors`
+ * (and its `@zylem/behaviors/core` surface) never has to depend on the concrete
+ * `@zylem/game-lib` entity implementation. The real engine entity is
+ * structurally assignable to this type.
+ */
+declare class GameEntity<TOptions = unknown> {
+    [key: string]: any;
+    uuid: string;
+    name: string;
+    type: string;
+    options?: TOptions & Record<string, unknown>;
+    group: any;
+    mesh?: any;
+    materials?: any[];
+    /** Opaque host-owned physics references (never inspected by behaviors). */
+    body: unknown | null;
+    collider: unknown | null;
+    colliderDesc?: any;
+    colliderDescs: any[];
+    bodyDesc?: any;
+    physicsAttached: boolean;
+    runtimeHandle?: number;
+    transformStore?: TransformState;
+    nodeDestroy?: any;
+    isInstanced?: boolean;
+    private __behaviorRefs;
+    create(): this;
+    onCleanup(callback: () => void): this;
+    setPosition(_x: number, _y: number, _z: number): void;
+    setRotation(_x: number, _y: number, _z: number): void;
+    setRotationZ(_z: number): void;
+    setScale(_x: number, _y: number, _z: number): void;
+    /**
+     * Attach a behavior to this entity. The real engine entity does substantially
+     * more, but this functional stub stores the merged ref and builds the handle
+     * so descriptor/handle logic (and tests that drive behaviors directly) work
+     * without the full engine.
+     */
+    use<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>>(descriptor: BehaviorDescriptor<O, H>, options?: Partial<O>): BehaviorHandle<O, H>;
+    /** Live behavior refs attached via {@link use}. */
+    getBehaviorRefs(): BehaviorRef<any>[];
+}
+/**
+ * Factory contract injected into behavior systems via
+ * {@link BehaviorSystemContext.createEntity}. The host engine supplies the real
+ * entity factory at stage-construction time.
+ */
+type CreateEntityFn = (options?: Partial<GameEntityOptions>) => GameEntity<GameEntityOptions>;
+
+/** B191–B200. Milliseconds and input edges are explicit, ordered host data.
+ * Input timestamps are corrected by subtracting latencyMs; chart/clock times are already calibrated.
+ * Submit queued inputs in timestamp order BEFORE advancing the clock watermark. Physics/render
+ * stepping never moves chart time. Inclusive judgment windows; a miss finalizes at lateWindow+1ms.
+ * 64 notes, 8 tempo segments, 8 nonoverlapping score phrases, 8 unique scene transitions.
+ * Setup is immutable after start. Note kinds: 0 tap, 1 hold/release, 2 sustain.
+ * Results: 0 pending, 1 perfect, 2 good, 3 miss, 4 canceled; phases: 0 queued, 1 held, 2 final.
+ * Lane masks use five bits (1..31). Scene 1 starts; transition IDs are unique in 2..255.
+ * Beat units are integer ticks, 480 per quarter note. Tempo changes must precede beat notes.
+ * Pause freezes chart time; the host rebases its audio clock on resume. Seeking is forward-only,
+ * while paused, and cancels skipped/held notes without score, meter changes or replay rewards.
+ * A successful sustain earns 10 points per completed 100ms since max(head time, press time).
+ * A score phrase credits once after all its notes succeed. 50 charge buys 2000ms of 2x scoring;
+ * the end timestamp is exclusive. Hits earn 300/100 base points through the same score pipeline.
+ * Failure is terminal; remaining notes are canceled. Detach/despawn releases all session state.
+ * Values and request IDs are exact integers within 0..0xffffff. Request IDs strictly increase.
+ */
+declare const RHYTHM_ABILITIES: readonly ["timestamped-rhythm-judgment", "hold-release-rhythm", "call-and-response-pattern", "tempo-map-chart-player", "fret-chord-strum", "hammer-on-pull-off-chain", "sustain-note-tracking", "phrase-earned-score-power", "rhythm-scene-remix", "performance-failure-meter"];
+declare const RHYTHM_EVENTS: readonly ["timestamped-rhythm-judgment", "hold-release-rhythm", "call-and-response-pattern", "tempo-map-chart-player", "fret-chord-strum", "hammer-on-pull-off-chain", "sustain-note-tracking", "phrase-earned-score-power", "rhythm-scene-remix", "performance-failure-meter", "chart-or-clock", "note-result", "failed", "scene-changed", "cue"];
+type RhythmAbility = (typeof RHYTHM_ABILITIES)[number];
+type RhythmEvent = (typeof RHYTHM_EVENTS)[number];
+interface RhythmOptions {
+    perfectMs?: number;
+    goodMs?: number;
+    lateMs?: number;
+    latencyMs?: number;
+}
+type RhythmAction = {
+    requestId: number;
+} & ({
+    type: "hit";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "hold-press";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "hold-release";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "call";
+    start: number;
+    response: number;
+    duration: number;
+} | {
+    type: "cue";
+    offset: number;
+    lanes: number;
+} | {
+    type: "response";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "tempo";
+    beat: number;
+    bpm: number;
+} | {
+    type: "beat-note";
+    beat: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "chart-hit";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "seek";
+    timestamp: number;
+} | {
+    type: "strum";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "chain-strum";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "fret-edge";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "sustain-press";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "sustain-release";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "phrase";
+    first: number;
+    last: number;
+    reward: number;
+} | {
+    type: "activate-power";
+    timestamp: number;
+} | {
+    type: "power-hit";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "transition";
+    timestamp: number;
+    scene: number;
+} | {
+    type: "remix-hit";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "performance";
+    initial: number;
+    hitGain: number;
+    missLoss: number;
+    threshold: number;
+} | {
+    type: "performance-hit";
+    note: number;
+    timestamp: number;
+    lanes: number;
+    scene: number;
+} | {
+    type: "note";
+    kind: number;
+    timestamp: number;
+    end: number;
+    lanes: number;
+    scene: number;
+    eligible: number;
+} | {
+    type: "start";
+} | {
+    type: "clock";
+    timestamp: number;
+} | {
+    type: "pause";
+    paused: number;
+});
+interface RhythmNote {
+    kind: number;
+    timestamp: number;
+    end: number;
+    lanes: number;
+    scene: number;
+    eligible: boolean;
+    phase: number;
+    result: number;
+    headResult: number;
+    offset: number;
+    releaseOffset: number;
+    ticks: number;
+    cue: number;
+    responseCue: boolean;
+}
+interface RhythmState {
+    abilities: RhythmAbility[];
+    lastRequest: number;
+    revision: number;
+    clock: number;
+    started: boolean;
+    paused: boolean;
+    score: number;
+    hits: number;
+    misses: number;
+    scene: number;
+    held: number;
+    chain: boolean;
+    meter: number;
+    powerUntil: number;
+    failed: boolean;
+    performance: number;
+    transitions: number;
+    cues: number;
+    tempoSegments: number;
+    settledPhrases: number;
+    callPhase: number;
+    chartCursor: number;
+    patternResult: number;
+    notes: RhythmNote[];
+}
+declare function rhythmData(o: RhythmOptions): number[];
+declare function rhythmOperation(a: RhythmAction): {
+    op: number;
+    data: number[];
+};
+
+/** B181–B190. Board cells use x=0..width-1, y=0 at the bottom; storage has stride 8.
+ * Configure cells once before start-board. Colors 1..colors; 0 is empty.
+ * Phases: 0 idle, 1 swapping, 2 clearing, 3 settling, 4 garbage, 5 converting.
+ * Clock is explicit monotonic integer milliseconds, 0..0xffffff, <=60000 per command.
+ * Frame stepping publishes events and processes physical contacts; it never advances this clock.
+ * Swaps/matches/collapse reject busy boards. Clearing keeps occupancy until its deadline.
+ * Only panels falling through holes from the previous credited clear continue a chain.
+ * Pauses suspend stack rise, not danger grace. Full top rows never silently disappear.
+ * Pinball balls require enabled centered solid dynamic spheres with CCD; flippers require
+ * CCD dynamic paddles and fixed anchors, aligned at the supplied local pivot (Z-axis hinge).
+ * Distances are meters, angles radians, impulses N·s, motor maxForce N·m.
+ * The host owns bodies and exclusive motion control; detach removes the owned joint.
+ * A plunger can launch up to eight distinct ball identities per attachment, once each.
+ * Bumpers require separation AND cooldown before another kick. Mode hits require actual
+ * solid contact with registered targets, in sequence, before an exclusive deadline.
+ * Mode phases: 0 ready, 1 active, 2 won, 3 failed; one mode attempt per attachment.
+ * Configure-once profiles and rejected commands never replenish or partially mutate state.
+ */
+declare const MATCHING_ABILITIES: readonly ["adjacent-panel-swap", "simultaneous-match-clear", "column-collapse", "cascade-chain-credit", "rising-stack-pressure", "garbage-block-conversion", "powered-pinball-flipper", "spring-plunger-launch", "active-bumper-kick", "pinball-mode-objectives"];
+declare const MATCHING_EVENTS: readonly ["adjacent-panel-swap", "simultaneous-match-clear", "column-collapse", "cascade-chain-credit", "rising-stack-pressure", "garbage-block-conversion", "powered-pinball-flipper", "spring-plunger-launch", "active-bumper-kick", "pinball-mode-objectives", "board-or-clock", "bumper-contact"];
+type MatchingAbility = (typeof MATCHING_ABILITIES)[number];
+type MatchingEvent = (typeof MATCHING_EVENTS)[number];
+interface MatchingOptions {
+    width?: number;
+    height?: number;
+    colors?: number;
+    swapMs?: number;
+    clearMs?: number;
+    settleMs?: number;
+    riseMs?: number;
+    dangerMs?: number;
+    chainWindowMs?: number;
+    seed?: number;
+    launchReach?: number;
+}
+/** Request IDs strictly increase in 1..0xffffff. Common setup and clock commands work
+ * in every standalone selection. All deadlines use the component clock, not wall time. */
+type MatchingAction<T = number> = {
+    requestId: number;
+} & ({
+    type: "swap";
+    x: number;
+    y: number;
+    toX: number;
+    toY: number;
+} | {
+    type: "match";
+} | {
+    type: "collapse";
+} | {
+    type: "chain-match";
+} | {
+    type: "chain-collapse";
+} | {
+    type: "pressure";
+} | {
+    type: "pause-rise";
+    duration: number;
+} | {
+    type: "garbage";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    region: number;
+} | {
+    type: "garbage-match";
+} | {
+    type: "flipper";
+    target: T;
+    pivotX: number;
+    pivotY: number;
+    pivotZ: number;
+    rest: number;
+    active: number;
+    stiffness: number;
+    damping: number;
+    maxForce: number;
+} | {
+    type: "flipper-input";
+    pressed: number;
+} | {
+    type: "stage-ball";
+    target: T;
+    directionX: number;
+    directionY: number;
+    directionZ: number;
+    maxImpulse: number;
+} | {
+    type: "pull";
+    amount: number;
+} | {
+    type: "launch";
+} | {
+    type: "cancel-launch";
+} | {
+    type: "bumper";
+    target: T;
+    impulse: number;
+    cooldown: number;
+    reward: number;
+} | {
+    type: "bumper-hit";
+} | {
+    type: "mode";
+    length: number;
+    duration: number;
+    reward: number;
+    target0: number;
+    target1: number;
+    target2: number;
+    target3: number;
+    target4: number;
+    target5: number;
+    target6: number;
+    target7: number;
+} | {
+    type: "mode-start";
+    target: T;
+} | {
+    type: "mode-hit";
+    target: T;
+    row: number;
+} | {
+    type: "mode-cancel";
+} | {
+    type: "cell";
+    x: number;
+    y: number;
+    color: number;
+} | {
+    type: "start-board";
+} | {
+    type: "clock";
+    timestamp: number;
+} | {
+    type: "mode-target";
+    target: T;
+    row: number;
+});
+interface MatchingCell {
+    color: number;
+    phase: number;
+    generation: number;
+    garbage: number;
+}
+interface MatchingState {
+    abilities: MatchingAbility[];
+    cells: MatchingCell[];
+    pattern: number[];
+    targets: boolean[];
+    lastRequest: number;
+    revision: number;
+    clock: number;
+    width: number;
+    height: number;
+    started: boolean;
+    chain: number;
+    score: number;
+    cleared: number;
+    lastMatch: number;
+    rows: number;
+    riseProgress: number;
+    dangerElapsed: number;
+    lost: boolean;
+    generation: number;
+    flipperConfigured: boolean;
+    flipperPressed: boolean;
+    flipperAngle: number;
+    charge: number;
+    staged: boolean;
+    launches: number;
+    bumperHits: number;
+    bumperReadyAt: number;
+    modePhase: number;
+    modeCursor: number;
+    modeDeadline: number;
+    wins: number;
+    patternLength: number;
+    pressure: boolean;
+    pauseUntil: number;
+    chainUntil: number;
+}
+declare function matchingData(o: MatchingOptions): number[];
+declare function matchingOperation<T>(a: MatchingAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B171–B180. Eight rows per table; 128 contexts. Calendar commands close exactly one day.
+ * Day 0 is weekday 0; seasons are floor(day / seasonLength) % 4. Masks select bits 0..3/0..6.
+ * Daily order: growth/care, calendar, withering, moisture decay + new-day rain, reward reset,
+ * fruit regrowth, routine. Frame stepping never advances the calendar or fishing clock.
+ * Plot phases: 0 empty, 1 growing, 2 ripe, 3 withered. Stages 0..2 grow; 3 is ripe.
+ * Animal care flags: 1 feed, 2 affection, 4 medicine. Product capacity is one per animal.
+ * Relationship kinds: 0 gift, 1 request, 2 offense. Rewards are once per kind/person/day;
+ * independent increasing event serials protect replay after the eight-entry history wraps.
+ * Fish phases: 0 idle, 1 waiting, 2 bite, 3 hooked, 4 lost. Integer millisecond timestamps
+ * are monotonic within this component. Hook interval is [biteAt, deadline); early reels lose.
+ * Water is an explicitly registered enabled sensor volume. A catch is a ledger increment;
+ * the host selects species and owns inventory/spawning. No engine types cross this API.
+ * Tree harvests issue one stack receipt; acknowledge a live nearby pickup or discard it.
+ * A bound live pickup blocks a new harvest. Host owns despawn/collection; regrowth is by day.
+ * Furniture uses a logical <=16x16 room, top-left cells and quarter-turn rotations 0..3.
+ * Hosts update optional colliders only after successful placement, using committed state.
+ * Commands are trusted host authority; configure-once profiles cannot replenish resources.
+ */
+declare const LIFE_ABILITIES: readonly ["crop-growth-stages", "soil-moisture-cycle", "seasonal-crop-eligibility", "exertion-and-fatigue", "livestock-daily-care", "calendar-npc-routine", "relationship-event-memory", "fishing-bite-and-hook", "harvestable-fruit-regrowth", "room-furniture-placement"];
+declare const LIFE_EVENTS: readonly ["crop-growth-stages", "soil-moisture-cycle", "seasonal-crop-eligibility", "exertion-and-fatigue", "livestock-daily-care", "calendar-npc-routine", "relationship-event-memory", "fishing-bite-and-hook", "harvestable-fruit-regrowth", "room-furniture-placement", "calendar-or-plot", "fishing-lost"];
+type LifeAbility = (typeof LIFE_ABILITIES)[number];
+type LifeEvent = (typeof LIFE_EVENTS)[number];
+interface LifeOptions {
+    day?: number;
+    seasonLength?: number;
+    stamina?: number;
+    reach?: number;
+    roomWidth?: number;
+    roomHeight?: number;
+}
+/** Request IDs strictly increase in 1..0xffffff. Rejected commands leave all state unchanged.
+ * Common calendar-time/day/plot/seed/clear commands are host setup and work in every standalone capability.
+ * Each context owns a calendar; broadcast the same day transaction to contexts in a world.
+ * Schedules return activity/destination only; a separate navigation behavior executes movement. */
+type LifeAction<T = number> = {
+    requestId: number;
+} & ({
+    type: "calendar-time";
+    minute: number;
+} | {
+    type: "plant";
+    row: number;
+} | {
+    type: "harvest-crop";
+    row: number;
+} | {
+    type: "clear-crop";
+    row: number;
+} | {
+    type: "water";
+    row: number;
+    amount: number;
+} | {
+    type: "season-plant";
+    row: number;
+} | {
+    type: "season-clear";
+    row: number;
+} | {
+    type: "work";
+    cost: number;
+    fatiguePerMissing: number;
+} | {
+    type: "recover";
+    stamina: number;
+    fatigue: number;
+} | {
+    type: "sleep";
+} | {
+    type: "animal";
+    row: number;
+    health: number;
+    affection: number;
+} | {
+    type: "care";
+    row: number;
+    flags: number;
+} | {
+    type: "collect-product";
+    row: number;
+} | {
+    type: "schedule";
+    row: number;
+    start: number;
+    end: number;
+    weekdays: number;
+    seasons: number;
+    activity: number;
+    x: number;
+    y: number;
+    z: number;
+    priority: number;
+} | {
+    type: "time";
+    minute: number;
+} | {
+    type: "routine-override";
+    activity: number;
+    x: number;
+    y: number;
+    z: number;
+    until: number;
+} | {
+    type: "routine-resume";
+} | {
+    type: "person";
+    row: number;
+    score: number;
+} | {
+    type: "interaction";
+    row: number;
+    eventSerial: number;
+    kind: number;
+    delta: number;
+} | {
+    type: "water-habitat";
+    target: T;
+    species: number;
+    seasons: number;
+    start: number;
+    end: number;
+    delay: number;
+    window: number;
+} | {
+    type: "cast";
+    x: number;
+    y: number;
+    z: number;
+    timestamp: number;
+    species: number;
+} | {
+    type: "reel";
+    timestamp: number;
+} | {
+    type: "fish-time";
+    timestamp: number;
+} | {
+    type: "tree";
+    target: T;
+    row: number;
+    capacity: number;
+    regrowDays: number;
+} | {
+    type: "harvest-fruit";
+    row: number;
+} | {
+    type: "fruit-confirm";
+    target: T;
+    row: number;
+    receipt: number;
+} | {
+    type: "fruit-discard";
+    row: number;
+    receipt: number;
+} | {
+    type: "furniture";
+    row: number;
+    width: number;
+    height: number;
+    score: number;
+    style: number;
+} | {
+    type: "place";
+    row: number;
+    x: number;
+    y: number;
+    rotation: number;
+} | {
+    type: "remove";
+    row: number;
+} | {
+    type: "room-block";
+    x: number;
+    y: number;
+    blocked: number;
+} | {
+    type: "day";
+    day: number;
+    rain: number;
+} | {
+    type: "plot";
+    row: number;
+    seasons: number;
+    stage0Days: number;
+    stage1Days: number;
+    stage2Days: number;
+    moistureRequired: number;
+    capacity: number;
+    decay: number;
+    moisture: number;
+    regrowDays: number;
+} | {
+    type: "seed-plot";
+    row: number;
+} | {
+    type: "clear-plot";
+    row: number;
+});
+interface LifePlot {
+    configured: boolean;
+    phase: number;
+    stage: number;
+    progress: number;
+    moisture: number;
+    seasons: number;
+    harvests: number;
+    capacity: number;
+    moistureRequired: number;
+    regrowDays: number;
+    regrowing: boolean;
+}
+interface LifeAnimal {
+    configured: boolean;
+    health: number;
+    affection: number;
+    care: number;
+    product: number;
+    collected: number;
+}
+interface LifePerson {
+    configured: boolean;
+    score: number;
+    eventSerial: number;
+    rewards: number;
+}
+interface LifeMemory {
+    eventSerial: number;
+    row: number;
+    kind: number;
+    delta: number;
+    day: number;
+}
+interface LifeTree {
+    configured: boolean;
+    fruit: number;
+    capacity: number;
+    due: number;
+    receipt: number;
+    pending: boolean;
+    bound: boolean;
+    x: number;
+    y: number;
+    z: number;
+    regrowDays: number;
+}
+interface LifeFurniture {
+    configured: boolean;
+    placed: boolean;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    rotation: number;
+    score: number;
+    style: number;
+}
+interface LifeSchedule {
+    configured: boolean;
+    start: number;
+    end: number;
+    weekdays: number;
+    seasons: number;
+    activity: number;
+    x: number;
+    y: number;
+    z: number;
+    priority: number;
+}
+interface LifeState {
+    lastRequest: number;
+    revision: number;
+    day: number;
+    season: number;
+    minute: number;
+    rain: number;
+    stamina: number;
+    fatigue: number;
+    route: number;
+    activity: number;
+    destinationX: number;
+    destinationY: number;
+    destinationZ: number;
+    overrideUntil: number;
+    roomScore: number;
+    fishPhase: number;
+    fishClock: number;
+    biteAt: number;
+    deadline: number;
+    catches: number;
+    castX: number;
+    castY: number;
+    castZ: number;
+    fruitSerial: number;
+    memoryCount: number;
+    roomWidth: number;
+    roomHeight: number;
+    slept: boolean;
+    abilities: LifeAbility[];
+    blocked: boolean[];
+    plots: LifePlot[];
+    animals: LifeAnimal[];
+    people: LifePerson[];
+    memories: LifeMemory[];
+    trees: LifeTree[];
+    furniture: LifeFurniture[];
+    schedules: LifeSchedule[];
+}
+declare function lifeData(o: LifeOptions): number[];
+declare function lifeOperation<T>(a: LifeAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B161–B170. Eight retained target rows, eight resource/wave/tile slots, four cards, three armor layers.
+ * Lanes 0..4 run along world X. Direction is -1 or +1; positions must agree with authored lane IDs.
+ * Target kinds: 0 enemy, 1 blocker. Flags: 1 targetable/edible, 2 vaultable, 4 ordinary burrow blocker.
+ * Moving owners and deployment bodies: enabled position-kinematic solid centered spheres.
+ * Burrow uses phase-scoped query exclusions for registered static/kinematic ordinary blockers;
+ * visual underground depth is presentation. Body/collider settings are never changed.
+ * Hosts must give this family exclusive motion authority and own spawn/despawn/health replication.
+ * Receipt phases: 0 free/retired, 1 requested, 2 bound/active. Host acknowledges real live entities.
+ * Mine: 0 new, 1 arming, 2 armed, 3 spent. Wave: 0 idle, 1 issuing, 2 draining, 3 complete.
+ * Vault: 0 unused, 1 airborne, 2 landed, 3 blocked/interrupted, 4 unsupported.
+ * Burrow: 0 unused, 1 underground, 2 emerging, 3 surface. Sweeper: 0 new, 1 armed, 2 active, 3 spent.
+ * Tiles: 0 free, 1 reserved (cost held), 2 occupied. Confirmation starts card cooldown;
+ * cancellation refunds once. Target rows cannot be reused until detach. Query references are one-based.
+ */
+declare const DEFENSE_ABILITIES: readonly ["lane-target-acquisition", "blocker-chew-transition", "layered-breakaway-armor", "arming-proximity-mine", "periodic-resource-production", "budgeted-wave-scheduler", "single-use-obstacle-vault", "burrow-to-backline", "costed-grid-deployment", "last-chance-lane-sweeper"];
+declare const DEFENSE_EVENTS: readonly ["lane-target-acquisition", "blocker-chew-transition", "layered-breakaway-armor", "arming-proximity-mine", "periodic-resource-production", "budgeted-wave-scheduler", "single-use-obstacle-vault", "burrow-to-backline", "costed-grid-deployment", "last-chance-lane-sweeper", "host-update", "armor-break", "body-damage", "target-damage", "mine-detonated", "resource-requested", "spawn-requested", "wave-complete", "vault-ended", "burrow-emerged", "sweep-ended"];
+type DefenseAbility = (typeof DEFENSE_ABILITIES)[number];
+type DefenseEvent = (typeof DEFENSE_EVENTS)[number];
+interface DefenseOptions {
+    lane?: number;
+    direction?: number;
+    speed?: number;
+    reach?: number;
+    resources?: number;
+    health?: number;
+}
+/** Request IDs strictly increase in 1..0xffffff; rejects are atomic. Setup and credits are trusted host authority.
+ * Damage/credit/wave serials also increase independently. Bind/collect/confirm consume exact receipts.
+ * Target damage updates this component's ledger and emits receipts for host health/despawn integration.
+ * Profile edits cannot replenish damaged armor or reset an active card cooldown. */
+type DefenseAction<T = number> = {
+    requestId: number;
+} & ({
+    type: "targeting-start";
+    range: number;
+    damage: number;
+    interval: number;
+} | {
+    type: "targeting-stop";
+} | {
+    type: "advance";
+    damage: number;
+    interval: number;
+} | {
+    type: "halt";
+} | {
+    type: "armor-layer";
+    layer: number;
+    health: number;
+    damageMask: number;
+} | {
+    type: "damage";
+    damageSerial: number;
+    amount: number;
+    damageMask: number;
+} | {
+    type: "mine-prepare";
+    delay: number;
+    radius: number;
+    damage: number;
+} | {
+    type: "production-start";
+    interval: number;
+    value: number;
+    capacity: number;
+} | {
+    type: "resource-bind";
+    target: T;
+    receipt: number;
+} | {
+    type: "resource-collect";
+    target: T;
+    receipt: number;
+} | {
+    type: "resource-expire";
+    receipt: number;
+} | {
+    type: "wave-start";
+    waveSerial: number;
+    budget: number;
+    cost: number;
+    laneMask: number;
+    interval: number;
+    activeLimit: number;
+} | {
+    type: "spawn-confirm";
+    target: T;
+    receipt: number;
+} | {
+    type: "spawn-retire";
+    target: T;
+    receipt: number;
+} | {
+    type: "spawn-cancel";
+    receipt: number;
+} | {
+    type: "vault";
+    row: number;
+    landingDistance: number;
+    height: number;
+    duration: number;
+    postSpeed: number;
+} | {
+    type: "burrow";
+    destinationX: number;
+    emergeDelay: number;
+} | {
+    type: "tile";
+    row: number;
+    terrainMask: number;
+    x: number;
+    y: number;
+    z: number;
+} | {
+    type: "card";
+    row: number;
+    cost: number;
+    cooldown: number;
+    terrainMask: number;
+} | {
+    type: "deployment-request";
+    tile: number;
+    card: number;
+} | {
+    type: "deployment-confirm";
+    target: T;
+    receipt: number;
+} | {
+    type: "deployment-cancel";
+    receipt: number;
+} | {
+    type: "sweeper-arm";
+    destinationX: number;
+    speed: number;
+    triggerRadius: number;
+    hitRadius: number;
+} | {
+    type: "target";
+    target: T;
+    row: number;
+    kind: number;
+    lane: number;
+    health: number;
+    flags: number;
+} | {
+    type: "target-health";
+    row: number;
+    health: number;
+} | {
+    type: "credit";
+    creditSerial: number;
+    amount: number;
+} | {
+    type: "interrupt";
+});
+interface DefenseTarget {
+    present: boolean;
+    kind: number;
+    lane: number;
+    health: number;
+    flags: number;
+    x: number;
+    y: number;
+    z: number;
+}
+interface DefenseReceipt {
+    receipt: number;
+    phase: number;
+    value: number;
+    lane: number;
+    bound: boolean;
+}
+interface DefenseTile {
+    configured: boolean;
+    terrainMask: number;
+    x: number;
+    y: number;
+    z: number;
+    phase: number;
+    receipt: number;
+    card: number;
+    cost: number;
+    bound: boolean;
+}
+interface DefenseState {
+    lastRequest: number;
+    revision: number;
+    bank: number;
+    health: number;
+    direction: number;
+    speed: number;
+    blocked: number;
+    selected: number;
+    shots: number;
+    chewed: number;
+    bites: number;
+    breaks: number;
+    damageSerial: number;
+    firing: boolean;
+    advancing: boolean;
+    minePhase: number;
+    mineRemaining: number;
+    detonations: number;
+    producing: boolean;
+    productionClock: number;
+    resourceSerial: number;
+    collected: number;
+    wavePhase: number;
+    waveSerial: number;
+    budget: number;
+    spawnSerial: number;
+    spawnCount: number;
+    deploymentSerial: number;
+    sweepPhase: number;
+    sweepHits: number;
+    outstandingResources: number;
+    x: number;
+    y: number;
+    z: number;
+    vaultUsed: boolean;
+    vaultPhase: number;
+    vaultTime: number;
+    vaultDuration: number;
+    burrowPhase: number;
+    burrowGoal: number;
+    emergeRemaining: number;
+    sweepEnd: number;
+    activeSpawns: number;
+    shotClock: number;
+    chewClock: number;
+    waveClock: number;
+    creditSerial: number;
+    abilities: DefenseAbility[];
+    targets: DefenseTarget[];
+    resources: DefenseReceipt[];
+    spawns: DefenseReceipt[];
+    tiles: DefenseTile[];
+    cards: {
+        configured: boolean;
+        cost: number;
+        remaining: number;
+        terrainMask: number;
+    }[];
+    armor: {
+        health: number;
+        damageMask: number;
+    }[];
+}
+declare function defenseData(o: DefenseOptions): number[];
+declare function defenseOperation<T>(a: DefenseAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B151–B160. Original bounded squad policies; eight workers, four tasks/species, three growth stages.
+ * Workers and payloads must be enabled position-kinematic bodies with one centered solid sphere.
+ * Squad owns their motion until released/detached: do not combine with another movement controller.
+ * Rows are zero-based; query task/landing/base references are one-based (zero means none).
+ * Task kinds: 0 payload, 1 worksite, 2 enemy, 3 base. Commands use 4 for no landing task/base.
+ * Modes: 0 idle, 1 follow, 2 airborne, 3 carry, 4 work, 5 latch, 6 panic, 7 safe, 8 lost.
+ * Task phases: 0 active, 1 arrived/complete, 2 consumed/dead, 3 removed.
+ * Flight results: 0 pending, 1 supported, 2 blocked, 3 unsupported.
+ * Hosts supply hazards, navigation destinations, health and spawn/despawn from receipts.
+ * Queries expose cached poses refreshed by accepted commands and simulation steps. */
+declare const SQUAD_ABILITIES: readonly ["whistle-recall", "squad-formation-follow", "thrown-worker-deployment", "cooperative-object-transport", "cooperative-construction-work", "surface-latch-attack", "species-hazard-affinity", "growth-stage-mobility", "delivered-resource-conversion", "day-end-unit-recall"];
+declare const SQUAD_EVENTS: readonly ["whistle-recall", "squad-formation-follow", "thrown-worker-deployment", "cooperative-object-transport", "cooperative-construction-work", "surface-latch-attack", "species-hazard-affinity", "growth-stage-mobility", "delivered-resource-conversion", "day-end-unit-recall", "host-update", "worker-landed", "task-complete", "latch-hit", "worker-lost", "day-resolved"];
+type SquadAbility = (typeof SQUAD_ABILITIES)[number];
+type SquadEvent = (typeof SQUAD_EVENTS)[number];
+interface SquadOptions {
+    speed?: number;
+    reach?: number;
+    separation?: number;
+    gravity?: number;
+    attackInterval?: number;
+}
+/** Accepted request IDs strictly increase in 1..0xffffff; rejected commands do not mutate state.
+ * Setup/profile/health/protection/credit commands are trusted host authority.
+ * Each worker/task body is exclusively claimed by one squad; rows are never reused until detach.
+ * Delivery consumes a payload receipt once; deploy/retire update credits, never spawn ECS entities.
+ * A resolved day accepts only a new day-start; lost workers stay lost. */
+type SquadAction<T = number> = {
+    requestId: number;
+} & ({
+    type: "whistle-start";
+    maximumRadius: number;
+    rate: number;
+    duration: number;
+} | {
+    type: "whistle-stop";
+} | {
+    type: "formation-slot";
+    row: number;
+    x: number;
+    y: number;
+    z: number;
+} | {
+    type: "follow";
+    row: number;
+} | {
+    type: "dismiss";
+    row: number;
+} | {
+    type: "throw";
+    row: number;
+    x: number;
+    y: number;
+    z: number;
+    duration: number;
+    landingTask: number;
+} | {
+    type: "assign-carrier";
+    row: number;
+    task: number;
+} | {
+    type: "payload-route";
+    task: number;
+    x: number;
+    y: number;
+    z: number;
+    speed: number;
+} | {
+    type: "release-carrier";
+    row: number;
+} | {
+    type: "assign-work";
+    row: number;
+    task: number;
+} | {
+    type: "stop-work";
+    row: number;
+} | {
+    type: "latch";
+    row: number;
+    task: number;
+    x: number;
+    y: number;
+    z: number;
+} | {
+    type: "shake";
+    task: number;
+    speciesMask: number;
+} | {
+    type: "unlatch";
+    row: number;
+} | {
+    type: "affinity";
+    species: number;
+    immuneMask: number;
+    rescueMask: number;
+    panicDuration: number;
+} | {
+    type: "expose";
+    row: number;
+    hazard: number;
+} | {
+    type: "rescue";
+    rescuer: number;
+    victim: number;
+} | {
+    type: "growth-profile";
+    stage: number;
+    speed: number;
+    work: number;
+} | {
+    type: "grow";
+    row: number;
+    stage: number;
+    growthReceipt: number;
+} | {
+    type: "base-profile";
+    task: number;
+    populationCapacity: number;
+    activeLimit: number;
+} | {
+    type: "deliver";
+    payload: number;
+    base: number;
+    deliverySerial: number;
+} | {
+    type: "deploy";
+    base: number;
+    count: number;
+    spawnSerial: number;
+} | {
+    type: "retire";
+    base: number;
+    count: number;
+    spawnSerial: number;
+} | {
+    type: "day-start";
+    daySerial: number;
+    duration: number;
+    base: number;
+    safeRadius: number;
+} | {
+    type: "protect";
+    row: number;
+    protected: boolean;
+} | {
+    type: "worker";
+    target: T;
+    row: number;
+    species: number;
+    growth: number;
+    workRate: number;
+    strength: number;
+    damage: number;
+    recallable: boolean;
+} | {
+    type: "task";
+    target: T;
+    row: number;
+    kind: number;
+    required: number;
+    capacity: number;
+    value: number;
+} | {
+    type: "release-worker";
+    row: number;
+} | {
+    type: "target-health";
+    task: number;
+    health: number;
+});
+interface SquadWorker {
+    present: boolean;
+    mode: number;
+    species: number;
+    growth: number;
+    task: number;
+    speed: number;
+    workRate: number;
+    strength: number;
+    damage: number;
+    recallable: boolean;
+    protected: boolean;
+    hazard: number;
+    panicRemaining: number;
+    flightResult: number;
+    growthReceipt: number;
+    lossReceipt: number;
+    x: number;
+    y: number;
+    z: number;
+    goalX: number;
+    goalY: number;
+    goalZ: number;
+    slotX: number;
+    slotY: number;
+    slotZ: number;
+    flightTime: number;
+    flightDuration: number;
+    attackClock: number;
+    dealt: number;
+    landedTask: number;
+}
+interface SquadTask {
+    present: boolean;
+    kind: number;
+    phase: number;
+    required: number;
+    progress: number;
+    capacity: number;
+    value: number;
+    health: number;
+    stored: number;
+    active: number;
+    populationCapacity: number;
+    activeLimit: number;
+    receipt: number;
+    assigned: number;
+    strength: number;
+    speed: number;
+    x: number;
+    y: number;
+    z: number;
+    destinationX: number;
+    destinationY: number;
+    destinationZ: number;
+    routed: boolean;
+}
+interface SquadState {
+    lastRequest: number;
+    revision: number;
+    whistling: boolean;
+    radius: number;
+    maximumRadius: number;
+    recalls: number;
+    flightSerial: number;
+    completed: number;
+    hitSerial: number;
+    lossSerial: number;
+    deliverySerial: number;
+    spawnSerial: number;
+    daySerial: number;
+    dayPhase: number;
+    dayRemaining: number;
+    dayBase: number;
+    safeRadius: number;
+    safe: number;
+    lost: number;
+    blocked: number;
+    abilities: SquadAbility[];
+    workers: SquadWorker[];
+    tasks: SquadTask[];
+    growth: {
+        speed: number;
+        work: number;
+    }[];
+    affinities: {
+        immuneMask: number;
+        rescueMask: number;
+        panicDuration: number;
+    }[];
+}
+declare function squadData(o: SquadOptions): number[];
+declare function squadOperation<T>(a: SquadAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B141–B150. Original configurable grid policies. Coordinates and rules are host-authored.
+ * Eight units, eight structures, four teams/classes/weapons, eight terrain types, at most 8×8 cells.
+ * Queries use zero-based rows except explicit 1-based references (zero means none).
+ * Physics supplies lifetime only; the host maps committed grid coordinates to world poses. */
+declare const TACTICS_ABILITIES: readonly ["terrain-movement-budget", "min-max-attack-range", "terrain-defense-modifier", "counterattack-and-follow-up", "weapon-advantage-cycle", "persistent-unit-loss", "progressive-building-capture", "fuel-ammunition-resupply", "transport-load-unload", "commander-power-window"];
+declare const TACTICS_EVENTS: readonly ["terrain-movement-budget", "min-max-attack-range", "terrain-defense-modifier", "counterattack-and-follow-up", "weapon-advantage-cycle", "persistent-unit-loss", "progressive-building-capture", "fuel-ammunition-resupply", "transport-load-unload", "commander-power-window", "host-update"];
+type TacticsAbility = (typeof TACTICS_ABILITIES)[number];
+type TacticsEvent = (typeof TACTICS_EVENTS)[number];
+interface TacticsOptions {
+    width?: number;
+    height?: number;
+    followUpSpeedThreshold?: number;
+    captureStrength?: number;
+    maximumFuel?: number;
+    maximumAmmo?: number;
+}
+/** Accepted request IDs strictly increase in 1..0xffffff; rejected commands are atomic.
+ * Setup/stat/turn/charge/resource inputs are trusted host authority, not client validation.
+ * During an exchange only next/cancel/defeat/host-health commands are accepted. */
+type TacticsAction<T = number> = {
+    requestId: number;
+} & ({
+    type: "movement-cost";
+    unitClass: number;
+    terrain: number;
+    cost: number;
+} | {
+    type: "reachable";
+    row: number;
+} | {
+    type: "move";
+    row: number;
+    x: number;
+    y: number;
+} | {
+    type: "weapon-range";
+    row: number;
+    minimum: number;
+    maximum: number;
+    lineOfSight: boolean;
+} | {
+    type: "range-map";
+    row: number;
+} | {
+    type: "check-range";
+    attacker: number;
+    defender: number;
+} | {
+    type: "terrain-profile";
+    unitClass: number;
+    terrain: number;
+    defense: number;
+    avoid: number;
+    recovery: number;
+} | {
+    type: "terrain-evaluate";
+    row: number;
+    raw: number;
+    seed: number;
+} | {
+    type: "terrain-recover";
+    row: number;
+} | {
+    type: "combat-start";
+    attacker: number;
+    defender: number;
+    combatSerial: number;
+    seed: number;
+} | {
+    type: "combat-next";
+} | {
+    type: "combat-cancel";
+} | {
+    type: "weapon-durability";
+    row: number;
+    durability: number;
+} | {
+    type: "advantage-row";
+    attackerWeapon: number;
+    defenderWeapon: number;
+    damage: number;
+    hit: number;
+} | {
+    type: "evaluate-advantage";
+    attacker: number;
+    defender: number;
+} | {
+    type: "defeat";
+    row: number;
+} | {
+    type: "loss-exception";
+    row: number;
+    exempt: boolean;
+} | {
+    type: "recover";
+    row: number;
+    health: number;
+} | {
+    type: "capture-building";
+    row: number;
+    structure: number;
+} | {
+    type: "supply-profile";
+    row: number;
+    classMask: number;
+} | {
+    type: "spend-resources";
+    row: number;
+    fuel: number;
+    ammo: number;
+    resourceSerial: number;
+} | {
+    type: "resupply-unit";
+    supplier: number;
+    recipient: number;
+    fuel: number;
+    ammo: number;
+} | {
+    type: "resupply-facility";
+    row: number;
+    structure: number;
+    fuel: number;
+    ammo: number;
+} | {
+    type: "transport-profile";
+    row: number;
+    capacity: number;
+    classMask: number;
+    size: number;
+} | {
+    type: "load";
+    carrier: number;
+    cargo: number;
+} | {
+    type: "unload";
+    carrier: number;
+    cargo: number;
+    x: number;
+    y: number;
+} | {
+    type: "power-profile";
+    team: number;
+    threshold: number;
+    duration: number;
+    attack: number;
+    defense: number;
+    movement: number;
+} | {
+    type: "power-charge";
+    team: number;
+    amount: number;
+    chargeSerial: number;
+} | {
+    type: "power-activate";
+    team: number;
+} | {
+    type: "power-cancel";
+    team: number;
+} | {
+    type: "unit";
+    target: T;
+    row: number;
+    x: number;
+    y: number;
+    team: number;
+    unitClass: number;
+    health: number;
+    maximumHealth: number;
+    movement: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    weapon: number;
+    minimumRange: number;
+    maximumRange: number;
+    fuel: number;
+    ammo: number;
+} | {
+    type: "tile";
+    x: number;
+    y: number;
+    terrain: number;
+    blocked: boolean;
+} | {
+    type: "begin-turn";
+    phase: number;
+    team: number;
+} | {
+    type: "structure";
+    row: number;
+    x: number;
+    y: number;
+    owner: number;
+    maximumCapture: number;
+    fuel: number;
+    ammo: number;
+    classMask: number;
+} | {
+    type: "host-health";
+    row: number;
+    health: number;
+});
+interface TacticsUnit {
+    present: boolean;
+    x: number;
+    y: number;
+    team: number;
+    unitClass: number;
+    health: number;
+    maximumHealth: number;
+    movementRemaining: number;
+    attack: number;
+    defense: number;
+    speed: number;
+    weapon: number;
+    minimumRange: number;
+    maximumRange: number;
+    fuel: number;
+    ammo: number;
+    loss: number;
+    lossSerial: number;
+    exempt: boolean;
+    carrier: number;
+    size: number;
+    capacity: number;
+    cargoMask: number;
+    supplyMask: number;
+    durability: number;
+    acted: boolean;
+    spent: number;
+    resourceSerial: number;
+    healPhase: number;
+    maximumFuel: number;
+    maximumAmmo: number;
+    lineOfSight: boolean;
+}
+interface TacticsStructure {
+    present: boolean;
+    x: number;
+    y: number;
+    owner: number;
+    progress: number;
+    maximum: number;
+    fuel: number;
+    ammo: number;
+}
+interface TacticsPower {
+    charge: number;
+    threshold: number;
+    duration: number;
+    active: boolean;
+    remainingTurns: number;
+    attack: number;
+    defense: number;
+    movement: number;
+    chargeSerial: number;
+    turns: number;
+}
+interface TacticsState {
+    lastRequest: number;
+    revision: number;
+    width: number;
+    height: number;
+    phase: number;
+    team: number;
+    movementUnit: number;
+    rangeUnit: number;
+    rangeAllowed: boolean;
+    rangeDistance: number;
+    terrainDefense: number;
+    terrainAvoid: number;
+    healed: number;
+    previewDamage: number;
+    lastCost: number;
+    combatSerial: number;
+    combatPhase: number;
+    cursor: number;
+    strikeCount: number;
+    lastAttacker: number;
+    lastDefender: number;
+    damage: number;
+    hit: boolean;
+    lossSerial: number;
+    captureSerial: number;
+    supplySerial: number;
+    transportSerial: number;
+    advantageDamage: number;
+    advantageHit: number;
+    powerSerial: number;
+    abilities: TacticsAbility[];
+    units: TacticsUnit[];
+    structures: TacticsStructure[];
+    powers: TacticsPower[];
+    cells: TacticsCell[];
+}
+interface TacticsCell {
+    x: number;
+    y: number;
+    terrain: number;
+    blocked: boolean;
+    occupant: number;
+    structure: number;
+    inRange: boolean;
+    cost: number;
+}
+declare function tacticsData(o: TacticsOptions): number[];
+declare function tacticsOperation<T>(a: TacticsAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B131–B140. Host-authoritative battle inputs and simulation-time judgment. */
+declare const BATTLE_ABILITIES: readonly ["priority-speed-turn-order", "type-effectiveness-matrix", "turn-duration-status", "capture-attempt-resolution", "conditional-evolution", "timed-battle-action-command", "active-partner-swap", "budgeted-passive-loadout", "field-first-strike", "escape-attempt"];
+declare const BATTLE_EVENTS: readonly ["priority-speed-turn-order", "type-effectiveness-matrix", "turn-duration-status", "capture-attempt-resolution", "conditional-evolution", "timed-battle-action-command", "active-partner-swap", "budgeted-passive-loadout", "field-first-strike", "escape-attempt", "action-command-timeout"];
+type BattleEvent = (typeof BATTLE_EVENTS)[number];
+type BattleAbility = (typeof BATTLE_ABILITIES)[number];
+type BattleTriple = readonly [number, number, number];
+type BattleFour = readonly [number, number, number, number];
+type BattleEight = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+interface BattleOptions {
+    swapCost?: number;
+    actionPoints?: number;
+    passiveBudget?: number;
+    captureItems?: number;
+    escapeCost?: number;
+    escapeBaseChance?: number;
+    escapeRetryBonus?: number;
+}
+/** Successful requests strictly increase in 1..0xffffff. Rejections are atomic.
+ * Targets are live handles. Registration, stats, eligibility and budgets are trusted host inputs.
+ * Terminal outcomes emit receipts; the host applies ownership, inventory and encounter transitions once. */
+type BattleAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'queue-action';
+    target: T;
+    row: number;
+    actionId: number;
+    priority: number;
+    speed: number;
+    tieKey: number;
+} | {
+    type: 'freeze-order';
+    turn: number;
+} | {
+    type: 'next-action';
+} | {
+    type: 'clear-order';
+} | {
+    type: 'type-row';
+    attackType: number;
+    defenderType: number;
+    multiplier: number;
+} | {
+    type: 'resolve-type';
+    attackType: number;
+    defenderType: number;
+    secondType?: number;
+    raw: number;
+    damageSerial: number;
+} | {
+    type: 'status-apply';
+    id: number;
+    turns: number;
+    phaseMask: 1 | 2 | 3;
+    restrict: boolean;
+    amount: number;
+} | {
+    type: 'status-phase';
+    turn: number;
+    phase: 0 | 1;
+} | {
+    type: 'status-remove';
+    id: number;
+} | {
+    type: 'capture';
+    target: T;
+    attemptSerial: number;
+    seed: number;
+    health: number;
+    maximumHealth: number;
+    catchRate: number;
+    itemBonus: number;
+    statusBonus: number;
+    eligible: boolean;
+    itemId: number;
+} | {
+    type: 'capture-stock';
+    count: number;
+} | {
+    type: 'creature';
+    species: number;
+    level: number;
+    friendship: number;
+    stats: BattleTriple;
+    moves: BattleFour;
+} | {
+    type: 'evolution-rule';
+    row: number;
+    from: number;
+    to: number;
+    level: number;
+    item: number;
+    friendship: number;
+    context: number;
+    stats: BattleTriple;
+    keepMovesMask: number;
+} | {
+    type: 'evolve';
+    evolutionSerial: number;
+    item: number;
+    context: number;
+} | {
+    type: 'creature-progress';
+    level: number;
+    friendship: number;
+} | {
+    type: 'timing-start';
+    moveSerial: number;
+    count: number;
+    window: number;
+    bonus: number;
+    times: BattleFour;
+    buttons: BattleFour;
+} | {
+    type: 'timing-input';
+    button: number;
+    timestamp: number;
+} | {
+    type: 'timing-finish';
+} | {
+    type: 'partner-register';
+    target: T;
+    row: number;
+    health: number;
+    maximumHealth: number;
+} | {
+    type: 'partner-swap';
+    row: number;
+} | {
+    type: 'partner-health';
+    row: number;
+    health: number;
+} | {
+    type: 'partner-turn';
+    turn: number;
+    points: number;
+} | {
+    type: 'passive-row';
+    row: number;
+    id: number;
+    cost: number;
+    group: number;
+    stat: 0 | 1 | 2;
+    amount: number;
+    maximumStacks: number;
+} | {
+    type: 'passive-equip';
+    counts: BattleEight;
+} | {
+    type: 'passive-budget';
+    budget: number;
+} | {
+    type: 'passive-clear';
+} | {
+    type: 'field-contact';
+    target: T;
+    side: 0 | 1 | 2;
+    attackId: number;
+} | {
+    type: 'opening-transfer';
+    encounterSerial: number;
+} | {
+    type: 'escape';
+    seed: number;
+    speed: number;
+    enemySpeed: number;
+    eligible: boolean;
+} | {
+    type: 'escape-turn';
+    turn: number;
+    points: number;
+} | {
+    type: 'battle-end';
+    outcome: 3 | 4;
+});
+interface BattleState {
+    abilities: BattleAbility[];
+    lastRequest: number;
+    revision: number;
+    outcome: number;
+    points: number;
+    budgetTurn: number;
+    turn: number;
+    frozen: boolean;
+    orderCount: number;
+    cursor: number;
+    lastAction: number;
+    canceled: number;
+    typeSerial: number;
+    multiplier: number;
+    damage: number;
+    reaction: number;
+    hook: number;
+    tickAmount: number;
+    blocked: boolean;
+    captureSerial: number;
+    captureResult: number;
+    captureChance: number;
+    captureRoll: number;
+    captureStock: number;
+    captureItem: number;
+    species: number;
+    level: number;
+    friendship: number;
+    evolutionSerial: number;
+    usedItem: number;
+    stats: BattleTriple;
+    moves: BattleFour;
+    moveSerial: number;
+    timingPhase: number;
+    clock: number;
+    inputCount: number;
+    inputNext: number;
+    hits: number;
+    quality: number;
+    actionMultiplier: number;
+    window: number;
+    times: BattleFour;
+    buttons: BattleFour;
+    /** Active partner is a 1-based roster index; zero means none. */
+    activePartner: number;
+    swapSerial: number;
+    passiveBudget: number;
+    spent: number;
+    modifiers: BattleTriple;
+    bonus: number;
+    openingPhase: number;
+    openingSide: number;
+    openingAttack: number;
+    openingSerial: number;
+    escapeAttempts: number;
+    escapeResult: number;
+    escapeChance: number;
+    escapeRoll: number;
+    order: number[];
+    queued: boolean[];
+    partnerHealth: number[];
+    partnerMaximum: number[];
+    passiveCounts: number[];
+    passiveIds: number[];
+    statusIds: number[];
+    statusTurns: number[];
+    statusAmounts: number[];
+    statusPhases: number[];
+    typeMatrix: number[];
+}
+declare function battleData(o: BattleOptions): number[];
+declare function battleOperation<T>(a: BattleAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B121–B130. Host-authoritative inventory inputs; world metres and simulation seconds. */
+declare const RPG_ABILITIES: readonly ["equipment-stat-aggregation", "durability-and-repair", "affix-budget-generation", "death-drop-ownership", "consumable-belt-slots", "seeded-loot-table", "damage-to-resource-leech", "typed-resistance-resolution", "autonomous-familiar", "resource-draining-transformation"];
+declare const RPG_EVENTS: readonly ["equipment-stat-aggregation", "durability-and-repair", "affix-budget-generation", "death-drop-ownership", "consumable-belt-slots", "seeded-loot-table", "damage-to-resource-leech", "typed-resistance-resolution", "autonomous-familiar", "resource-draining-transformation", "familiar-attack", "familiar-support"];
+type RpgEvent = (typeof RPG_EVENTS)[number];
+type RpgAbility = (typeof RPG_ABILITIES)[number];
+type RpgPoint = readonly [number, number, number];
+interface RpgOptions {
+    strength?: number;
+    defense?: number;
+    speed?: number;
+    maximumHealth?: number;
+    maximumMana?: number;
+    currency?: number;
+    repairUnitCost?: number;
+    pickupRange?: number;
+    reservationSeconds?: number;
+    followDistance?: number;
+    familiarSpeed?: number;
+    actionRange?: number;
+    actionCooldown?: number;
+    leashRange?: number;
+    maximumDrain?: number;
+    maximumRadius?: number;
+}
+/** Request IDs strictly increase (1..0xffffff). Invalid commands are atomic.
+ * Item targets are live entity handles, uniquely claimed within the RPG registry.
+ * Authored data/notifications must come from the host's authoritative inventory/combat system. */
+type RpgAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'equipment-register';
+    target: T;
+    slotMask: number;
+    requiredStrength: number;
+    flat: RpgPoint;
+    percent: RpgPoint;
+} | {
+    type: 'equip';
+    target: T;
+    slot: 0 | 1 | 2 | 3;
+} | {
+    type: 'unequip';
+    slot: 0 | 1 | 2 | 3;
+} | {
+    type: 'base-stats';
+    values: RpgPoint;
+} | {
+    type: 'durability-register';
+    target: T;
+    current: number;
+    maximum: number;
+} | {
+    type: 'wear';
+    target: T;
+    amount: number;
+    useSerial: number;
+} | {
+    type: 'repair';
+    target: T;
+    amount: number;
+} | {
+    type: 'wallet';
+    currency: number;
+} | {
+    type: 'affix-row';
+    row: number;
+    id: number;
+    cost: number;
+    level: number;
+    classMask: number;
+    group: number;
+    stat: 0 | 1 | 2;
+    amount: number;
+    weight: number;
+} | {
+    type: 'affix-roll';
+    seed: number;
+    level: number;
+    itemClass: number;
+    budget: number;
+    count: number;
+} | {
+    type: 'affix-clear';
+} | {
+    type: 'drop-public';
+    itemType: number;
+    rarity: number;
+} | {
+    type: 'drop-reserve';
+    target: T;
+    itemType: number;
+    rarity: number;
+} | {
+    type: 'death-drop';
+    deathSerial: number;
+    lootSerial: number;
+    affixSerial: number;
+} | {
+    type: 'drop-pickup';
+    target: T;
+} | {
+    type: 'belt-stock';
+    target: T;
+    slot: 0 | 1 | 2 | 3;
+    count: number;
+    kind: 1 | 2;
+    potency: number;
+} | {
+    type: 'belt-use';
+    slot: 0 | 1 | 2 | 3;
+} | {
+    type: 'belt-move';
+    from: 0 | 1 | 2 | 3;
+    to: 0 | 1 | 2 | 3;
+} | {
+    type: 'belt-resources';
+    health: number;
+    mana: number;
+} | {
+    type: 'loot-row';
+    row: number;
+    itemType: number;
+    weight: number;
+    level: number;
+    rarity: number;
+} | {
+    type: 'loot-roll';
+    seed: number;
+    level: number;
+} | {
+    type: 'loot-clear';
+} | {
+    type: 'leech-rates';
+    health: number;
+    mana: number;
+} | {
+    type: 'leech';
+    damage: number;
+    damageSerial: number;
+    flags: number;
+} | {
+    type: 'leech-resources';
+    health: number;
+    mana: number;
+} | {
+    type: 'resistance';
+    damageType: 0 | 1 | 2 | 3;
+    resistance: number;
+    immune: boolean;
+} | {
+    type: 'resolve-damage';
+    raw: number;
+    damageType: 0 | 1 | 2 | 3;
+    damageSerial: number;
+    flags: number;
+    availableHealth: number;
+} | {
+    type: 'familiar-bind';
+    target: T;
+    role: 0 | 1;
+} | {
+    type: 'familiar-candidate';
+    target: T;
+} | {
+    type: 'familiar-stop';
+} | {
+    type: 'familiar-remove';
+    target: T;
+} | {
+    type: 'transform';
+    form: 1 | 2;
+    radius: number;
+    drain: number;
+    speed: number;
+} | {
+    type: 'revert';
+} | {
+    type: 'form-mana';
+    mana: number;
+});
+interface RpgItem {
+    owned: boolean;
+    equipment: boolean;
+    slotMask: number;
+    requiredStrength: number;
+    flat: RpgPoint;
+    percent: RpgPoint;
+    durability: number;
+    maximumDurability: number;
+    count: number;
+    kind: number;
+    potency: number;
+    lastWear: number;
+}
+interface RpgAffix {
+    id: number;
+    stat: number;
+    amount: number;
+    cost: number;
+}
+interface RpgState {
+    abilities: RpgAbility[];
+    lastRequest: number;
+    revision: number;
+    base: RpgPoint;
+    derived: RpgPoint;
+    health: number;
+    mana: number;
+    currency: number;
+    repairCost: number;
+    beltSerial: number;
+    healthGained: number;
+    manaGained: number;
+    affixSerial: number;
+    affixCount: number;
+    affixSpent: number;
+    affixSeed: number;
+    lootSerial: number;
+    lootType: number;
+    lootRarity: number;
+    lootSeed: number;
+    dropPhase: number;
+    deathSerial: number;
+    dropType: number;
+    dropRarity: number;
+    reservation: number;
+    dropAffixCount: number;
+    leechSerial: number;
+    damageSerial: number;
+    damage: number;
+    damageType: number;
+    damageFlags: number;
+    reaction: number;
+    familiarPhase: number;
+    destination: RpgPoint;
+    actionSerial: number;
+    cooldown: number;
+    form: number;
+    formPhase: number;
+    formRadius: number;
+    formSpeed: number;
+    formSerial: number;
+    /** References are 1-based indexes into items; zero is an empty slot. */
+    equipmentSlots: number[];
+    beltSlots: number[];
+    resistances: number[];
+    immunities: boolean[];
+    items: RpgItem[];
+    affixes: RpgAffix[];
+    dropAffixes: RpgAffix[];
+}
+declare function rpgData(o: RpgOptions): number[];
+declare function rpgOperation<T>(a: RpgAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B111–B120. Metres/seconds, Y up; tennis court is X width / Z length. */
+declare const SPORTS_ABILITIES: readonly ["swing-power-accuracy", "club-shot-profile", "wind-drag-ball-flight", "landing-spin-transfer", "slope-aware-putting", "racket-contact-timing", "racket-spin-shot", "lob-and-drop-placement", "serve-and-fault-sequence", "rally-point-adjudication"];
+type SportsAbility = (typeof SPORTS_ABILITIES)[number];
+type SportsPoint = readonly [number, number, number];
+interface SportsOptions {
+    swingDuration?: number;
+    idealImpactTime?: number;
+    accuracyWindow?: number;
+    ballRadius?: number;
+    drag?: number;
+    lift?: number;
+    gravity?: number;
+    restitution?: number;
+    rollingResistance?: number;
+    cupRadius?: number;
+    cupMaximumSpeed?: number;
+    racketWindow?: number;
+    maximumSpin?: number;
+    maximumSpeed?: number;
+    courtHalfWidth?: number;
+    courtHalfLength?: number;
+}
+/** Request IDs strictly increase (1..0xffffff). Invalid commands are atomic.
+ * With prerequisite abilities attached, consume their current serial rather than host inputs.
+ * Flight / putting own a virtual ball; host applies destination once per fixed step. */
+type SportsAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'swing-start';
+} | {
+    type: 'swing-power';
+} | {
+    type: 'swing-impact';
+} | {
+    type: 'swing-cancel';
+} | {
+    type: 'club-profile';
+    speed: number;
+    loft: number;
+    spin: number;
+} | {
+    type: 'club-shot';
+    aim: SportsPoint;
+    power: number;
+    error: number;
+    lie: number;
+    swingSerial: number;
+} | {
+    type: 'flight-start';
+    velocity: SportsPoint;
+    spin: SportsPoint;
+    shotSerial: number;
+} | {
+    type: 'wind';
+    velocity: SportsPoint;
+    drag: number;
+    lift: number;
+} | {
+    type: 'flight-stop';
+} | {
+    type: 'landing-spin';
+    spin: SportsPoint;
+} | {
+    type: 'spin-transfer';
+} | {
+    type: 'putt';
+    target: T;
+    velocity: SportsPoint;
+} | {
+    type: 'putt-stop';
+} | {
+    type: 'racket-swing';
+    target: T;
+} | {
+    type: 'racket-cancel';
+} | {
+    type: 'spin-shot';
+    aim: SportsPoint;
+    mode: -1 | 0 | 1;
+    power: number;
+    contactSerial: number;
+} | {
+    type: 'placement';
+    position: SportsPoint;
+    apex: number;
+} | {
+    type: 'serve-start';
+    target: T;
+    server: 0 | 1;
+    boxSide: -1 | 1;
+    serviceDepth: number;
+} | {
+    type: 'serve-strike';
+} | {
+    type: 'serve-contact';
+    kind: 'net' | 'bounce';
+} | {
+    type: 'rally-start';
+    lastHitter: 0 | 1;
+} | {
+    type: 'rally-hit';
+    player: 0 | 1;
+    contactSerial: number;
+} | {
+    type: 'rally-bounce';
+});
+interface SportsState {
+    abilities: SportsAbility[];
+    lastRequest: number;
+    revision: number;
+    swingPhase: number;
+    swingTime: number;
+    power: number;
+    directionError: number;
+    swingSerial: number;
+    shotSerial: number;
+    shotVelocity: SportsPoint;
+    shotSpin: SportsPoint;
+    flightPhase: number;
+    destination: SportsPoint;
+    velocity: SportsPoint;
+    spin: SportsPoint;
+    collisionSerial: number;
+    impactSerial: number;
+    impactVelocity: SportsPoint;
+    puttPhase: number;
+    bounceEpoch: number;
+    racketPhase: number;
+    racketTime: number;
+    contactQuality: number;
+    contactSerial: number;
+    contactAge: number;
+    placementTime: number;
+    placement: SportsPoint;
+    servePhase: number;
+    attempt: number;
+    server: number;
+    netTouched: boolean;
+    lets: number;
+    rallyPhase: number;
+    lastHitter: number;
+    bounceCount: number;
+    crossedNet: boolean;
+    winner: number;
+    pointSerial: number;
+    pointReason: number;
+    supported: boolean;
+    wind: SportsPoint;
+    consumedShot: number;
+    consumedSwing: number;
+    consumedContact: number;
+    adjudicatedContact: number;
+    adjudicatedBounce: number;
+}
+declare function sportsData(o: SportsOptions): number[];
+declare function sportsOperation<T>(a: SportsAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B101–B110. Metres/seconds, Y up, local +X forward. Host applies motion intents. */
+declare const SKATE_ABILITIES: readonly ["rail-grind-balance", "wall-ride", "manual-balance", "ramp-lip-launch", "unbanked-trick-combo", "repeated-trick-devaluation", "air-grab-trick", "prewound-spin", "landing-alignment-bail", "trick-earned-boost-meter"];
+type SkateAbility = (typeof SKATE_ABILITIES)[number];
+type SkatePoint = readonly [number, number, number];
+interface SkateOptions {
+    supportDistance?: number;
+    snapDistance?: number;
+    minimumSpeed?: number;
+    wallDuration?: number;
+    lipWindow?: number;
+    grabReleaseLead?: number;
+    minimumUpDot?: number;
+    minimumTravelDot?: number;
+    maximumImpactSpeed?: number;
+    minimumGrabTime?: number;
+    maximumSpinRate?: number;
+    maximumSpinAngle?: number;
+    boostCapacity?: number;
+    boostDrain?: number;
+    boostPerPoint?: number;
+    jumpSpeed?: number;
+}
+/** Successful request IDs strictly increase (1..0xffffff). Rejected commands are atomic.
+ * Scoring is host-authored; bank/award validates the live landing frame. No raw boost grants. */
+type SkateAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'grind';
+    target: T;
+    start: SkatePoint;
+    end: SkatePoint;
+} | {
+    type: 'grind-balance';
+    correction: number;
+} | {
+    type: 'dismount';
+    position: SkatePoint;
+} | {
+    type: 'wall-attach';
+    target: T;
+    direction: SkatePoint;
+} | {
+    type: 'wall-exit';
+    direction: SkatePoint;
+} | {
+    type: 'manual';
+} | {
+    type: 'manual-balance';
+    correction: number;
+} | {
+    type: 'end-manual';
+} | {
+    type: 'ramp-sample';
+    target: T;
+    tangent: SkatePoint;
+    jump: boolean;
+} | {
+    type: 'trick';
+    trick: number;
+    points: number;
+} | {
+    type: 'begin-combo';
+} | {
+    type: 'land-combo';
+} | {
+    type: 'bail-combo';
+} | {
+    type: 'preview-repeat';
+    trick: number;
+} | {
+    type: 'practice-repeat';
+    trick: number;
+} | {
+    type: 'reset-history';
+} | {
+    type: 'grab';
+    trick: number;
+} | {
+    type: 'release-grab';
+} | {
+    type: 'land-grab';
+} | {
+    type: 'wind';
+    direction: number;
+} | {
+    type: 'spin-takeoff';
+} | {
+    type: 'land-spin';
+} | {
+    type: 'begin-landing';
+} | {
+    type: 'resolve-landing';
+} | {
+    type: 'boost-trick';
+    trick: number;
+    points: number;
+} | {
+    type: 'boost-input';
+    held: boolean;
+} | {
+    type: 'land-boost';
+} | {
+    type: 'bail-boost';
+});
+type SkatePhase = 'idle' | 'active' | 'ended' | 'bailed' | 'blocked';
+interface SkateState {
+    abilities: SkateAbility[];
+    lastRequest: number;
+    revision: number;
+    railPhase: SkatePhase;
+    railCoordinate: number;
+    balance: number;
+    balanceTime: number;
+    wallPhase: SkatePhase;
+    wallRemaining: number;
+    manualPhase: SkatePhase;
+    destination: SkatePoint;
+    velocity: SkatePoint;
+    launchSerial: number;
+    launchVelocity: SkatePoint;
+    flight: number;
+    comboOpen: boolean;
+    landing: 'none' | 'landed' | 'bailed';
+    resolvedFlight: number;
+    pendingBase: number;
+    trickCount: number;
+    totalScore: number;
+    lastBank: number;
+    bankSerial: number;
+    repeatFactor: number;
+    repeatCount: number;
+    historySize: number;
+    grab: number;
+    grabHeld: boolean;
+    grabTime: number;
+    releaseAge: number;
+    grabValid: boolean;
+    windup: number;
+    spinRate: number;
+    spinAngle: number;
+    energy: number;
+    boosting: boolean;
+    boostFraction: number;
+    touchdownCaptured: boolean;
+    wallNormal: SkatePoint;
+    lipRemaining: number;
+}
+declare function skateData(o: SkateOptions): number[];
+declare function skateOperation<T>(a: SkateAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B091–B100. Metres/seconds, Y up, local +X forward/+Z right. Host owns motion and collision leases. */
+declare const RACING_ABILITIES: readonly ["drift-charge-boost", "slipstream-drafting", "position-weighted-race-items", "track-following-homing-item", "ordered-lap-checkpoints", "hover-track-suspension", "energy-funded-race-boost", "vehicle-side-attack", "vehicle-damage-progression", "vehicle-seat-entry-exit"];
+type RacingAbility = (typeof RACING_ABILITIES)[number];
+type RacingPoint = readonly [number, number, number];
+interface RacingOptions {
+    driftTierTime?: number;
+    boostDuration?: number;
+    minimumSpeed?: number;
+    draftRange?: number;
+    draftDwell?: number;
+    rideHeight?: number;
+    spring?: number;
+    damping?: number;
+    maxAcceleration?: number;
+    energyCapacity?: number;
+    boostDrain?: number;
+    rechargeRate?: number;
+    attackDuration?: number;
+    attackCooldown?: number;
+    burnDuration?: number;
+    seatRange?: number;
+}
+/** Successful IDs strictly increase, 1..0xffffff. Rejected commands leave all state untouched. */
+type RacingAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'drift-input';
+    held: boolean;
+    supported: boolean;
+    slipAngle: number;
+    steering: number;
+} | {
+    type: 'draft-target';
+    target: T;
+} | {
+    type: 'clear-draft';
+} | {
+    type: 'item-weight';
+    firstRank: number;
+    lastRank: number;
+    item: number;
+    weight: number;
+} | {
+    type: 'draw-item';
+    rank: number;
+    racers: number;
+    seed: number;
+} | {
+    type: 'use-item';
+} | {
+    type: 'route-point';
+    position: RacingPoint;
+} | {
+    type: 'launch-item';
+    target: T;
+} | {
+    type: 'cancel-item';
+} | {
+    type: 'checkpoint';
+    position: RacingPoint;
+    normal: RacingPoint;
+    radius: number;
+} | {
+    type: 'start-race';
+    laps: number;
+} | {
+    type: 'hover-track';
+    target: T;
+} | {
+    type: 'clear-hover';
+} | {
+    type: 'boost-input';
+    held: boolean;
+} | {
+    type: 'recharge-zone';
+    target: T;
+    radius: number;
+} | {
+    type: 'energy-damage';
+    amount: number;
+} | {
+    type: 'side-attack';
+    direction: -1 | 0 | 1;
+} | {
+    type: 'attack-contact';
+    target: T;
+} | {
+    type: 'vehicle-damage';
+    amount: number;
+} | {
+    type: 'repair';
+    amount: number;
+} | {
+    type: 'reserve-seat';
+    target: T;
+    seat: number;
+    local: RacingPoint;
+} | {
+    type: 'complete-entry';
+} | {
+    type: 'exit-seat';
+    position: RacingPoint;
+} | {
+    type: 'release-seat';
+});
+interface RacingState {
+    abilities: RacingAbility[];
+    lastRequest: number;
+    revision: number;
+    driftCharge: number;
+    driftTier: number;
+    driftBoost: number;
+    draftDwell: number;
+    draftBoost: number;
+    item: number;
+    itemRank: number;
+    routeIndex: number;
+    homing: 'idle' | 'following' | 'hit' | 'arrived' | 'cancelled';
+    destination: RacingPoint;
+    randomState: number;
+    nextCheckpoint: number;
+    lap: number;
+    laps: number;
+    racing: boolean;
+    supportProbes: number;
+    hoverAcceleration: RacingPoint;
+    trackUp: RacingPoint;
+    energy: number;
+    boostFraction: number;
+    attackRemaining: number;
+    attackCooldown: number;
+    attackHits: number;
+    integrity: number;
+    damage: 'healthy' | 'smoke' | 'fire' | 'destroyed';
+    burnElapsed: number;
+    handlingMultiplier: number;
+    seatPhase: 'free' | 'entering' | 'occupied' | 'exiting';
+    seat: number;
+    seatDestination: RacingPoint;
+    seatRemaining: number;
+    weightCount: number;
+    routePoints: number;
+    checkpointCount: number;
+    drifting: boolean;
+    boosting: boolean;
+    attackDirection: number;
+}
+declare function racingData(o: RacingOptions): number[];
+declare function racingOperation<T>(a: RacingAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B081–B090: Y-up metres/seconds. Host owns motion, combat outcomes, gates and durable storage. */
+declare const SURVIVAL_ABILITIES: readonly ["escort-follow-wait", "companion-abduction-objective", "environmental-vault-action", "stagger-finisher-opportunity", "adaptive-encounter-pressure", "spatial-inventory-packing", "ingredient-combination", "weapon-upgrade-track", "encounter-clear-lock", "save-point-checkpoint"];
+type SurvivalAbility = (typeof SURVIVAL_ABILITIES)[number];
+type SurvivalPoint = readonly [number, number, number];
+interface SurvivalOptions {
+    followDistance?: number;
+    maxTravelDistance?: number;
+    interactionRange?: number;
+    boundaryRadius?: number;
+    finisherRange?: number;
+    minPressure?: number;
+    maxPressure?: number;
+    columns?: number;
+    rows?: number;
+    pressureGain?: number;
+}
+/** Successful request IDs strictly increase per attached actor (1..0xffffff). Rejections are retryable. */
+type SurvivalAction<T = number> = {
+    requestId: number;
+} & ({
+    type: 'follow';
+    target: T;
+} | {
+    type: 'wait';
+} | {
+    type: 'seek-safe';
+    position: SurvivalPoint;
+} | {
+    type: 'capture';
+    target: T;
+    boundary: SurvivalPoint;
+} | {
+    type: 'rescue';
+} | {
+    type: 'vault';
+    target: T;
+    landing: SurvivalPoint;
+    height: number;
+    duration: number;
+} | {
+    type: 'cancel-vault';
+} | {
+    type: 'stagger';
+    class: 1 | 2 | 3;
+    duration: number;
+} | {
+    type: 'finish';
+    target: T;
+    eligibleMask: number;
+} | {
+    type: 'performance';
+    score: number;
+} | {
+    type: 'begin-encounter';
+} | {
+    type: 'pack';
+    kind: number;
+    quantity: number;
+    limit: number;
+    shape: number;
+    x: number;
+    y: number;
+    rotated?: boolean;
+} | {
+    type: 'move-item';
+    item: number;
+    x: number;
+    y: number;
+    rotated?: boolean;
+} | {
+    type: 'stack';
+    item: number;
+    into: number;
+    quantity: number;
+} | {
+    type: 'stock';
+    kind: number;
+    quantity: number;
+    limit: number;
+} | {
+    type: 'recipe';
+    id: number;
+    first: number;
+    firstCount: number;
+    second: number;
+    secondCount: number;
+    output: number;
+    outputCount: number;
+    limit: number;
+} | {
+    type: 'combine';
+    recipe: number;
+} | {
+    type: 'credit';
+    amount: number;
+} | {
+    type: 'upgrade-level';
+    level: number;
+    cost: number;
+    gate: number;
+    value: number;
+} | {
+    type: 'purchase';
+    unlockedGate: number;
+} | {
+    type: 'expect-spawns';
+    count: number;
+} | {
+    type: 'track-enemy';
+    target: T;
+    id: number;
+} | {
+    type: 'resolve-enemy';
+    id: number;
+    resolution: 'defeated' | 'exempt';
+} | {
+    type: 'link-gate';
+    target: T;
+} | {
+    type: 'save-permission';
+    allowed: boolean;
+} | {
+    type: 'request-save';
+    target: T;
+    checkpoint: number;
+} | {
+    type: 'complete-save';
+    saveRequest: number;
+    success: boolean;
+});
+interface SurvivalItem {
+    id: number;
+    kind: number;
+    quantity: number;
+    limit: number;
+    shape: number;
+    x: number;
+    y: number;
+    rotated: boolean;
+}
+/** Versioned gameplay record. The host adds stable actor/world IDs and performs durable IO. */
+interface SurvivalCheckpoint {
+    version: 1;
+    checkpoint: number;
+    requestId: number;
+    revision: number;
+    currency: number;
+    upgradeLevel: number;
+    weaponValue: number;
+    pressure: number;
+    items: SurvivalItem[];
+}
+interface SurvivalState {
+    abilities: SurvivalAbility[];
+    lastRequest: number;
+    revision: number;
+    escortMode: 'wait' | 'follow' | 'safe';
+    intent: 'hold' | 'move' | 'transport' | 'vault';
+    destination: SurvivalPoint;
+    capture: 'free' | 'captured' | 'failed';
+    vault: 'idle' | 'active' | 'completed' | 'cancelled';
+    finisherRemaining: number;
+    staggerClass: number;
+    finisherConsumed: boolean;
+    pressure: number;
+    nextPressure: number;
+    sampleCount: number;
+    items: SurvivalItem[];
+    currency: number;
+    upgradeLevel: number;
+    weaponValue: number;
+    spawnObligations: number;
+    unresolvedEnemies: number;
+    locked: boolean;
+    savePending: boolean;
+    lastCheckpoint: number;
+    gateCount: number;
+    vaultElapsed: number;
+    vaultDuration: number;
+    recipeCount: number;
+    columns: number;
+    rows: number;
+    saveAllowed: boolean;
+    checkpoint: SurvivalCheckpoint | null;
+}
+declare function survivalData(o: SurvivalOptions): number[];
+declare function survivalOperation<T>(a: SurvivalAction<T>): {
+    op: number;
+    data: number[];
+};
+
+/** B071–B080. Metres, seconds, Y-up. Policies emit intents and never move bodies. */
+declare const CITY_ABILITIES: readonly ["vision-cone-awareness", "last-seen-search", "noise-investigation", "footprint-trail-following", "contextual-disguise", "alarm-communication-network", "wanted-level-escalation", "pursuit-evasion-decay", "pedestrian-panic-propagation", "traffic-junction-yield"];
+type CityAbility = (typeof CITY_ABILITIES)[number];
+declare const CITY_INTENTS: readonly ["hold", "observe", "search", "investigate", "track", "flee", "wait", "drive"];
+declare const CITY_EVENTS: readonly ["none", "awareness-changed", "search-ended", "noise-heard", "clue-reached", "disguise-changed", "report-sent", "alert-received", "wanted-changed", "panic", "traffic-changed"];
+declare const CITY_LINKS: readonly ["target", "radio", "neighbor", "junction", "observer"];
+type CityLinkKind = (typeof CITY_LINKS)[number];
+type CityPoint = readonly [number, number, number];
+interface CityOptions {
+    visionRange?: number;
+    coneCosine?: number;
+    suspicionRate?: number;
+    suspicionDecay?: number;
+    alertThreshold?: number;
+    searchDuration?: number;
+    searchRadius?: number;
+    hearingRange?: number;
+    noiseMemory?: number;
+    trailLifetime?: number;
+    disguiseModifier?: number;
+    reportDelay?: number;
+    wantedDecay?: number;
+    evasionDelay?: number;
+    panicDuration?: number;
+    trafficSpeed?: number;
+}
+interface CityTarget {
+    exposure?: number;
+    crouched?: boolean;
+    zone?: number;
+    disguiseZone?: number;
+    disguised?: boolean;
+    actions?: number;
+    recognized?: boolean;
+}
+/** Sequence is an integer in 1..0xffffff and strictly increases per source, recipient and signal kind. Offense IDs increase per offender across all witnesses. */
+interface CityNoise {
+    sequence: number;
+    position: CityPoint;
+    loudness?: number;
+    category?: 'footstep' | 'impact' | 'gunshot';
+    age?: number;
+}
+interface CityFootprint {
+    sequence: number;
+    position: CityPoint;
+    age?: number;
+    eligible?: boolean;
+}
+interface CityDanger {
+    sequence: number;
+    position: CityPoint;
+    radius?: number;
+    age?: number;
+}
+interface CityTraffic {
+    green: boolean;
+    exitOpen: boolean;
+    request: boolean;
+    inside?: boolean;
+}
+interface CityState {
+    abilities: CityAbility[];
+    suspicion: number;
+    visible: boolean;
+    intent: (typeof CITY_INTENTS)[number];
+    destination: CityPoint;
+    disguiseModifier: number;
+    searchRemaining: number;
+    noiseRemaining: number;
+    trailCount: number;
+    alert: boolean;
+    reportRemaining: number;
+    wantedLevel: number;
+    pursuitScore: number;
+    targetSlot: number | null;
+    responseMask: number;
+    unseenFor: number;
+    panicRemaining: number;
+    reserved: boolean;
+    desiredSpeed: number;
+    trafficReason: 'clear' | 'no-request' | 'red' | 'blocked' | 'conflict';
+    trailSequence: number;
+    reportsSent: number;
+    lastEvent: (typeof CITY_EVENTS)[number];
+    lastSeen: CityPoint;
+    searchIndex: number;
+    noiseCategory: 'footstep' | 'impact' | 'gunshot';
+    receiptCount: number;
+    linkCount: number;
+}
+declare function cityData(o: CityOptions): number[];
+
+/** Combat AI emits decisions, never body writes. Metres, seconds, Y-up. */
+declare const ENCOUNTER_ABILITIES: readonly ["squad-flank-assignment", "leader-loss-morale", "grenade-danger-evasion", "cover-peek-cycle", "threat-target-selection", "tactical-burst-selection", "latent-ambush-activation", "boss-phase-controller", "localized-weak-point-damage", "shootable-projectile-interception"];
+type EncounterAbility = (typeof ENCOUNTER_ABILITIES)[number];
+declare const ENCOUNTER_INTENTS: readonly ["hold", "flank", "retreat", "evade", "hide", "peek", "attack", "reposition", "dormant", "dead", "intercepted", "impact"];
+declare const ENCOUNTER_EVENTS: readonly ["none", "target-changed", "flank-assigned", "morale-changed", "evasion", "cover-changed", "fire-request", "activated", "phase-changed", "damage", "stagger", "intercepted", "impact"];
+interface EncounterOptions {
+    health?: number;
+    team?: number;
+    squad?: number;
+    perceptionRange?: number;
+    flankRadius?: number;
+    retreatThreshold?: number;
+    leaderPenalty?: number;
+    casualtyPenalty?: number;
+    dangerHorizon?: number;
+    evadeSpeed?: number;
+    concealDuration?: number;
+    attackDuration?: number;
+    shotInterval?: number;
+    burstPause?: number;
+    activationDelay?: number;
+    targetHysteresis?: number;
+}
+interface EncounterCandidate {
+    team?: number;
+    priority?: number;
+    recentDamage?: number;
+}
+interface EncounterCover {
+    hide: readonly [number, number, number];
+    peek: readonly [number, number, number];
+}
+interface EncounterHazard {
+    radius: number;
+    fuse: number;
+    velocity?: readonly [number, number, number];
+}
+interface EncounterRegion {
+    multiplier?: number;
+    staggerThreshold?: number;
+}
+interface EncounterPhase {
+    healthFraction: number;
+    attackMask: number;
+    vulnerability?: number;
+}
+/** Sequence must strictly increase per source/recipient; retries are rejected. */
+interface EncounterHit {
+    damage: number;
+    team: number;
+    sequence: number;
+    impact?: boolean;
+}
+type EncounterLinkKind = 'candidate' | 'leader' | 'ally' | 'cover' | 'hazard' | 'region';
+declare const ENCOUNTER_LINKS: readonly ["candidate", "leader", "ally", "cover", "hazard", "region"];
+interface EncounterState {
+    abilities: EncounterAbility[];
+    health: number;
+    morale: number;
+    intent: (typeof ENCOUNTER_INTENTS)[number];
+    destination: readonly [number, number, number];
+    targetSlot: number | null;
+    flankSlot: number | null;
+    coverPhase: 'concealed' | 'observing' | 'attacking';
+    activation: 'dormant' | 'activating' | 'active';
+    bossPhase: number;
+    attackMask: number;
+    vulnerability: number;
+    shotSequence: number;
+    terminal: 'live' | 'intercepted' | 'impact';
+    burstRemaining: number;
+    shotBudget: number;
+    activationRemaining: number;
+    staggerRemaining: number;
+    lastDamage: number;
+    lastEvent: (typeof ENCOUNTER_EVENTS)[number];
+    retiredAttackMask: number;
+    attackEpoch: number;
+    leaderLost: boolean;
+    coverElapsed: number;
+    targetScore: number;
+}
+declare function encounterData(o: EncounterOptions): number[];
+
+/** Weapon policy units: metres, seconds, radians; Y-up, +X forward at yaw 0. */
+declare const WEAPON_ABILITIES: readonly ["delayed-shield-regeneration", "weapon-heat-and-vent", "interruptible-magazine-reload", "sticky-grenade-attachment", "alternate-weapon-mode", "remote-guided-projectile", "charge-and-release-shot", "material-penetrating-shot", "beam-missile-combination", "stationary-aim-mode"];
+type WeaponAbility = (typeof WEAPON_ABILITIES)[number];
+declare const WEAPON_PHASES: readonly ["idle", "cooldown", "reloading", "venting", "switching", "charging", "overheated", "guiding", "dead"];
+declare const WEAPON_EVENTS: readonly ["none", "damage", "shot", "recharge-start", "shield-full", "vent-start", "vent-end", "reload-start", "reload-commit", "reload-cancel", "attached", "detonated", "control-returned", "mode-changed"];
+interface WeaponOptions {
+    speed?: number;
+    gravity?: number;
+    health?: number;
+    shieldCapacity?: number;
+    rechargeDelay?: number;
+    rechargeRate?: number;
+    heatCapacity?: number;
+    coolingRate?: number;
+    resumeHeat?: number;
+    ventDuration?: number;
+    reloadDuration?: number;
+    reloadCommit?: number;
+    magazineSize?: number;
+    reserve?: number;
+    secondaryAmmo?: number;
+    chargeDuration?: number;
+    turnRate?: number;
+}
+interface WeaponInput {
+    moveX?: number;
+    moveZ?: number;
+    turnYaw?: number;
+    turnPitch?: number;
+    fire?: boolean;
+    reload?: boolean;
+    vent?: boolean;
+    switchMode?: boolean;
+    cancelGuide?: boolean;
+    combo?: boolean;
+    aim?: boolean;
+    cancelReload?: boolean;
+}
+interface WeaponMode {
+    damage?: number;
+    interval?: number;
+    roundsPerShot?: number;
+    heatPerShot?: number;
+    range?: number;
+    penetrationBudget?: number;
+    chargeMultiplier?: number;
+    comboCost?: number;
+    comboMultiplier?: number;
+    comboCompatible?: boolean;
+    switchDuration?: number;
+    minimumCharge?: number;
+}
+interface WeaponSurface {
+    penetrable?: boolean;
+    resistance?: number;
+    sticky?: boolean;
+}
+/** Spawn the body first: one centered sphere, dynamic, solid. Host owns projectile inventory. */
+interface WeaponProjectileOptions {
+    speed?: number;
+    lifetime?: number;
+    turnRate?: number;
+    blastRadius?: number;
+    damage?: number;
+}
+type WeaponProjectileKind = 'sticky' | 'guided';
+interface WeaponProjectileState {
+    kind: WeaponProjectileKind;
+    phase: 'flying' | 'attached' | 'detonated' | 'cancelled';
+    remaining: number;
+    position: readonly [number, number, number];
+    yaw: number;
+    pitch: number;
+    ownerSlot: number | null;
+    hostSlot: number | null;
+    radius: number;
+}
+interface WeaponShot {
+    sequence: number;
+    kind: 'normal' | 'charged' | 'combo';
+    damage: number;
+    from: readonly [number, number, number];
+    to: readonly [number, number, number];
+    intersections: number;
+}
+interface WeaponState {
+    abilities: WeaponAbility[];
+    phase: (typeof WEAPON_PHASES)[number];
+    health: number;
+    shield: number;
+    heat: number;
+    magazine: number;
+    reserve: number;
+    secondaryAmmo: number;
+    mode: 0 | 1;
+    charge: number;
+    cooldown: number;
+    reloadTime: number | null;
+    reloadCommitted: boolean;
+    yaw: number;
+    pitch: number;
+    lastEvent: (typeof WEAPON_EVENTS)[number];
+    shot: WeaponShot;
+    aiming: boolean;
+    guidedSlot: number | null;
+    overheated: boolean;
+    ventTime: number;
+    switchTime: number;
+    timeSinceDamage: number;
+}
+/** Camera intent only. The renderer owns camera placement and interpolation. */
+interface WeaponCameraIntent {
+    mode: 'actor' | 'precision' | 'projectile';
+    slot: number;
+    yaw: number;
+    pitch: number;
+}
+declare function weaponData(o: WeaponOptions): number[];
+declare function weaponModeData(o: WeaponMode): number[];
+declare function weaponProjectileData(o: WeaponProjectileOptions): number[];
+declare function weaponButtons(i: WeaponInput): number;
+
+/** Y-up, XY combat plane. Distances in metres; clocks in simulation seconds. */
+declare const COMBAT_ABILITIES: readonly ["attack-phase-hitboxes", "damage-scaled-knockback", "combat-hitstop", "depleting-shield", "timed-perfect-guard", "grab-hold-throw", "air-dodge-recovery", "directional-influence", "impact-tech-window", "grounded-attack-chain"];
+type CombatAbility = (typeof COMBAT_ABILITIES)[number];
+declare const COMBAT_PHASES: readonly ["idle", "startup", "active", "recovery", "stunned", "guarding", "captured", "holding", "dodging", "recovering", "shield-break"];
+declare const COMBAT_EVENTS: readonly ["none", "hit", "shield", "perfect-guard", "evaded", "shield-break", "launch", "grab", "throw", "release", "air-dodge", "floor-tech", "wall-tech", "failed-tech"];
+interface CombatOptions {
+    speed?: number;
+    gravity?: number;
+    weight?: number;
+    shieldCapacity?: number;
+    shieldDrain?: number;
+    shieldRegen?: number;
+    perfectWindow?: number;
+    grabDuration?: number;
+    dodgeDuration?: number;
+    dodgeRecovery?: number;
+    maxInfluenceAngle?: number;
+    techWindow?: number;
+    techLockout?: number;
+    inputBuffer?: number;
+    jumpSpeed?: number;
+    shieldBreakStun?: number;
+}
+interface CombatInput {
+    moveX?: number;
+    moveY?: number;
+    attack?: boolean;
+    guard?: boolean;
+    grab?: boolean;
+    throw?: boolean;
+    dodge?: boolean;
+    tech?: boolean;
+    jump?: boolean;
+}
+interface CombatHit {
+    damage?: number;
+    baseKnockback?: number;
+    growth?: number;
+    angle?: number;
+    direction?: 1 | -1;
+    hitstop?: number;
+    hitstun?: number;
+}
+interface CombatAttack extends CombatHit {
+    startup?: number;
+    active?: number;
+    recovery?: number;
+    reach?: number;
+    halfExtents?: readonly [number, number, number];
+    chainOpen?: number;
+    chainClose?: number;
+}
+interface CombatState {
+    abilities: CombatAbility[];
+    phase: (typeof COMBAT_PHASES)[number];
+    attackIndex: number | null;
+    actionTime: number;
+    damage: number;
+    shield: number;
+    hitstop: number;
+    hitstun: number;
+    dodge: number;
+    recovery: number;
+    partnerSlot: number | null;
+    confirmedHits: number;
+    lastEvent: (typeof COMBAT_EVENTS)[number];
+    launch: readonly [number, number, number];
+    grounded: boolean;
+    facing: 1 | -1;
+}
+declare function combatData(o: CombatOptions): number[];
+declare function combatHitData(o: CombatHit): number[];
+declare function combatAttackData(o: CombatAttack): number[];
+declare function combatButtons(i: CombatInput): number;
+
+/** Distances in metres, time in seconds; logical heat and cold are normalized units. */
+declare const PUZZLE_ABILITIES: readonly ["weighted-pressure-switch", "grid-constrained-push-block", "mirror-beam-routing", "conductive-contact-network", "material-ignition-spread", "freeze-and-shatter", "stasis-impulse-storage", "magnetic-object-manipulation", "water-level-mechanism", "timed-solid-platform"];
+type PuzzleAbility = (typeof PUZZLE_ABILITIES)[number];
+type PuzzleVector = readonly [number, number, number];
+interface PuzzleOptions {
+    threshold?: number;
+    releaseDelay?: number;
+    occupancy?: boolean;
+    cellSize?: number;
+    beamRole?: 'emitter' | 'mirror' | 'receiver';
+    direction?: PuzzleVector;
+    range?: number;
+    maxSegments?: number;
+    source?: boolean;
+    contactGap?: number;
+    ignition?: number;
+    fuel?: number;
+    heatRate?: number;
+    cooling?: number;
+    spreadRadius?: number;
+    wetness?: number;
+    duration?: number;
+    coldThreshold?: number;
+    shatterThreshold?: number;
+    resistance?: number;
+    maxImpulse?: number;
+    stiffness?: number;
+    damping?: number;
+    maxForce?: number;
+    low?: number;
+    high?: number;
+    speed?: number;
+    halfWidth?: number;
+    bottom?: number;
+    halfDepth?: number;
+    solidDuration?: number;
+    warningDuration?: number;
+    absentDuration?: number;
+}
+type PuzzleCommand = {
+    type: 'push';
+    direction: PuzzleVector;
+} | {
+    type: 'aim';
+    direction: PuzzleVector;
+} | {
+    type: 'power';
+    enabled: boolean;
+} | {
+    type: 'heat' | 'cold';
+    amount: number;
+} | {
+    type: 'wetness';
+    value: number;
+} | {
+    type: 'impact';
+    impulse: PuzzleVector;
+} | {
+    type: 'activate' | 'release';
+} | {
+    type: 'target';
+    position: PuzzleVector;
+} | {
+    type: 'level';
+    high: boolean;
+};
+interface PuzzleState {
+    ability: PuzzleAbility;
+    active: boolean;
+    value: number;
+    remaining: number;
+    blocked: boolean;
+    transitions: number;
+    auxiliary: number;
+    storedImpulse: PuzzleVector;
+    target: PuzzleVector;
+    segmentCount: number;
+}
+interface PuzzleSegment {
+    from: PuzzleVector;
+    to: PuzzleVector;
+}
+/** Shared encoding, kept internal to the runtime bridge. */
+declare function puzzleData(a: PuzzleAbility, o: PuzzleOptions): number[];
+declare function puzzleCommandData(c: PuzzleCommand): [number, number, number, number];
+
+/** Engine-neutral tools. Distances are metres, angles radians, durations seconds. */
+declare const ADVENTURE_ABILITIES: readonly ["combat-lock-on", "hookshot-pull", "grapple-swing", "morph-ball-transition", "magnetic-track-adhesion", "scanning-and-discovery", "fused-carryable-bomb", "returning-boomerang", "keyed-interaction-gate", "carry-aim-and-throw"];
+type AdventureAbility = (typeof ADVENTURE_ABILITIES)[number];
+interface AdventureOptions {
+    speed?: number;
+    gravity?: number;
+    range?: number;
+    scanDuration?: number;
+    maxCarryMass?: number;
+}
+interface AdventureInput {
+    moveX?: number;
+    moveY?: number;
+    moveZ?: number;
+    yaw?: number;
+    pitch?: number;
+    lock?: boolean;
+    cycle?: boolean;
+    hook?: boolean;
+    grapple?: boolean;
+    morph?: boolean;
+    magnet?: boolean;
+    scan?: boolean;
+    armBomb?: boolean;
+    boomerang?: boolean;
+    interact?: boolean;
+    carry?: boolean;
+    throw?: boolean;
+    release?: boolean;
+}
+declare const ADVENTURE_BUTTONS: readonly ["lock", "cycle", "hook", "grapple", "morph", "magnet", "scan", "armBomb", "boomerang", "interact", "carry", "throw", "release"];
+declare const ADVENTURE_FLAGS: {
+    readonly target: 1;
+    readonly hookAnchor: 2;
+    readonly pullable: 4;
+    readonly grappleAnchor: 8;
+    readonly scannable: 16;
+    readonly carryable: 32;
+    readonly bomb: 64;
+    readonly gate: 128;
+    readonly magneticTrack: 256;
+    readonly hittable: 512;
+};
+type AdventureRole = keyof typeof ADVENTURE_FLAGS;
+interface AdventureObject {
+    roles: readonly AdventureRole[];
+    key?: number;
+    consumeToken?: boolean;
+    fuse?: number;
+    blastRadius?: number;
+    /** Track segment offset from its fixed body's origin, with an outward normal. */
+    trackEnd?: readonly [number, number, number];
+    trackNormal?: readonly [number, number, number];
+}
+interface AdventureState {
+    mode: number;
+    targetSlot: number | null;
+    ball: boolean;
+    scanProgress: number;
+    discoveries: number;
+    hits: number;
+    unlocks: number;
+    heldSlot: number | null;
+    projectile: readonly [number, number, number];
+    projectilePhase: number;
+    ropeLength: number;
+    blocked: boolean;
+    detonations: number;
+    hookPhase: number;
+}
+interface AdventureObjectState {
+    flags: number;
+    key: number;
+    opened: boolean;
+    armed: boolean;
+    fuse: number;
+    detonated: boolean;
+    ownerSlot: number | null;
+    hits: number;
+}
+declare const ADVENTURE_EVENT_KINDS: readonly ["unknown", "lockChanged", "discovered", "detonated", "toolHit", "unlocked", "pickedUp", "released", "formChanged"];
+
+/** World metres, seconds, radians. No backend handles or engine types. */
+declare const ENVIRONMENT_ABILITIES: readonly ["local-gravity-field", "gravity-frame-transition", "volume-buoyancy", "stroke-swimming", "surface-breach-jump", "breath-and-drowning", "water-current-advection", "wind-driven-sailing", "stamina-glide-and-updraft", "tube-slide-steering"];
+type EnvironmentAbility = typeof ENVIRONMENT_ABILITIES[number];
+type EnvironmentVector = readonly [number, number, number];
+interface EnvironmentOptions {
+    gravity?: number;
+    speed?: number;
+    drag?: number;
+    buoyancy?: number;
+    turnRate?: number;
+    breathCapacity?: number;
+    staminaCapacity?: number;
+}
+interface EnvironmentInput {
+    moveX?: number;
+    moveY?: number;
+    moveZ?: number;
+    sailTrim?: number;
+    stroke?: boolean;
+    breach?: boolean;
+    glide?: boolean;
+    sail?: boolean;
+    ride?: boolean;
+    release?: boolean;
+}
+declare const ENVIRONMENT_MODES: readonly ["air", "water", "stroke", "breach", "sailing", "gliding", "tube slide"];
+interface EnvironmentState {
+    mode: number;
+    submerged: number;
+    breath: number;
+    stamina: number;
+    strokes: number;
+    breaches: number;
+    damage: number;
+    railDistance: number;
+    railAngle: number;
+    up: EnvironmentVector;
+    velocity: EnvironmentVector;
+    blocked: boolean;
+}
+interface VolumeBounds {
+    min: EnvironmentVector;
+    max: EnvironmentVector;
+    priority?: number;
+}
+type EnvironmentVolume = VolumeBounds & ({
+    kind: 'directional-gravity';
+    direction: EnvironmentVector;
+    strength?: number;
+} | {
+    kind: 'point-gravity';
+    point: EnvironmentVector;
+    strength?: number;
+} | {
+    kind: 'segment-gravity';
+    start: EnvironmentVector;
+    end: EnvironmentVector;
+    strength?: number;
+} | {
+    kind: 'water';
+    current?: EnvironmentVector;
+    density?: number;
+    falloff?: number;
+    waveAmplitude?: number;
+    waveFrequency?: number;
+} | {
+    kind: 'wind' | 'updraft';
+    velocity: EnvironmentVector;
+    strength?: number;
+});
+/** Cubic Bezier centerline. Up must remain nonparallel to every tangent. */
+interface TubeRail {
+    points: readonly [EnvironmentVector, EnvironmentVector, EnvironmentVector, EnvironmentVector];
+    radius: number;
+    up?: EnvironmentVector;
+}
+
+/** Physics-neutral public contract; velocities are metres/second, durations seconds. */
+declare const TRAVERSAL_ABILITIES: readonly ["running-long-jump", "chained-jump", "crouch-backflip", "wall-kick", "ledge-hang-and-mantle", "pole-climb", "ceiling-hang-traverse", "ground-pound-impact", "dive-to-belly-slide", "temporary-actor-possession"];
+type AcrobaticsAbility = typeof TRAVERSAL_ABILITIES[number];
+interface AcrobaticsOptions {
+    moveSpeed?: number;
+    jumpSpeed?: number;
+    gravity?: number;
+    chainWindow?: number;
+}
+interface AcrobaticsInput {
+    moveX: number;
+    jump: boolean;
+    crouch: boolean;
+    moveY?: number;
+    moveZ?: number;
+    action?: boolean;
+    grab?: boolean;
+    release?: boolean;
+}
+interface AcrobaticsState {
+    grounded: boolean;
+    action: number;
+    chain: number;
+    remaining: number;
+    facing: number;
+    launches: number;
+    velocity: readonly [number, number];
+    impacts: number;
+    phaseRemaining: number;
+    poleAngle: number;
+    wallWindow: number;
+    reattachLockout: number;
+    velocityZ: number;
+    impactThisStep: boolean;
+    impactSpeed: number;
+}
+declare const ACROBATICS_ACTIONS: readonly ["grounded", "jump", "long jump", "double jump", "triple jump", "backflip", "falling", "wall kick", "ledge hang", "pole climb", "ceiling hang", "pound windup", "pound descent", "impact recovery", "dive", "belly slide", "possessing", "mantle"];
+
+/** Sentinel handle for "no entity / failed allocation". Mirrors `INVALID_SLOT` in Rust. */
+declare const STAGE_INVALID_SLOT = 4294967295;
+declare const StageBodyKind: {
+    readonly Dynamic: 0;
+    readonly Static: 1;
+    readonly KinematicPosition: 2;
+    readonly KinematicVelocity: 3;
+};
+type StageBodyKindValue = (typeof StageBodyKind)[keyof typeof StageBodyKind];
+declare const StageBoundaryDim: {
+    readonly Two: 2;
+    readonly Three: 3;
+};
+declare const StageRicochetDim: {
+    readonly Two: 2;
+    readonly Three: 3;
+};
+declare const StageRicochetReflection: {
+    readonly Mirror: 0;
+    readonly Angled: 1;
+};
+declare const StageTopDownPlane: {
+    readonly Xy: 0;
+    readonly Xz: 1;
+};
+declare const StageEventType: {
+    readonly CollisionStarted: 1;
+    readonly CollisionStopped: 2;
+    readonly BoundaryHit: 3;
+    readonly Ricochet: 4;
+    readonly RegionEntered: 5;
+    readonly JumpStarted: 6;
+    readonly Landed: 7;
+    readonly Wrapped: 8;
+    readonly CooldownFired: 9;
+    readonly GroundPoundImpact: 10;
+    readonly DrowningDamage: 11;
+    readonly Adventure: 12;
+    readonly Puzzle: 13;
+    readonly Combat: 14;
+    readonly Weapon: 15;
+    readonly Encounter: 16;
+    readonly City: 17;
+    readonly Survival: 18;
+    readonly Racing: 19;
+    readonly Skate: 20;
+    readonly Sports: 21;
+    readonly Rpg: 22;
+    readonly Matching: 28;
+    readonly Rhythm: 29;
+    readonly Life: 27;
+    readonly Defense: 26;
+    readonly Squad: 25;
+    readonly Tactics: 24;
+    readonly Battle: 23;
+};
+type StageBoundaryDimValue = (typeof StageBoundaryDim)[keyof typeof StageBoundaryDim];
+type StageRicochetDimValue = (typeof StageRicochetDim)[keyof typeof StageRicochetDim];
+type StageRicochetReflectionValue = (typeof StageRicochetReflection)[keyof typeof StageRicochetReflection];
+type StageTopDownPlaneValue = (typeof StageTopDownPlane)[keyof typeof StageTopDownPlane];
+/** Position + rotation snapshot for one runtime slot. */
+interface StagePose {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+}
+interface StageWorldBoundaryOptions {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    front?: number;
+    back?: number;
+    padding?: number;
+}
+interface StageScreenWrapOptions {
+    width: number;
+    height: number;
+    centerX?: number;
+    centerY?: number;
+    edgeThreshold?: number;
+}
+interface StageRicochetOptions {
+    minSpeed: number;
+    maxSpeed: number;
+    speedMultiplier: number;
+    maxAngleDeg: number;
+    reflectionMode: StageRicochetReflectionValue;
+}
+interface StageThrusterOptions {
+    maxSpeed: number;
+    acceleration: number;
+    turnRateRadPerSec: number;
+    linearDamping: number;
+}
+interface StageTopDownOptions {
+    plane: StageTopDownPlaneValue;
+    speed: number;
+    faceMovement?: boolean;
+}
+interface StageShooter2DOptions {
+    fireRateHz: number;
+    muzzleOffsetX: number;
+    muzzleOffsetY: number;
+    muzzleSpeed: number;
+}
+interface StageJumper2DOptions {
+    jumpForce: number;
+    maxJumps: number;
+    jumpBufferTime: number;
+    coyoteTime: number;
+    gravity: number;
+}
+interface StageJumper3DOptions {
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.08). */
+    jumpBufferTime?: number;
+}
+interface StagePlatformer3DOptions {
+    halfHeight: number;
+    radius: number;
+    walkSpeed: number;
+    runSpeed: number;
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.1). */
+    jumpBufferTime?: number;
+    /** Velocity multiplier applied on early jump release (default 0.5). */
+    jumpCutMultiplier?: number;
+    /** Seconds before a multi-jump becomes available (default 0.15). */
+    multiJumpWindow?: number;
+    /** Max slope angle in degrees the KCC can climb (default 50). */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default 40). */
+    slopeSlideAngle?: number;
+    /** Autostep max height in world units; 0 disables (default 0.3). */
+    autostepHeight?: number;
+    /** Minimum unobstructed width for an autostep (default 0.1). */
+    autostepMinWidth?: number;
+    /** Snap-to-ground distance in world units; 0 disables (default 0.3). */
+    snapToGroundDistance?: number;
+    /** KCC collision offset between collider and environment (default 0.05). */
+    characterOffset?: number;
+    /** Collider local offset X (fallback / override). */
+    offsetX?: number;
+    /** Collider local offset Y (fallback / override). */
+    offsetY?: number;
+    /** Collider local offset Z (fallback / override). */
+    offsetZ?: number;
+    /** 0 = auto-read attached collider; 1 = use stored shape fields. */
+    shapeSource?: number;
+}
+declare const StagePlatformerShapeSource: {
+    readonly Auto: 0;
+    readonly Override: 1;
+};
+interface StagePlatformer2DOptions {
+    halfHeight: number;
+    radius: number;
+    walkSpeed: number;
+    runSpeed: number;
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.1). */
+    jumpBufferTime?: number;
+    /** Velocity multiplier applied on early jump release (default 0.5). */
+    jumpCutMultiplier?: number;
+    /** Seconds before a multi-jump becomes available (default 0.15). */
+    multiJumpWindow?: number;
+    /** Max slope angle in degrees the KCC can climb (default 50). */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default 40). */
+    slopeSlideAngle?: number;
+    /** Autostep max height in world units; 0 disables (default 0.25). */
+    autostepHeight?: number;
+    /** Minimum unobstructed width for an autostep (default 0.05). */
+    autostepMinWidth?: number;
+    /** Snap-to-ground distance in world units; 0 disables (default 0.2). */
+    snapToGroundDistance?: number;
+    /** KCC collision offset between collider and environment (default 0.05). */
+    characterOffset?: number;
+    /** Collider local offset X (fallback / override). */
+    offsetX?: number;
+    /** Collider local offset Y (fallback / override). */
+    offsetY?: number;
+    /** Collider local offset Z (fallback / override). */
+    offsetZ?: number;
+    /** 0 = auto-read attached collider; 1 = use stored shape fields. */
+    shapeSource?: number;
+}
+interface StageFirstPersonOptions {
+    walkSpeed: number;
+    runSpeed: number;
+    eyeHeight: number;
+    lookSensitivity: number;
+}
+interface StageFirstPersonInput {
+    moveX: number;
+    moveZ: number;
+    lookYawDelta: number;
+    lookPitchDelta: number;
+    run: boolean;
+}
+/** Button bits for the slot-indexed input buffer's bitmask field. */
+declare const STAGE_INPUT_BUTTON_JUMP = 1;
+declare const STAGE_INPUT_BUTTON_RUN = 2;
+/**
+ * Decoded per-slot behavior snapshot written by the runtime after every
+ * step: movement fields come from whichever character behavior the entity
+ * has (platformer 3D/2D, jumper 3D/2D); first-person fills yaw/pitch.
+ * Values reflect the end of the previous `step()` (one-frame read lag).
+ */
+interface StageBehaviorSnapshot {
+    grounded: boolean;
+    fsmState: number;
+    jumpCount: number;
+    verticalVelocity: number;
+    speed: number;
+    yaw: number;
+    pitch: number;
+}
+/**
+ * Wasm fast-path backrefs a behavior system stores on its `BehaviorRef` every
+ * frame so descriptor handles can read the runtime snapshot buffer instead of
+ * a duplicate TS FSM (or hardcoded defaults).
+ */
+interface WasmSnapshotBackref {
+    __wasmStage?: BehaviorRuntime | null;
+    __entity?: {
+        runtimeHandle?: number;
+    } | null;
+}
+/**
+ * Read the behavior snapshot for the entity a `BehaviorRef` is linked to.
+ * Returns `null` off the wasm fast path (no stage runtime / no
+ * `runtimeHandle` / no snapshot yet), in which case handles should fall back
+ * to their TS FSM.
+ */
+declare function readBehaviorSnapshot(ref: object): StageBehaviorSnapshot | null;
+/**
+ * Runtime surface behavior systems rely on. `WasmStageRuntime` is the real
+ * wasm-backed implementation; `MockBehaviorRuntime` (see
+ * `./mock-behavior-runtime`) implements the same contract for unit tests, so
+ * descriptors stay runtime-agnostic.
+ */
+interface BehaviorRuntime {
+    attachRhythm(slot: number, abilities: readonly RhythmAbility[], options?: RhythmOptions): boolean;
+    detachRhythm(slot: number): boolean;
+    queryRhythm(slot: number): RhythmState | null;
+    rhythmAction(slot: number, action: RhythmAction): boolean;
+    attachMatching(slot: number, abilities: readonly MatchingAbility[], options?: MatchingOptions): boolean;
+    detachMatching(slot: number): boolean;
+    queryMatching(slot: number): MatchingState | null;
+    matchingAction(slot: number, action: MatchingAction): boolean;
+    attachLife(slot: number, abilities: readonly LifeAbility[], options?: LifeOptions): boolean;
+    detachLife(slot: number): boolean;
+    queryLife(slot: number): LifeState | null;
+    lifeAction(slot: number, action: LifeAction): boolean;
+    attachDefense(slot: number, abilities: readonly DefenseAbility[], options?: DefenseOptions): boolean;
+    detachDefense(slot: number): boolean;
+    queryDefense(slot: number): DefenseState | null;
+    defenseAction(slot: number, action: DefenseAction): boolean;
+    attachSquad(slot: number, abilities: readonly SquadAbility[], options?: SquadOptions): boolean;
+    detachSquad(slot: number): boolean;
+    querySquad(slot: number): SquadState | null;
+    squadAction(slot: number, action: SquadAction): boolean;
+    attachTactics(slot: number, abilities: readonly TacticsAbility[], options?: TacticsOptions): boolean;
+    detachTactics(slot: number): boolean;
+    queryTactics(slot: number): TacticsState | null;
+    tacticsAction(slot: number, action: TacticsAction): boolean;
+    attachBattle(slot: number, abilities: readonly BattleAbility[], options?: BattleOptions): boolean;
+    detachBattle(slot: number): boolean;
+    queryBattle(slot: number): BattleState | null;
+    battleAction(slot: number, action: BattleAction): boolean;
+    attachRpg(slot: number, abilities: readonly RpgAbility[], options?: RpgOptions): boolean;
+    detachRpg(slot: number): boolean;
+    queryRpg(slot: number): RpgState | null;
+    rpgAction(slot: number, action: RpgAction): boolean;
+    attachSports(slot: number, abilities: readonly SportsAbility[], options?: SportsOptions): boolean;
+    detachSports(slot: number): boolean;
+    querySports(slot: number): SportsState | null;
+    sportsAction(slot: number, action: SportsAction): boolean;
+    attachSkate(slot: number, abilities: readonly SkateAbility[], options?: SkateOptions): boolean;
+    detachSkate(slot: number): boolean;
+    querySkate(slot: number): SkateState | null;
+    skateAction(slot: number, action: SkateAction): boolean;
+    attachRacing(slot: number, abilities: readonly RacingAbility[], options?: RacingOptions): boolean;
+    detachRacing(slot: number): boolean;
+    queryRacing(slot: number): RacingState | null;
+    racingAction(slot: number, action: RacingAction): boolean;
+    attachSurvival(slot: number, abilities: readonly SurvivalAbility[], options?: SurvivalOptions): boolean;
+    detachSurvival(slot: number): boolean;
+    querySurvival(slot: number): SurvivalState | null;
+    survivalAction(slot: number, action: SurvivalAction): boolean;
+    attachCity(slot: number, abilities: readonly CityAbility[], options?: CityOptions): boolean;
+    detachCity(slot: number): boolean;
+    queryCity(slot: number): CityState | null;
+    cityLink(slot: number, other: number, kind: number, data: readonly number[]): boolean;
+    cityUnlink(slot: number, other: number, kind: number): boolean;
+    cityCommand(slot: number, kind: number, data: readonly number[]): boolean;
+    citySignal(slot: number, source: number, kind: number, sequence: number, data: readonly number[]): boolean;
+    attachEncounters(slot: number, abilities: readonly EncounterAbility[], options?: EncounterOptions): boolean;
+    detachEncounters(slot: number): boolean;
+    queryEncounters(slot: number): EncounterState | null;
+    encounterLink(slot: number, other: number, kind: number, data: readonly number[]): boolean;
+    encounterUnlink(slot: number, other: number, kind: number): boolean;
+    encounterCommand(slot: number, kind: number, value: number, data?: readonly number[]): boolean;
+    encounterHit(slot: number, source: number, region: number | null, hit: EncounterHit): boolean;
+    attachWeapons(slot: number, abilities: readonly WeaponAbility[], options?: WeaponOptions): boolean;
+    detachWeapons(slot: number): boolean;
+    weaponInput(slot: number, input: WeaponInput): boolean;
+    weaponMode(slot: number, index: 0 | 1, mode: WeaponMode): boolean;
+    weaponDamage(slot: number, amount: number, source: number | null): boolean;
+    weaponSurface(slot: number, surface: WeaponSurface): boolean;
+    launchWeaponProjectile(owner: number, slot: number, kind: WeaponProjectileKind, options?: WeaponProjectileOptions): boolean;
+    queryWeapons(slot: number): WeaponState | null;
+    queryWeaponProjectile(slot: number): WeaponProjectileState | null;
+    weaponCameraIntent(slot: number): WeaponCameraIntent | null;
+    attachCombat(slot: number, abilities: readonly CombatAbility[], options?: CombatOptions): boolean;
+    detachCombat(slot: number): boolean;
+    combatInput(slot: number, input: CombatInput): boolean;
+    combatAttack(slot: number, index: number, attack: CombatAttack): boolean;
+    combatHit(slot: number, hit: CombatHit, source: number | null): boolean;
+    queryCombat(slot: number): CombatState | null;
+    attachPuzzle(slot: number, ability: PuzzleAbility, options?: PuzzleOptions): boolean;
+    detachPuzzle(slot: number): boolean;
+    queryPuzzle(slot: number): PuzzleState | null;
+    puzzleCommand(slot: number, command: PuzzleCommand): boolean;
+    puzzleLink(slot: number, other: number | null): boolean;
+    puzzleSegments(slot: number): PuzzleSegment[];
+    attachAdventure(slot: number, abilities: readonly AdventureAbility[], options?: AdventureOptions): boolean;
+    detachAdventure(slot: number): boolean;
+    queryAdventure(slot: number): AdventureState | null;
+    writeAdventureInput(slot: number, input: AdventureInput): void;
+    setAdventureObject(slot: number, object: AdventureObject | null): boolean;
+    queryAdventureObject(slot: number): AdventureObjectState | null;
+    adventureProgress(slot: number, kind: number, key: number, value?: number): number;
+    attachEnvironment(slot: number, abilities: readonly EnvironmentAbility[], options?: EnvironmentOptions): boolean;
+    detachEnvironment(slot: number): boolean;
+    queryEnvironment(slot: number): EnvironmentState | null;
+    writeEnvironmentInput(slot: number, input: EnvironmentInput): void;
+    setEnvironmentVolume(slot: number, volume: EnvironmentVolume | null): boolean;
+    setTubeRail(slot: number, rail: TubeRail | null): boolean;
+    attachAcrobatics(slot: number, abilities: readonly AcrobaticsAbility[], options?: AcrobaticsOptions): boolean;
+    queryAcrobatics(slot: number): AcrobaticsState | null;
+    detachAcrobatics(slot: number): boolean;
+    setTraversalSurface(slot: number, kind: 'pole' | 'ceiling' | null): boolean;
+    setPossessable(slot: number, enabled: boolean): boolean;
+    startPossession(owner: number, target: number, seconds?: number): boolean;
+    endPossession(owner: number): boolean;
+    queryPossession(owner: number): {
+        targetSlot: number;
+        remaining: number;
+    } | null;
+    getPose(handle: number, out?: StagePose): StagePose | null;
+    setPosition(handle: number, x: number, y: number, z: number): boolean;
+    setRotation(handle: number, x: number, y: number, z: number, w: number): boolean;
+    writeInputAxes(handle: number, axisA: number, axisB: number): boolean;
+    writeInputLook(handle: number, yawDelta: number, pitchDelta: number): boolean;
+    /** Write reserved input slots (thruster world-space vector X/Y). */
+    writeInputReserved(handle: number, reservedA: number, reservedB: number): boolean;
+    writeInputButton(handle: number, buttonMask: number, pressed: boolean): boolean;
+    /** Read the per-slot behavior snapshot written at the end of the previous step. */
+    readSnapshot(handle: number, out?: StageBehaviorSnapshot): StageBehaviorSnapshot | null;
+    attachThruster(handle: number, opts: StageThrusterOptions): boolean;
+    setThrusterInput(handle: number, thrust: number, rotate: number, vectorX?: number, vectorY?: number): void;
+    attachTopDown(handle: number, opts: StageTopDownOptions): boolean;
+    setTopDownInput(handle: number, moveX: number, moveY: number): void;
+    attachShooter2D(handle: number, opts: StageShooter2DOptions): boolean;
+    attachScreenWrap(handle: number, opts: StageScreenWrapOptions): boolean;
+    queryScreenWrap(handle: number): {
+        fsm: number;
+        lastWrappedAxes: number;
+    } | null;
+    attachWorldBoundary(handle: number, dim: StageBoundaryDimValue, opts: StageWorldBoundaryOptions): boolean;
+    queryWorldBoundary(handle: number): {
+        hits: number;
+        clamped: [number, number, number];
+    } | null;
+    attachRicochet(handle: number, dim: StageRicochetDimValue, opts: StageRicochetOptions): boolean;
+    attachPlatformer3D(handle: number, opts: StagePlatformer3DOptions): boolean;
+    setPlatformer3DInputAxes(handle: number, moveX: number, moveZ: number): void;
+    setPlatformer3DInputButtons(handle: number, jump: boolean, run: boolean): void;
+    attachPlatformer2D(handle: number, opts: StagePlatformer2DOptions): boolean;
+    setPlatformer2DInputAxes(handle: number, moveX: number): void;
+    setPlatformer2DInputButtons(handle: number, jump: boolean, run: boolean): void;
+    attachFirstPerson(handle: number, opts: StageFirstPersonOptions): boolean;
+    setFirstPersonInput(handle: number, input: StageFirstPersonInput): void;
+    attachJumper2D(handle: number, opts: StageJumper2DOptions): boolean;
+    setJumper2DInput(handle: number, jumpPressed: boolean): void;
+    attachJumper3D(handle: number, opts: StageJumper3DOptions): boolean;
+    setJumper3DInput(handle: number, jumpPressed: boolean): void;
+}
+/** Default options used when constructing a wasm-backed Stage runtime. */
+interface WasmStageRuntimeOptions {
+    /** Native implementations required by the selected public behaviors. */
+    requiredBehaviors?: readonly RuntimeBehaviorName[];
+    initialCapacity?: number;
+    gravity?: readonly [number, number, number];
+    imports?: WebAssembly.Imports;
+    /**
+     * Custom wasm source. Defaults to the `zylem_runtime.wasm` bundled with
+     * `@zylem/runtime`.
+     */
+    source?: RequestInfo | URL | ArrayBuffer | Uint8Array;
+}
+type StageEventTypeValue = (typeof StageEventType)[keyof typeof StageEventType];
+/** One decoded event drained from the runtime's per-step event buffer. */
+interface StageEvent {
+    type: StageEventTypeValue;
+    primarySlot: number | null;
+    secondarySlot: number | null;
+    payload: [number, number, number];
+}
+/**
+ * Decoded view of one entity's slot in the unified render buffer.
+ *
+ * Mirrors the `STAGE_RENDER_STRIDE` (12-float) packing documented in
+ * `runtime/stage/render.rs`:
+ * `[0..3]` position, `[3..7]` rotation xyzw, `[7]` uniform scale,
+ * `[8..11]` custom0..custom2 (shading hints), `[11]` custom3 sleeping flag
+ * (1.0 = sleeping).
+ */
+interface StageRenderSlot {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: number;
+    custom: [number, number, number, number];
+    /** True when custom[3] indicates the body is sleeping. */
+    isSleeping: boolean;
+}
+/**
+ * Read a single entity slot out of a unified-Stage render buffer view.
+ *
+ * @param view   The `Float32Array` over wasm memory (e.g. `WasmStageRuntime.render`).
+ * @param slot   The entity's wasm slot id (its `runtimeHandle`).
+ * @param out    Optional target object to write into (avoids per-call allocation).
+ * @returns The decoded slot, or `null` when the slot is out of range.
+ */
+declare function readStageRenderSlot(view: Float32Array, slot: number, out?: StageRenderSlot): StageRenderSlot | null;
+interface StageBodyConfig {
+    kind: StageBodyKindValue;
+    position: readonly [number, number, number];
+    rotation: readonly [number, number, number, number];
+    linearDamping: number;
+    angularDamping: number;
+    gravityScale: number;
+    canSleep: boolean;
+    ccdEnabled: boolean;
+    lockRotation: readonly [boolean, boolean, boolean];
+    lockTranslation: readonly [boolean, boolean, boolean];
+}
+type StageColliderShape = {
+    type: 'box';
+    halfExtents: readonly [number, number, number];
+} | {
+    type: 'sphere';
+    radius: number;
+} | {
+    type: 'capsule';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cylinder';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cone';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'convexHull';
+    vertices: Float32Array;
+} | {
+    type: 'trimesh';
+    vertices: Float32Array;
+    indices: Uint32Array;
+} | {
+    type: 'heightfield';
+    rows: number;
+    cols: number;
+    scale: readonly [number, number, number];
+    heights: Float32Array;
+};
+interface StageColliderConfig {
+    shape: StageColliderShape;
+    offset: readonly [number, number, number];
+    friction: number;
+    restitution: number;
+    sensor: boolean;
+    /** Packed interaction-groups: high 16 bits = membership, low 16 bits = filter. */
+    collisionGroups: number;
+}
+/** Result of a physics raycast against the stage. */
+interface StageRaycastHit {
+    slot: number;
+    distance: number;
+    normal: [number, number, number];
+}
+/** Body introspection payload for debug tooling. */
+interface StageBodyInfo {
+    bodyType: number;
+    mass: number;
+    isSleeping: boolean;
+    isEnabled: boolean;
+    linearVelocity: [number, number, number];
+}
+/** Line-list wireframe for physics debug rendering. */
+interface StageDebugRender {
+    /** `[x, y, z]` per vertex, two vertices per line. */
+    vertices: Float32Array;
+    /** RGBA per vertex. */
+    colors: Float32Array;
+}
+/**
+ * Owns the wasm instance plus the live float-views over its render / event /
+ * pose / scratch buffers. One instance per logical stage; each stage gets
+ * its own `WebAssembly.Instance` so the singleton inside `stage_ffi.rs`
+ * stays single-stage scoped (today's `thread_local!` contract).
+ */
+declare class WasmStageRuntime implements BehaviorRuntime {
+    readonly exports: StageWasmExports;
+    readonly compatibility: RuntimeCompatibility;
+    private readonly memory;
+    private renderView;
+    private inputView;
+    private snapshotView;
+    private eventView;
+    private poseView;
+    private vec3View;
+    private queryView;
+    private scratchView;
+    constructor(exports: StageWasmExports, options?: WasmStageRuntimeOptions);
+    /** Recreate typed views over wasm memory. Call after step() or whenever memory may have grown. */
+    refreshViews(): void;
+    /** Step the simulation by `dt` seconds. Refreshes views afterwards. */
+    step(dt: number): number;
+    dispose(): void;
+    get tickCount(): number;
+    get activeCount(): number;
+    setGravity(x: number, y: number, z: number): void;
+    /**
+     * Toggle per-step collision-event collection in the wasm stage. Hosts
+     * with no collision listeners should disable it — with thousands of
+     * touching bodies the per-step contact-pair hashing is a significant
+     * fraction of `step()`.
+     */
+    setEventsEnabled(enabled: boolean): void;
+    /** Cap Rapier contact solver iterations (default 4). */
+    setSolverIterations(iterations: number): void;
+    /**
+     * Override sleep activation thresholds for sleep-capable dynamic bodies.
+     * Higher velocity thresholds / lower `timeUntilSleep` put piles to sleep
+     * sooner.
+     */
+    setSleepThresholds(normalizedLinearThreshold: number, angularThreshold: number, timeUntilSleep: number): void;
+    /** Number of awake (non-sleeping) dynamic rigid bodies. */
+    awakeDynamicCount(): number;
+    createEntity(): number;
+    destroyEntity(slot: number): boolean;
+    attachBody(slot: number, config: StageBodyConfig): boolean;
+    addCollider(slot: number, config: StageColliderConfig): boolean;
+    private stageScratch;
+    private stageScratchIndices;
+    getPose(slot: number, out?: StagePose): StagePose | null;
+    setPosition(slot: number, x: number, y: number, z: number): boolean;
+    setRotation(slot: number, x: number, y: number, z: number, w: number): boolean;
+    setLinearVelocity(slot: number, x: number, y: number, z: number): boolean;
+    getLinearVelocity(slot: number, out?: [number, number, number]): [number, number, number] | null;
+    setAngularVelocity(slot: number, x: number, y: number, z: number): boolean;
+    getAngularVelocity(slot: number, out?: [number, number, number]): [number, number, number] | null;
+    applyImpulse(slot: number, x: number, y: number, z: number): boolean;
+    /** Cast a ray against the physics world. Returns the closest hit or `null`. */
+    castRay(origin: readonly [number, number, number], dir: readonly [number, number, number], maxDistance: number, solidOnly?: boolean): StageRaycastHit | null;
+    /** Body introspection for debug tooling. */
+    getBodyInfo(slot: number): StageBodyInfo | null;
+    /** Wireframe debug render of every collider (all shapes). */
+    getDebugRender(): StageDebugRender | null;
+    /** Read-only view over the render buffer; one slot occupies {@link STAGE_RENDER_STRIDE} floats. */
+    get render(): Float32Array;
+    get renderStride(): number;
+    /**
+     * Decode a single entity slot from the live render buffer. Convenience
+     * wrapper over {@link readStageRenderSlot} bound to this runtime's view.
+     */
+    readRenderSlot(slot: number, out?: StageRenderSlot): StageRenderSlot | null;
+    /** Drain the wasm event buffer into a fresh array of typed events. */
+    drainEvents(): StageEvent[];
+    /** Writable view over the slot-indexed input buffer ({@link STAGE_INPUT_STRIDE} floats/slot). */
+    get input(): Float32Array;
+    get inputStride(): number;
+    /** Read-only view over the per-slot behavior snapshot buffer ({@link STAGE_SNAPSHOT_STRIDE} floats/slot). */
+    get snapshot(): Float32Array;
+    get snapshotStride(): number;
+    /**
+     * Write the primary movement axes for a slot into the slot-indexed input
+     * buffer and mark the slot dirty. Field-scoped (doesn't touch look
+     * deltas or buttons) so multiple behaviors composed on one entity can
+     * each write their part.
+     */
+    writeInputAxes(slot: number, axisA: number, axisB: number): boolean;
+    /** Write the look deltas (first-person yaw/pitch) for a slot. */
+    writeInputLook(slot: number, yawDelta: number, pitchDelta: number): boolean;
+    /** Write reserved input slots (thruster world-space vector X/Y). */
+    writeInputReserved(slot: number, reservedA: number, reservedB: number): boolean;
+    /**
+     * Set or clear one button bit ({@link STAGE_INPUT_BUTTON_JUMP} /
+     * {@link STAGE_INPUT_BUTTON_RUN}) in a slot's input bitmask.
+     */
+    writeInputButton(slot: number, buttonMask: number, pressed: boolean): boolean;
+    /**
+     * Decode a slot's behavior snapshot from the buffer written at the end of
+     * the previous step. Returns `null` when the slot has no behavior data.
+     */
+    readSnapshot(slot: number, out?: StageBehaviorSnapshot): StageBehaviorSnapshot | null;
+    get queryScratch(): Float32Array;
+    attachCooldown(slot: number): boolean;
+    registerCooldown(slot: number, id: number, durationSeconds: number, immediate?: boolean): boolean;
+    fireCooldown(slot: number, id: number): boolean;
+    resetCooldown(slot: number, id: number): boolean;
+    cooldownRemaining(slot: number, id: number): number;
+    attachWorldBoundary(slot: number, dim: StageBoundaryDimValue, bounds: StageWorldBoundaryOptions): boolean;
+    queryWorldBoundary(slot: number): {
+        hits: number;
+        clamped: [number, number, number];
+    } | null;
+    attachScreenWrap(slot: number, opts: StageScreenWrapOptions): boolean;
+    queryScreenWrap(slot: number): {
+        fsm: number;
+        lastWrappedAxes: number;
+    } | null;
+    attachRicochet(slot: number, dim: StageRicochetDimValue, opts: StageRicochetOptions): boolean;
+    queryRicochet(slot: number): {
+        bounces: number;
+        lastKind: number;
+    } | null;
+    attachThruster(slot: number, opts: StageThrusterOptions): boolean;
+    setThrusterInput(slot: number, thrust: number, turn: number, vectorX?: number, vectorY?: number): void;
+    queryThruster(slot: number): {
+        headingRad: number;
+        speed: number;
+    } | null;
+    attachRhythm(slot: number, abilities: readonly RhythmAbility[], options?: RhythmOptions): boolean;
+    detachRhythm(slot: number): boolean;
+    rhythmAction(slot: number, action: RhythmAction): boolean;
+    queryRhythm(slot: number): RhythmState | null;
+    attachMatching(slot: number, abilities: readonly MatchingAbility[], options?: MatchingOptions): boolean;
+    detachMatching(slot: number): boolean;
+    matchingAction(slot: number, action: MatchingAction): boolean;
+    queryMatching(slot: number): MatchingState | null;
+    attachLife(slot: number, abilities: readonly LifeAbility[], options?: LifeOptions): boolean;
+    detachLife(slot: number): boolean;
+    lifeAction(slot: number, action: LifeAction): boolean;
+    queryLife(slot: number): LifeState | null;
+    attachDefense(slot: number, abilities: readonly DefenseAbility[], options?: DefenseOptions): boolean;
+    detachDefense(slot: number): boolean;
+    defenseAction(slot: number, action: DefenseAction): boolean;
+    queryDefense(slot: number): DefenseState | null;
+    attachSquad(slot: number, abilities: readonly SquadAbility[], options?: SquadOptions): boolean;
+    detachSquad(slot: number): boolean;
+    squadAction(slot: number, action: SquadAction): boolean;
+    querySquad(slot: number): SquadState | null;
+    attachTactics(slot: number, abilities: readonly TacticsAbility[], options?: TacticsOptions): boolean;
+    detachTactics(slot: number): boolean;
+    tacticsAction(slot: number, action: TacticsAction): boolean;
+    queryTactics(slot: number): TacticsState | null;
+    attachBattle(slot: number, abilities: readonly BattleAbility[], options?: BattleOptions): boolean;
+    detachBattle(slot: number): boolean;
+    battleAction(slot: number, action: BattleAction): boolean;
+    queryBattle(slot: number): BattleState | null;
+    attachRpg(slot: number, abilities: readonly RpgAbility[], options?: RpgOptions): boolean;
+    detachRpg(slot: number): boolean;
+    rpgAction(slot: number, action: RpgAction): boolean;
+    queryRpg(slot: number): RpgState | null;
+    attachSports(slot: number, abilities: readonly SportsAbility[], options?: SportsOptions): boolean;
+    detachSports(slot: number): boolean;
+    sportsAction(slot: number, action: SportsAction): boolean;
+    querySports(slot: number): SportsState | null;
+    attachSkate(slot: number, abilities: readonly SkateAbility[], options?: SkateOptions): boolean;
+    detachSkate(slot: number): boolean;
+    skateAction(slot: number, action: SkateAction): boolean;
+    querySkate(slot: number): SkateState | null;
+    attachRacing(slot: number, abilities: readonly RacingAbility[], options?: RacingOptions): boolean;
+    detachRacing(slot: number): boolean;
+    racingAction(slot: number, action: RacingAction): boolean;
+    queryRacing(slot: number): RacingState | null;
+    attachSurvival(slot: number, abilities: readonly SurvivalAbility[], options?: SurvivalOptions): boolean;
+    detachSurvival(slot: number): boolean;
+    survivalAction(slot: number, action: SurvivalAction): boolean;
+    querySurvival(slot: number): SurvivalState | null;
+    attachCity(slot: number, abilities: readonly CityAbility[], options?: CityOptions): boolean;
+    detachCity(slot: number): boolean;
+    private cityData;
+    cityLink(slot: number, other: number, kind: number, data: readonly number[]): boolean;
+    cityUnlink(slot: number, other: number, kind: number): boolean;
+    cityCommand(slot: number, kind: number, data: readonly number[]): boolean;
+    citySignal(slot: number, source: number, kind: number, sequence: number, data: readonly number[]): boolean;
+    queryCity(slot: number): CityState | null;
+    attachEncounters(slot: number, abilities: readonly EncounterAbility[], options?: EncounterOptions): boolean;
+    detachEncounters(slot: number): boolean;
+    encounterLink(slot: number, other: number, kind: number, data: readonly number[]): boolean;
+    encounterUnlink(slot: number, other: number, kind: number): boolean;
+    encounterCommand(slot: number, kind: number, value: number, data?: readonly number[]): boolean;
+    encounterHit(slot: number, source: number, region: number | null, hit: EncounterHit): boolean;
+    queryEncounters(slot: number): EncounterState | null;
+    attachWeapons(slot: number, abilities: readonly WeaponAbility[], options?: WeaponOptions): boolean;
+    detachWeapons(slot: number): boolean;
+    weaponInput(slot: number, input: WeaponInput): boolean;
+    weaponMode(slot: number, index: 0 | 1, mode: WeaponMode): boolean;
+    weaponDamage(slot: number, amount: number, source: number | null): boolean;
+    weaponSurface(slot: number, surface: WeaponSurface): boolean;
+    launchWeaponProjectile(owner: number, slot: number, kind: WeaponProjectileKind, options?: WeaponProjectileOptions): boolean;
+    queryWeapons(slot: number): WeaponState | null;
+    queryWeaponProjectile(slot: number): WeaponProjectileState | null;
+    weaponCameraIntent(slot: number): WeaponCameraIntent | null;
+    attachCombat(slot: number, abilities: readonly CombatAbility[], options?: CombatOptions): boolean;
+    detachCombat(slot: number): boolean;
+    combatInput(slot: number, input: CombatInput): boolean;
+    combatAttack(slot: number, index: number, attack: CombatAttack): boolean;
+    combatHit(slot: number, hit: CombatHit, source: number | null): boolean;
+    queryCombat(slot: number): CombatState | null;
+    attachPuzzle(slot: number, ability: PuzzleAbility, options?: PuzzleOptions): boolean;
+    detachPuzzle(slot: number): boolean;
+    queryPuzzle(slot: number): PuzzleState | null;
+    puzzleCommand(slot: number, command: PuzzleCommand): boolean;
+    puzzleLink(slot: number, other: number | null): boolean;
+    puzzleSegments(slot: number): PuzzleSegment[];
+    attachAdventure(slot: number, abilities: readonly AdventureAbility[], o?: AdventureOptions): boolean;
+    detachAdventure(slot: number): boolean;
+    queryAdventure(slot: number): AdventureState | null;
+    writeAdventureInput(slot: number, input: AdventureInput): void;
+    setAdventureObject(slot: number, object: AdventureObject | null): boolean;
+    queryAdventureObject(slot: number): AdventureObjectState | null;
+    adventureProgress(slot: number, kind: number, key: number, value?: number): number;
+    private refreshEnvironmentViews;
+    attachEnvironment(slot: number, abilities: readonly EnvironmentAbility[], o?: EnvironmentOptions): boolean;
+    detachEnvironment(slot: number): boolean;
+    queryEnvironment(slot: number): EnvironmentState | null;
+    writeEnvironmentInput(slot: number, input: EnvironmentInput): void;
+    setEnvironmentVolume(slot: number, volume: EnvironmentVolume | null): boolean;
+    setTubeRail(slot: number, rail: TubeRail | null): boolean;
+    attachAcrobatics(slot: number, abilities: readonly AcrobaticsAbility[], opts?: AcrobaticsOptions): boolean;
+    queryAcrobatics(slot: number): AcrobaticsState | null;
+    detachAcrobatics(slot: number): boolean;
+    setTraversalSurface(slot: number, kind: 'pole' | 'ceiling' | null): boolean;
+    setPossessable(slot: number, enabled: boolean): boolean;
+    startPossession(owner: number, target: number, seconds?: number): boolean;
+    endPossession(owner: number): boolean;
+    queryPossession(owner: number): {
+        targetSlot: number;
+        remaining: number;
+    } | null;
+    attachTopDown(slot: number, opts: StageTopDownOptions): boolean;
+    setTopDownInput(slot: number, axisA: number, axisB: number): void;
+    attachJumper2D(slot: number, opts: StageJumper2DOptions): boolean;
+    setJumper2DInput(slot: number, jumpPressed: boolean): void;
+    queryJumper2D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        coyote: number;
+        jumpBuffer: number;
+    } | null;
+    attachJumper3D(slot: number, opts: StageJumper3DOptions): boolean;
+    setJumper3DInput(slot: number, jump: boolean): void;
+    queryJumper3D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        verticalVelocity: number;
+    } | null;
+    attachShooter2D(slot: number, opts: StageShooter2DOptions): boolean;
+    fireShooter2D(slot: number, x: number, y: number, z: number, yaw: number): boolean;
+    queryShooter2D(slot: number): {
+        cooldown: number;
+        firedCount: number;
+    } | null;
+    attachPlatformer3D(slot: number, opts: StagePlatformer3DOptions): boolean;
+    setPlatformer3DInputAxes(slot: number, moveX: number, moveZ: number): void;
+    setPlatformer3DInputButtons(slot: number, jump: boolean, run: boolean): void;
+    queryPlatformer3D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        fsmState: number;
+        speed: number;
+    } | null;
+    attachPlatformer2D(slot: number, opts: StagePlatformer2DOptions): boolean;
+    setPlatformer2DInputAxes(slot: number, moveX: number): void;
+    setPlatformer2DInputButtons(slot: number, jump: boolean, run: boolean): void;
+    queryPlatformer2D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        fsmState: number;
+        verticalVelocity: number;
+    } | null;
+    attachFirstPerson(slot: number, opts: StageFirstPersonOptions): boolean;
+    setFirstPersonInput(slot: number, input: StageFirstPersonInput): void;
+    queryFirstPerson(slot: number): {
+        yaw: number;
+        pitch: number;
+        speed: number;
+        eyeHeight: number;
+    } | null;
+}
+/**
+ * Load the bundled `@zylem/runtime` wasm (or a custom `source`), instantiate
+ * it, and construct a `WasmStageRuntime` around the exports.
+ */
+declare function createWasmStageRuntime(options?: WasmStageRuntimeOptions): Promise<WasmStageRuntime>;
+
+/**
+ * Structural stand-in for the engine world wrapper. The engine's world
+ * delegate exposes an entity lookup map; behaviors only rely on this slice.
+ *
+ * The map value is intentionally `unknown` (not the `GameEntity` stub class):
+ * the engine's concrete entity class is a different nominal type, and systems
+ * that iterate the map narrow entities themselves.
+ */
+interface ZylemWorld {
+    collisionMap?: Map<string, unknown>;
+}
+
+/**
+ * BehaviorSystem Interface
+ *
+ * Legacy behavior systems reserved the first `update` argument for an ECS world
+ * handle; it is always `undefined` now.
+ */
+/**
+ * A behavior system that processes entities with specific components.
+ *
+ * @example
+ * ```typescript
+ * class ThrusterSystem implements BehaviorSystem {
+ *   update(_ecs: unknown, delta: number): void {
+ *     // Iterate behavior links, push intent into wasm runtime, etc.
+ *   }
+ * }
+ * ```
+ */
+interface BehaviorSystem {
+    /** Optional eager initialization when a behavior link is registered on a live entity */
+    attach?(link: BehaviorEntityLink): void;
+    /** Called once per frame. The first argument is always `undefined` (reserved legacy slot). */
+    update(ecs: unknown, delta: number): void;
+    /**
+     * Called once per frame after the simulation has stepped and before the
+     * host syncs render poses. Systems that need this frame's post-step state
+     * (e.g. wasm-side teleports) run here instead of in `update`.
+     */
+    postUpdate?(ecs: unknown, delta: number): void;
+    /** Optional cleanup when a behavior link is detached from a live entity */
+    detach?(link: BehaviorEntityLink): void;
+    /** Optional cleanup when stage is destroyed */
+    destroy?(ecs?: unknown): void;
+}
+/**
+ * Runtime link between a spawned entity and one of its behavior refs.
+ * Systems can iterate these links to avoid scanning all world entities.
+ */
+interface BehaviorEntityLink {
+    entity: any;
+    ref: any;
+}
+/**
+ * Context provided to behavior-system factories.
+ *
+ * After the runtime-only stage migration, `wasmStage` is the source of
+ * truth — descriptors should call `wasmStage.attach<X>(handle, opts)` /
+ * `wasmStage.query<X>(handle)` from inside the system instead of touching
+ * `entity.body` directly. The legacy `world` / `scene` fields remain for
+ * unmigrated descriptors.
+ */
+interface BehaviorSystemContext {
+    world: ZylemWorld | null;
+    /** Host scene wrapper (engine-specific); behaviors only call `add`/`remove`-style methods on it. */
+    scene: any;
+    /** Wasm-driven Stage runtime; omitted when the stage has no wasm module. */
+    wasmStage?: BehaviorRuntime | null;
+    /**
+     * Returns live behavior links for a descriptor key.
+     * O(1) lookup into a pre-built stage index.
+     */
+    getBehaviorLinks?: (key: symbol) => Iterable<BehaviorEntityLink>;
+    /**
+     * Host-injected entity factory. Behaviors that spawn entities at runtime
+     * (e.g. destructible-3d fragments) use this instead of importing the engine
+     * entity factory directly, keeping the behavior layer decoupled.
+     */
+    createEntity?: CreateEntityFn;
+    /**
+     * Host-injected accessor for the global game-state bag, passed to entity
+     * lifecycle hooks (e.g. `nodeDestroy`).
+     */
+    getGlobals?: () => any;
+}
+/**
+ * Factory function that creates a BehaviorSystem.
+ * Receives the stage for access to world, scene, etc.
+ */
+type BehaviorSystemFactory<T extends BehaviorSystem = BehaviorSystem> = (stage: BehaviorSystemContext) => T;
+
+/**
+ * BehaviorDescriptor
+ *
+ * Type-safe behavior descriptors that provide options inference.
+ * Used with entity.use() to declaratively attach behaviors to entities.
+ *
+ * Each behavior can define its own handle type via `createHandle`,
+ * providing behavior-specific methods with full type safety.
+ */
+
+/**
+ * Base handle returned by entity.use() for lazy access to behavior runtime.
+ * FSM is null until entity is spawned and components are initialized.
+ */
+interface BaseBehaviorHandle<O extends Record<string, any> = Record<string, any>> {
+    /** Get the FSM instance (null until entity is spawned) */
+    getFSM(): any | null;
+    /** Get the current options */
+    getOptions(): O;
+    /** Access the underlying behavior ref */
+    readonly ref: BehaviorRef<O>;
+}
+/**
+ * Reference to a behavior stored on an entity
+ */
+interface BehaviorRef<O extends Record<string, any> = Record<string, any>> {
+    /** The behavior descriptor */
+    descriptor: BehaviorDescriptor<O, any>;
+    /** Merged options (defaults + overrides) */
+    options: O;
+    /** Optional FSM instance - set lazily when entity is spawned */
+    fsm?: any;
+}
+/**
+ * A typed behavior descriptor that associates a symbol key with:
+ * - Default options (providing type inference)
+ * - A system factory to create the behavior system
+ * - An optional handle factory for behavior-specific methods
+ */
+interface BehaviorDescriptor<O extends Record<string, any> = Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown> {
+    /** Unique symbol identifying this behavior */
+    readonly key: symbol;
+    /** Stable identity and build requirements; optional for existing custom descriptors. */
+    readonly metadata?: BehaviorMetadata;
+    /** Default options (used for type inference) */
+    readonly defaultOptions: O;
+    /** Factory to create the behavior system */
+    readonly systemFactory: any;
+    /**
+     * Optional factory to create behavior-specific handle methods.
+     * These methods are merged into the handle returned by entity.use().
+     */
+    readonly createHandle?: (ref: any) => H;
+}
+/**
+ * The full handle type returned by entity.use().
+ * Combines base handle with behavior-specific methods.
+ */
+type BehaviorHandle<O extends Record<string, any> = Record<string, any>, H extends Record<string, any> = Record<string, never>> = BaseBehaviorHandle<O> & H;
+/**
+ * Configuration for defining a new behavior
+ */
+interface DefineBehaviorConfig<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown> {
+    /** Human-readable name for debugging */
+    name: string;
+    metadata?: BehaviorMetadata;
+    /** Default options - these define the type */
+    defaultOptions: O;
+    /** Factory function to create the system */
+    systemFactory: BehaviorSystemFactory;
+    /**
+     * Optional factory to create behavior-specific handle methods.
+     * The returned object is merged into the handle returned by entity.use().
+     *
+     * @example
+     * ```typescript
+     * createHandle: (ref) => ({
+     *   getLastHits: () => ref.fsm?.getLastHits() ?? null,
+     *   getMovement: (moveX, moveY) => ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },
+     * }),
+     * ```
+     */
+    createHandle?: (ref: BehaviorRef<O>) => H;
+}
+/**
+ * Define a typed behavior descriptor.
+ *
+ * @example
+ * ```typescript
+ * export const WorldBoundary2DBehavior = defineBehavior({
+ *   name: 'world-boundary-2d',
+ *   defaultOptions: { boundaries: { top: 0, bottom: 0, left: 0, right: 0 } },
+ *   systemFactory: (ctx) => new WorldBoundary2DSystem(ctx.world),
+ *   createHandle: (ref) => ({
+ *     getLastHits: () => ref.fsm?.getLastHits() ?? null,
+ *     getMovement: (moveX: number, moveY: number) =>
+ *       ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },
+ *   }),
+ * });
+ *
+ * // Usage - handle has getLastHits and getMovement with full types
+ * const boundary = ship.use(WorldBoundary2DBehavior, { ... });
+ * const hits = boundary.getLastHits(); // Fully typed!
+ * ```
+ */
+declare function defineBehavior<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown>(config: DefineBehaviorConfig<O, H, I>): BehaviorDescriptor<O, H, I>;
+
+export { type CombatState as $, ACROBATICS_ACTIONS as A, BATTLE_ABILITIES as B, type BehaviorRef as C, type BehaviorSystem as D, type BehaviorSystemFactory as E, CITY_ABILITIES as F, CITY_EVENTS as G, CITY_INTENTS as H, CITY_LINKS as I, COMBAT_ABILITIES as J, COMBAT_EVENTS as K, COMBAT_PHASES as L, type CityAbility as M, type CityDanger as N, type CityFootprint as O, type CityLinkKind as P, type CityNoise as Q, type CityOptions as R, type CityPoint as S, type CityState as T, type CityTarget as U, type CityTraffic as V, type CombatAbility as W, type CombatAttack as X, type CombatHit as Y, type CombatInput as Z, type CombatOptions as _, ADVENTURE_ABILITIES as a, RHYTHM_ABILITIES as a$, DEFENSE_ABILITIES as a0, DEFENSE_EVENTS as a1, type DefenseAbility as a2, type DefenseAction as a3, type DefenseEvent as a4, type DefenseOptions as a5, type DefenseReceipt as a6, type DefenseState as a7, type DefenseTarget as a8, type DefenseTile as a9, type LifeAction as aA, type LifeAnimal as aB, type LifeEvent as aC, type LifeFurniture as aD, type LifeMemory as aE, type LifeOptions as aF, type LifePerson as aG, type LifePlot as aH, type LifeSchedule as aI, type LifeState as aJ, type LifeTree as aK, MATCHING_ABILITIES as aL, MATCHING_EVENTS as aM, type MatchingAbility as aN, type MatchingAction as aO, type MatchingCell as aP, type MatchingEvent as aQ, type MatchingOptions as aR, type MatchingState as aS, PUZZLE_ABILITIES as aT, type PuzzleAbility as aU, type PuzzleCommand as aV, type PuzzleOptions as aW, type PuzzleSegment as aX, type PuzzleState as aY, type PuzzleVector as aZ, RACING_ABILITIES as a_, type DefineBehaviorConfig as aa, ENCOUNTER_ABILITIES as ab, ENCOUNTER_EVENTS as ac, ENCOUNTER_INTENTS as ad, ENCOUNTER_LINKS as ae, ENVIRONMENT_ABILITIES as af, ENVIRONMENT_MODES as ag, type EncounterAbility as ah, type EncounterCandidate as ai, type EncounterCover as aj, type EncounterHazard as ak, type EncounterHit as al, type EncounterLinkKind as am, type EncounterOptions as an, type EncounterPhase as ao, type EncounterRegion as ap, type EncounterState as aq, type EnvironmentAbility as ar, type EnvironmentInput as as, type EnvironmentOptions as at, type EnvironmentState as au, type EnvironmentVector as av, type EnvironmentVolume as aw, LIFE_ABILITIES as ax, LIFE_EVENTS as ay, type LifeAbility as az, ADVENTURE_BUTTONS as b, type TacticsUnit as b$, RHYTHM_EVENTS as b0, RPG_ABILITIES as b1, RPG_EVENTS as b2, type RacingAbility as b3, type RacingAction as b4, type RacingOptions as b5, type RacingPoint as b6, type RacingState as b7, type RhythmAbility as b8, type RhythmAction as b9, type SportsPoint as bA, type SportsState as bB, type SquadAbility as bC, type SquadAction as bD, type SquadEvent as bE, type SquadOptions as bF, type SquadState as bG, type SquadTask as bH, type SquadWorker as bI, type SurvivalAbility as bJ, type SurvivalAction as bK, type SurvivalCheckpoint as bL, type SurvivalItem as bM, type SurvivalOptions as bN, type SurvivalPoint as bO, type SurvivalState as bP, TACTICS_ABILITIES as bQ, TACTICS_EVENTS as bR, TRAVERSAL_ABILITIES as bS, type TacticsAbility as bT, type TacticsAction as bU, type TacticsCell as bV, type TacticsEvent as bW, type TacticsOptions as bX, type TacticsPower as bY, type TacticsState as bZ, type TacticsStructure as b_, type RhythmEvent as ba, type RhythmNote as bb, type RhythmOptions as bc, type RhythmState as bd, type RpgAbility as be, type RpgAction as bf, type RpgAffix as bg, type RpgEvent as bh, type RpgItem as bi, type RpgOptions as bj, type RpgPoint as bk, type RpgState as bl, SKATE_ABILITIES as bm, SPORTS_ABILITIES as bn, SQUAD_ABILITIES as bo, SQUAD_EVENTS as bp, SURVIVAL_ABILITIES as bq, type SkateAbility as br, type SkateAction as bs, type SkateOptions as bt, type SkatePhase as bu, type SkatePoint as bv, type SkateState as bw, type SportsAbility as bx, type SportsAction as by, type SportsOptions as bz, ADVENTURE_EVENT_KINDS as c, type StageWorldBoundaryOptions as c$, type TubeRail as c0, WEAPON_ABILITIES as c1, WEAPON_EVENTS as c2, WEAPON_PHASES as c3, type WeaponAbility as c4, type WeaponCameraIntent as c5, type WeaponInput as c6, type WeaponMode as c7, type WeaponOptions as c8, type WeaponProjectileKind as c9, rpgData as cA, rpgOperation as cB, skateData as cC, skateOperation as cD, sportsData as cE, sportsOperation as cF, squadData as cG, squadOperation as cH, survivalData as cI, survivalOperation as cJ, tacticsData as cK, tacticsOperation as cL, weaponButtons as cM, weaponData as cN, weaponModeData as cO, weaponProjectileData as cP, type TransformState as cQ, GameEntity as cR, type VelocityIntentMode as cS, type BehaviorRuntime as cT, type StagePose as cU, type StageBehaviorSnapshot as cV, type StageThrusterOptions as cW, type StageTopDownOptions as cX, type StageShooter2DOptions as cY, type StageScreenWrapOptions as cZ, type StageBoundaryDimValue as c_, type WeaponProjectileOptions as ca, type WeaponProjectileState as cb, type WeaponShot as cc, type WeaponState as cd, type WeaponSurface as ce, battleData as cf, battleOperation as cg, cityData as ch, combatAttackData as ci, combatButtons as cj, combatData as ck, combatHitData as cl, defenseData as cm, defenseOperation as cn, defineBehavior as co, encounterData as cp, lifeData as cq, lifeOperation as cr, matchingData as cs, matchingOperation as ct, puzzleCommandData as cu, puzzleData as cv, racingData as cw, racingOperation as cx, rhythmData as cy, rhythmOperation as cz, ADVENTURE_FLAGS as d, type StageRicochetDimValue as d0, type StageRicochetOptions as d1, type StagePlatformer3DOptions as d2, type StagePlatformer2DOptions as d3, type StageFirstPersonOptions as d4, type StageFirstPersonInput as d5, type StageJumper2DOptions as d6, type StageJumper3DOptions as d7, WasmStageRuntime as d8, type WasmStageRuntimeOptions as d9, StageTopDownPlane as dA, type StageTopDownPlaneValue as dB, type VelocityIntent as dC, type WasmSnapshotBackref as dD, createTransformStore as dE, createWasmStageRuntime as dF, readBehaviorSnapshot as dG, readStageRenderSlot as dH, type StageBodyKindValue as da, type StageColliderShape as db, type StageRenderSlot as dc, type StageRaycastHit as dd, type StageBodyInfo as de, type StageDebugRender as df, type BaseBehaviorHandle as dg, type BehaviorEntityLink as dh, type BehaviorSystemContext as di, type CreateEntityFn as dj, type GameEntityOptions as dk, STAGE_INPUT_BUTTON_JUMP as dl, STAGE_INPUT_BUTTON_RUN as dm, STAGE_INVALID_SLOT as dn, type StageBodyConfig as dp, StageBodyKind as dq, StageBoundaryDim as dr, type StageColliderConfig as ds, type StageEvent as dt, StageEventType as du, type StageEventTypeValue as dv, StagePlatformerShapeSource as dw, StageRicochetDim as dx, StageRicochetReflection as dy, type StageRicochetReflectionValue as dz, type AcrobaticsAbility as e, type AcrobaticsInput as f, type AcrobaticsOptions as g, type AcrobaticsState as h, type AdventureAbility as i, type AdventureInput as j, type AdventureObject as k, type AdventureObjectState as l, type AdventureOptions as m, type AdventureRole as n, type AdventureState as o, BATTLE_EVENTS as p, type BattleAbility as q, type BattleAction as r, type BattleEight as s, type BattleEvent as t, type BattleFour as u, type BattleOptions as v, type BattleState as w, type BattleTriple as x, type BehaviorDescriptor as y, type BehaviorHandle as z };