@jgengine/core 0.7.0 → 0.9.0

package/dist/physics/ragdoll.js

@@ -88,7 +88,7 @@ export function createRagdoll(world, config) {
                     (world.posY[a] + world.posY[b]) / 2,
                     (world.posZ[a] + world.posZ[b]) / 2,
                 ];
-            links.push(world.hingeJoint({
+            links.push(world.fixedJoint({
                 bodyA: a,
                 bodyB: b,
                 anchorA: [mid[0] - world.posX[a], mid[1] - world.posY[a], mid[2] - world.posZ[a]],

package/dist/physics/spatialGrid.d.ts

@@ -1,4 +1,4 @@
-import type { PhysicsBounds } from "./physicsWorld.js";
+import { type PhysicsBounds } from "./physicsWorld.js";
 export interface SpatialGridConfig {
     /** Horizontal extent to index; only x/z of the bounds are used (a top-down plane). */
     bounds: PhysicsBounds;

package/dist/physics/spatialGrid.js

@@ -1,3 +1,4 @@
+import { MAX_BROADPHASE_CELLS } from "./physicsWorld.js";
 /**
  * A uniform-grid broad-phase over the x/z plane, separate from the rigid-body sim, for cheap
  * same-tick proximity across hundreds–thousands of simple movers (swarm enemies). Rebuild each
@@ -30,6 +31,10 @@ export class SpatialGrid {
         this.nx = Math.max(1, Math.ceil(spanX / config.cellSize));
         this.nz = Math.max(1, Math.ceil(spanZ / config.cellSize));
         this.numCells = this.nx * this.nz;
+        if (this.numCells > MAX_BROADPHASE_CELLS) {
+            throw new Error(`SpatialGrid: grid too large (${this.nx}x${this.nz} = ${this.numCells} cells, cap ${MAX_BROADPHASE_CELLS}). ` +
+                `bounds=[${config.bounds.min}]..[${config.bounds.max}] cellSize=${config.cellSize}; raise cellSize or shrink bounds.`);
+        }
         this.cellStart = new Int32Array(this.numCells + 1);
         this.cursor = new Int32Array(this.numCells);
         this.sorted = new Int32Array(config.capacity);

package/dist/physics/vehicleBody.d.ts

@@ -77,6 +77,12 @@ export declare class VehicleBody {
     private readonly surfaceFriction;
     private groundedCount;
     constructor(world: PhysicsWorld, config: VehicleBodyConfig);
+    /**
+     * A wheel's local offset rotated by the current heading — the ground-side mount and the
+     * chassis-side spring anchor both derive from this, so the suspension axis stays vertical (not a
+     * mix of rotated and unrotated ends) as the chassis turns.
+     */
+    private rotateOffset;
     private wheelMount;
     get position(): [number, number, number];
     get forward(): [number, number];

package/dist/physics/vehicleBody.js

@@ -1,3 +1,4 @@
+import { steerYaw } from "../movement/steering.js";
 /**
  * Piecewise-linear tire-grip curve: normalized lateral slip → available grip (0..1). Grip peaks near
  * the breakaway slip then falls off as the tire slides — the shape that separates a planted corner
@@ -101,7 +102,7 @@ export class VehicleBody {
             const rest = wheel.restLength ?? this.suspensionRest;
             const id = world.springJoint({
                 bodyA: this.chassis,
-                anchorA: [wheel.offset[0], wheel.offset[1], wheel.offset[2]],
+                anchorA: this.rotateOffset(wheel.offset),
                 anchorB: [worldPos[0], worldPos[1] - rest, worldPos[2]],
                 restLength: rest,
                 stiffness,
@@ -118,15 +119,20 @@ export class VehicleBody {
             });
         }
     }
-    wheelMount(wheel) {
+    /**
+     * A wheel's local offset rotated by the current heading — the ground-side mount and the
+     * chassis-side spring anchor both derive from this, so the suspension axis stays vertical (not a
+     * mix of rotated and unrotated ends) as the chassis turns.
+     */
+    rotateOffset(offset) {
         const sin = Math.sin(this.heading);
         const cos = Math.cos(this.heading);
-        const [ox, oy, oz] = wheel.offset;
-        return [
-            this.world.posX[this.chassis] + ox * cos + oz * sin,
-            this.world.posY[this.chassis] + oy,
-            this.world.posZ[this.chassis] - ox * sin + oz * cos,
-        ];
+        const [ox, oy, oz] = offset;
+        return [ox * cos + oz * sin, oy, -ox * sin + oz * cos];
+    }
+    wheelMount(wheel) {
+        const [dx, dy, dz] = this.rotateOffset(wheel.offset);
+        return [this.world.posX[this.chassis] + dx, this.world.posY[this.chassis] + dy, this.world.posZ[this.chassis] + dz];
     }
     get position() {
         return [this.world.posX[this.chassis], this.world.posY[this.chassis], this.world.posZ[this.chassis]];
@@ -149,16 +155,8 @@ export class VehicleBody {
         return this.wheels.length;
     }
     resetTo(position, heading) {
-        const w = this.world;
-        const c = this.chassis;
-        w.posX[c] = position[0];
-        w.posY[c] = position[1];
-        w.posZ[c] = position[2];
-        w.velX[c] = 0;
-        w.velY[c] = 0;
-        w.velZ[c] = 0;
+        this.world.teleport(this.chassis, position[0], position[1], position[2]);
         this.heading = heading;
-        w.wake(c);
     }
     update(dt, input) {
         const w = this.world;
@@ -169,7 +167,7 @@ export class VehicleBody {
         if (grounded) {
             const steerScale = Math.min(1, Math.abs(speed) / this.turnSpeedRef);
             const dir = speed >= 0 ? 1 : -1;
-            this.heading += input.steer * this.turnRate * steerScale * dir * dt;
+            this.heading = steerYaw(this.heading, input.steer * steerScale * dir, this.turnRate, dt);
         }
         const [fx, fz] = this.forward;
         if (grounded) {
@@ -212,6 +210,8 @@ export class VehicleBody {
             const gap = mount[1] - (groundY + radius);
             const maxTravel = rest + radius;
             const grounded = gap <= maxTravel;
+            const anchorA = this.rotateOffset(wheel.offset);
+            w.setJointAnchorA(this.springs[i], anchorA[0], anchorA[1], anchorA[2]);
             w.setJointAnchor(this.springs[i], mount[0], groundY + radius, mount[2]);
             state.worldX = mount[0];
             state.worldY = groundY + radius;

package/dist/puzzle/cellGrid.d.ts

@@ -0,0 +1,26 @@
+export interface CellGrid<T> {
+    readonly width: number;
+    readonly height: number;
+    readonly cells: readonly (T | null)[];
+}
+export interface CellRun<T> {
+    readonly value: T;
+    readonly cells: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[];
+    readonly direction: "row" | "column";
+}
+export declare function createCellGrid<T>(width: number, height: number): CellGrid<T>;
+export declare function inGridBounds<T>(grid: CellGrid<T>, x: number, y: number): boolean;
+export declare function cellAt<T>(grid: CellGrid<T>, x: number, y: number): T | null;
+export declare function withCell<T>(grid: CellGrid<T>, x: number, y: number, value: T | null): CellGrid<T>;
+export declare function withCells<T>(grid: CellGrid<T>, entries: readonly {
+    readonly x: number;
+    readonly y: number;
+    readonly value: T | null;
+}[]): CellGrid<T>;
+export declare function fullRows<T>(grid: CellGrid<T>): number[];
+export declare function clearRows<T>(grid: CellGrid<T>, rows: readonly number[]): CellGrid<T>;
+export declare function collapseColumns<T>(grid: CellGrid<T>): CellGrid<T>;
+export declare function findRuns<T>(grid: CellGrid<T>, minLength: number, matches?: (a: T, b: T) => boolean): CellRun<T>[];

package/dist/puzzle/cellGrid.js

@@ -0,0 +1,110 @@
+export function createCellGrid(width, height) {
+    return { width, height, cells: new Array(width * height).fill(null) };
+}
+export function inGridBounds(grid, x, y) {
+    return x >= 0 && x < grid.width && y >= 0 && y < grid.height;
+}
+export function cellAt(grid, x, y) {
+    if (!inGridBounds(grid, x, y))
+        return null;
+    return grid.cells[y * grid.width + x] ?? null;
+}
+export function withCell(grid, x, y, value) {
+    if (!inGridBounds(grid, x, y))
+        return grid;
+    const cells = grid.cells.slice();
+    cells[y * grid.width + x] = value;
+    return { width: grid.width, height: grid.height, cells };
+}
+export function withCells(grid, entries) {
+    const cells = grid.cells.slice();
+    for (const entry of entries) {
+        if (inGridBounds(grid, entry.x, entry.y))
+            cells[entry.y * grid.width + entry.x] = entry.value;
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+export function fullRows(grid) {
+    const rows = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        let full = true;
+        for (let x = 0; x < grid.width; x += 1) {
+            if (cellAt(grid, x, y) === null) {
+                full = false;
+                break;
+            }
+        }
+        if (full)
+            rows.push(y);
+    }
+    return rows;
+}
+export function clearRows(grid, rows) {
+    const removed = new Set(rows);
+    const kept = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        if (removed.has(y))
+            continue;
+        kept.push(grid.cells.slice(y * grid.width, y * grid.width + grid.width));
+    }
+    const clearedCount = grid.height - kept.length;
+    const cells = [];
+    for (let i = 0; i < clearedCount; i += 1)
+        cells.push(...new Array(grid.width).fill(null));
+    for (const row of kept)
+        cells.push(...row);
+    return { width: grid.width, height: grid.height, cells };
+}
+export function collapseColumns(grid) {
+    const cells = grid.cells.slice();
+    for (let x = 0; x < grid.width; x += 1) {
+        const values = [];
+        for (let y = 0; y < grid.height; y += 1) {
+            const value = cellAt(grid, x, y);
+            if (value !== null)
+                values.push(value);
+        }
+        const emptyCount = grid.height - values.length;
+        for (let y = 0; y < grid.height; y += 1) {
+            cells[y * grid.width + x] = y < emptyCount ? null : values[y - emptyCount];
+        }
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+function scanRuns(length, cellAtIndex, minLength, matches) {
+    const runs = [];
+    let start = 0;
+    for (let i = 1; i <= length; i += 1) {
+        const prev = cellAtIndex(i - 1);
+        const cur = i < length ? cellAtIndex(i) : null;
+        const continues = prev !== null && cur !== null && matches(prev, cur);
+        if (!continues) {
+            const runLength = i - start;
+            const value = cellAtIndex(start);
+            if (runLength >= minLength && value !== null)
+                runs.push({ value, start, end: i });
+            start = i;
+        }
+    }
+    return runs;
+}
+export function findRuns(grid, minLength, matches = (a, b) => a === b) {
+    const runs = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        for (const run of scanRuns(grid.width, (x) => cellAt(grid, x, y), minLength, matches)) {
+            const cells = [];
+            for (let x = run.start; x < run.end; x += 1)
+                cells.push({ x, y });
+            runs.push({ value: run.value, cells, direction: "row" });
+        }
+    }
+    for (let x = 0; x < grid.width; x += 1) {
+        for (const run of scanRuns(grid.height, (y) => cellAt(grid, x, y), minLength, matches)) {
+            const cells = [];
+            for (let y = run.start; y < run.end; y += 1)
+                cells.push({ x, y });
+            runs.push({ value: run.value, cells, direction: "column" });
+        }
+    }
+    return runs;
+}

package/dist/puzzle/fallingPiece.d.ts

@@ -0,0 +1,24 @@
+import { type CellGrid } from "./cellGrid.js";
+export interface FallingPiece<TShape extends string = string> {
+    readonly shape: TShape;
+    readonly rotation: number;
+    readonly x: number;
+    readonly y: number;
+}
+export type ShapeTable<TShape extends string = string> = Record<TShape, readonly (readonly (readonly [number, number])[])[]>;
+export declare function pieceCells<TShape extends string>(table: ShapeTable<TShape>, piece: FallingPiece<TShape>): readonly (readonly [number, number])[];
+export declare function pieceCollides<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): boolean;
+export declare function mergePiece<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>, value: T): CellGrid<T>;
+export declare function dropDistance<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): number;
+export declare function gravityInterval(level: number, base?: number, perLevel?: number, min?: number): number;
+export declare function levelForLines(lines: number, linesPerLevel?: number): number;
+export declare function lineScore(cleared: number, level: number, table?: readonly number[]): number;
+export interface LockDelayState {
+    readonly delaySeconds: number;
+    readonly elapsed: number;
+}
+export declare function createLockDelay(delaySeconds: number): LockDelayState;
+export declare function stepLockDelay(state: LockDelayState, grounded: boolean, dt: number): {
+    state: LockDelayState;
+    locked: boolean;
+};

package/dist/puzzle/fallingPiece.js

@@ -0,0 +1,51 @@
+import { cellAt } from "./cellGrid.js";
+export function pieceCells(table, piece) {
+    const rotations = table[piece.shape];
+    const index = ((piece.rotation % rotations.length) + rotations.length) % rotations.length;
+    const state = rotations[index];
+    return state.map(([ox, oy]) => [piece.x + ox, piece.y + oy]);
+}
+export function pieceCollides(grid, table, piece) {
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x < 0 || x >= grid.width || y >= grid.height)
+            return true;
+        if (y >= 0 && cellAt(grid, x, y) !== null)
+            return true;
+    }
+    return false;
+}
+export function mergePiece(grid, table, piece, value) {
+    const cells = grid.cells.slice();
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x >= 0 && x < grid.width && y >= 0 && y < grid.height)
+            cells[y * grid.width + x] = value;
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+export function dropDistance(grid, table, piece) {
+    let distance = 0;
+    while (!pieceCollides(grid, table, { ...piece, y: piece.y + distance + 1 }))
+        distance += 1;
+    return distance;
+}
+export function gravityInterval(level, base = 0.8, perLevel = 0.07, min = 0.05) {
+    return Math.max(min, base - level * perLevel);
+}
+export function levelForLines(lines, linesPerLevel = 10) {
+    return Math.floor(lines / linesPerLevel);
+}
+const CLASSIC_LINE_SCORE = [0, 40, 100, 300, 1200];
+export function lineScore(cleared, level, table = CLASSIC_LINE_SCORE) {
+    return (table[cleared] ?? 0) * (level + 1);
+}
+export function createLockDelay(delaySeconds) {
+    return { delaySeconds, elapsed: 0 };
+}
+export function stepLockDelay(state, grounded, dt) {
+    if (!grounded)
+        return { state: { ...state, elapsed: 0 }, locked: false };
+    const elapsed = state.elapsed + dt;
+    if (elapsed >= state.delaySeconds)
+        return { state: { ...state, elapsed: 0 }, locked: true };
+    return { state: { ...state, elapsed }, locked: false };
+}

package/dist/random/nameGen.d.ts

@@ -0,0 +1,18 @@
+export interface SyllableBank {
+    onset?: readonly string[];
+    nucleus: readonly string[];
+    coda?: readonly string[];
+}
+export interface NameGeneratorOptions {
+    rng: () => number;
+    syllables: SyllableBank;
+    minSyllables?: number;
+    maxSyllables?: number;
+    capitalize?: boolean;
+}
+export interface NameGenerator {
+    name(): string;
+}
+export declare function pickFrom(rng: () => number, bank: readonly string[]): string;
+export declare function createNameGenerator(options: NameGeneratorOptions): NameGenerator;
+export declare function fillTemplate(template: string, vars: Record<string, () => string> | Record<string, string>): string;

package/dist/random/nameGen.js

@@ -0,0 +1,35 @@
+export function pickFrom(rng, bank) {
+    if (bank.length === 0)
+        throw new Error("pickFrom: bank must not be empty");
+    return bank[Math.floor(rng() * bank.length)];
+}
+export function createNameGenerator(options) {
+    const { rng, syllables } = options;
+    const minSyllables = Math.max(1, options.minSyllables ?? 2);
+    const maxSyllables = Math.max(minSyllables, options.maxSyllables ?? minSyllables);
+    const capitalize = options.capitalize ?? true;
+    function syllable() {
+        const onset = syllables.onset === undefined || syllables.onset.length === 0 ? "" : pickFrom(rng, syllables.onset);
+        const nucleus = pickFrom(rng, syllables.nucleus);
+        const coda = syllables.coda === undefined || syllables.coda.length === 0 ? "" : pickFrom(rng, syllables.coda);
+        return `${onset}${nucleus}${coda}`;
+    }
+    return {
+        name() {
+            const span = maxSyllables - minSyllables;
+            const count = minSyllables + (span === 0 ? 0 : Math.floor(rng() * (span + 1)));
+            let result = "";
+            for (let i = 0; i < count; i++)
+                result += syllable();
+            return capitalize && result.length > 0 ? result.charAt(0).toUpperCase() + result.slice(1) : result;
+        },
+    };
+}
+export function fillTemplate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+        if (!(key in vars))
+            return match;
+        const value = vars[key];
+        return typeof value === "function" ? value() : value;
+    });
+}

package/dist/random/rng.d.ts

@@ -0,0 +1,2 @@
+export declare function seededRng(seed: string | number): () => number;
+export declare function seededStreams(seed: string | number): (stream: string) => () => number;

package/dist/random/rng.js

@@ -0,0 +1,23 @@
+function hashSeed(seed) {
+    const text = typeof seed === "number" ? seed.toString() : seed;
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function seededRng(seed) {
+    let a = hashSeed(seed) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function seededStreams(seed) {
+    const base = typeof seed === "number" ? seed.toString() : seed;
+    return (stream) => seededRng(`${base}:${stream}`);
+}

package/dist/random/seedLink.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_SEED_PARAM = "seed";
+export declare function withSeedParam(url: string, seed: string | number, param?: string): string;
+export declare function seedFromSearch(search: string, param?: string): string | null;
+export declare function seedFromUrl(url: string, param?: string): string | null;
+export declare function dailySeed(nowMs: number, salt?: string): string;

package/dist/random/seedLink.js

@@ -0,0 +1,35 @@
+export const DEFAULT_SEED_PARAM = "seed";
+function splitUrl(url) {
+    const hashIndex = url.indexOf("#");
+    const hash = hashIndex === -1 ? "" : url.slice(hashIndex + 1);
+    const rest = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    const queryIndex = rest.indexOf("?");
+    const base = queryIndex === -1 ? rest : rest.slice(0, queryIndex);
+    const query = queryIndex === -1 ? "" : rest.slice(queryIndex + 1);
+    return { base, query, hash };
+}
+export function withSeedParam(url, seed, param = DEFAULT_SEED_PARAM) {
+    const { base, query, hash } = splitUrl(url);
+    const params = new URLSearchParams(query);
+    params.set(param, typeof seed === "number" ? seed.toString() : seed);
+    const queryString = params.toString();
+    return `${base}${queryString ? `?${queryString}` : ""}${hash ? `#${hash}` : ""}`;
+}
+export function seedFromSearch(search, param = DEFAULT_SEED_PARAM) {
+    const normalized = search.startsWith("?") ? search.slice(1) : search;
+    const params = new URLSearchParams(normalized);
+    const value = params.get(param);
+    return value === null || value === "" ? null : value;
+}
+export function seedFromUrl(url, param = DEFAULT_SEED_PARAM) {
+    const { query } = splitUrl(url);
+    return seedFromSearch(query, param);
+}
+export function dailySeed(nowMs, salt) {
+    const date = new Date(nowMs);
+    const year = date.getUTCFullYear().toString().padStart(4, "0");
+    const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+    const day = date.getUTCDate().toString().padStart(2, "0");
+    const base = `${year}-${month}-${day}`;
+    return salt !== undefined && salt.length > 0 ? `${base}:${salt}` : base;
+}

package/dist/runtime/adapter.d.ts

@@ -5,6 +5,20 @@ export type MultiplayerAdapterConfig = {
 } | {
     kind: "ws";
     topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "socketio";
+    topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "p2p";
+    topology?: MultiplayerTopology;
+    room?: string;
+} | {
+    kind: "lan";
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 } | {
     kind: "offline";
 };
@@ -13,8 +27,29 @@ export declare function convex(config?: {
 }): MultiplayerAdapterConfig;
 export declare function ws(config?: {
     topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function fly(config: {
+    app: string;
+    topology?: MultiplayerTopology;
+    path?: string;
+}): MultiplayerAdapterConfig;
+export declare function socketIo(config?: {
+    topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function p2p(config?: {
+    topology?: MultiplayerTopology;
+    room?: string;
+}): MultiplayerAdapterConfig;
+export declare function lan(config?: {
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 }): MultiplayerAdapterConfig;
 export declare function offline(): MultiplayerAdapterConfig;
+export declare function adapterOf(multiplayer: unknown): MultiplayerAdapterConfig | null;
+export declare function multiplayerAdapterKind(multiplayer: unknown): string | null;
 export type ServersPoolConfig = {
     maxServers: number;
     slotsPerServer: number;

package/dist/runtime/adapter.js

@@ -2,11 +2,47 @@ export function convex(config) {
     return { kind: "convex", topology: config?.topology ?? "shared" };
 }
 export function ws(config) {
-    return { kind: "ws", topology: config?.topology ?? "shared" };
+    return { kind: "ws", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function fly(config) {
+    return {
+        kind: "ws",
+        topology: config.topology ?? "shared",
+        url: `wss://${config.app}.fly.dev${config.path ?? "/ws"}`,
+    };
+}
+export function socketIo(config) {
+    return { kind: "socketio", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function p2p(config) {
+    return { kind: "p2p", topology: config?.topology ?? "private", room: config?.room };
+}
+export function lan(config) {
+    return { kind: "lan", topology: config?.topology ?? "shared", port: config?.port, path: config?.path };
 }
 export function offline() {
     return { kind: "offline" };
 }
+const ADAPTER_KINDS = new Set(["convex", "ws", "socketio", "p2p", "lan", "offline"]);
+function isAdapterConfig(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const kind = value.kind;
+    return typeof kind === "string" && ADAPTER_KINDS.has(kind);
+}
+export function adapterOf(multiplayer) {
+    if (isAdapterConfig(multiplayer))
+        return multiplayer;
+    if (typeof multiplayer === "object" && multiplayer !== null) {
+        const nested = multiplayer.adapter;
+        if (isAdapterConfig(nested))
+            return nested;
+    }
+    return null;
+}
+export function multiplayerAdapterKind(multiplayer) {
+    return adapterOf(multiplayer)?.kind ?? null;
+}
 export function servers(config) {
     return config;
 }

package/dist/runtime/cameraDirector.d.ts

@@ -0,0 +1,15 @@
+import type { ChaseCameraConfig, CinematicCameraConfig } from "../game/playableGame.js";
+/** Runtime patch over the static `camera.chase` config — distance/height/fov retuning from gameplay events (#286.11). */
+export type ChaseCameraTuning = Partial<Pick<ChaseCameraConfig, "distance" | "height" | "lookHeight" | "springDamping" | "fov" | "lead" | "bank">>;
+export interface CameraDirector {
+    follow(entityId: string | null): void;
+    /** `undefined` means no runtime override — the shell falls back to the static `playable.camera.followEntityId`. `null` means explicitly follow nothing. */
+    followedEntityId(): string | null | undefined;
+    setCinematic(config: CinematicCameraConfig | null): void;
+    cinematic(): CinematicCameraConfig | null;
+    /** Overlay a runtime patch on the chase rig's config — a boss-intro pull-back, drift zoom-out; `null` restores the static config. */
+    setChaseTuning(tuning: ChaseCameraTuning | null): void;
+    chaseTuning(): ChaseCameraTuning | null;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createCameraDirector(): CameraDirector;

package/dist/runtime/cameraDirector.js

@@ -0,0 +1,31 @@
+export function createCameraDirector() {
+    const listeners = new Set();
+    let followEntity = undefined;
+    let cinematicConfig = null;
+    let chaseTuningPatch = null;
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        follow(entityId) {
+            followEntity = entityId;
+            notify();
+        },
+        followedEntityId: () => followEntity,
+        setCinematic(config) {
+            cinematicConfig = config;
+            notify();
+        },
+        cinematic: () => cinematicConfig,
+        setChaseTuning(tuning) {
+            chaseTuningPatch = tuning;
+            notify();
+        },
+        chaseTuning: () => chaseTuningPatch,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/dist/runtime/commandRunner.d.ts

@@ -2,8 +2,8 @@ export type CommandValidationError = {
     reason: string;
 };
 export type CommandDef<TInput = unknown> = {
-    validate: (snapshot: import("./snapshot.js").GameRuntimeSnapshot, input: TInput) => CommandValidationError | null;
-    apply: (snapshot: import("./snapshot.js").GameRuntimeSnapshot, input: TInput) => import("./snapshot.js").GameRuntimeSnapshot;
+    validate: (snapshot: import("./snapshot.js").GameRuntimeSnapshot, input: TInput, actorUserId: string) => CommandValidationError | null;
+    apply: (snapshot: import("./snapshot.js").GameRuntimeSnapshot, input: TInput, actorUserId: string) => import("./snapshot.js").GameRuntimeSnapshot;
 };
 export type RunCommandResult = {
     ok: true;

package/dist/runtime/commandRunner.js

@@ -3,11 +3,11 @@ export function runCommand(snapshot, commands, commandName, input, actorUserId)
     if (!command) {
         return { ok: false, reason: `Unknown command: ${commandName}` };
     }
-    const validationError = command.validate(snapshot, input);
+    const validationError = command.validate(snapshot, input, actorUserId);
     if (validationError) {
         return { ok: false, reason: validationError.reason };
     }
-    const next = command.apply(snapshot, input);
+    const next = command.apply(snapshot, input, actorUserId);
     return {
         ok: true,
         snapshot: {