@waica/engine 0.4.2 → 0.6.0

package/README.md

@@ -0,0 +1,85 @@
+# `@waica/engine`
+
+Waica's public engine core: entities and components, the game loop, scene and prefab loading, state machines, input, collisions, sprites, camera, stats, and UI.
+
+```ts
+import { Component, Game, loadScene } from '@waica/engine'
+```
+
+## Component lifecycle
+
+Waica keeps the lifecycle boundaries distinct:
+
+1. `Entity.add()` mounts a component and calls its `onReady` immediately. This remains component insertion order so setup behavior does not silently move.
+2. During each simulated frame, entities keep their existing entity order. When an entity's turn begins, `Game` snapshots and resolves that entity's component `onUpdate` schedule, then dispatches only that schedule.
+3. Physical `onContact` hooks run from `DynamicBody` while it updates. Hitbox `onCollide` hooks run after all entity component updates. Their existing component dispatch order is unchanged.
+4. `Game.onUpdate` callbacks run after component updates, collisions, and camera work; input end-of-frame handling follows them.
+5. `Entity.destroy()` calls `onDestroy` in component insertion order.
+
+Only classes whose prototype chain implements `onUpdate` participate in the update schedule. Passive components remain available to their siblings but receive no update position.
+
+## Declaring update constraints
+
+An updateable component can declare the sibling writes it must observe with inherited static `updateAfter` metadata:
+
+```ts
+import { Component, StateMachine } from '@waica/engine'
+
+export class DamageFlash extends Component {
+  static override componentName = 'DamageFlash'
+  static override updateAfter: readonly string[] = ['StateMachine']
+
+  override onUpdate(dt: number): void {
+    const state = this.entity.get(StateMachine)?.current
+    // This update observes StateMachine's state for the same frame.
+    void state
+    void dt
+  }
+}
+```
+
+The relation is conditional on co-presence. `DamageFlash` does not require a `StateMachine`; when that target is registered but absent from this entity, no edge and no issue are created. A subclass inherits `updateAfter` when it declares nothing and replaces the inherited list when it declares its own list.
+
+Constraints always win over the tie-break. Whenever several components are ready simultaneously, Waica compares their case-sensitive `componentName` values in ascending Unicode code-unit order. It never uses locale collation, prefab order, scene order, or editor card grouping. Repeated names in one `updateAfter` list describe one edge.
+
+## Invalid schedules fail closed
+
+Component identity must be unique within an entity, and both sides of a present constraint must implement `onUpdate`. Waica rejects duplicate component names, unknown targets, passive declarers or present passive targets, self-edges, and multi-component cycles.
+
+At runtime an invalid entity runs no partial update schedule and does not fall back to authored order. Other entities continue updating. The engine logs one diagnostic containing the entity and causes, then logs again only if that entity's composition changes.
+
+Tools can inspect a composition without constructing components:
+
+```ts
+import { resolveComponentUpdateSchedule, type ComponentClass } from '@waica/engine'
+
+const registry: Record<string, ComponentClass> = { DamageFlash, StateMachine }
+const result = resolveComponentUpdateSchedule(
+  ['DamageFlash', 'StateMachine'],
+  registry,
+)
+
+if (result.ok) {
+  console.log(result.order) // ['StateMachine', 'DamageFlash']
+} else {
+  console.error(result.issues)
+}
+```
+
+The resolver is pure. Pass the effective component-name list and the complete class registry, including project-owned classes. A valid result contains `order` and no issues; an invalid result contains typed, actionable issues and no executable order.
+
+## Runtime inspection
+
+The engine owns Runtime Bridge protocol 1, but it is dormant during ordinary execution: there is no string-named global, network endpoint or per-frame bridge work. An MCP-owned browser context can install the symbol-keyed ephemeral activation hook before navigation. In that context `Game.start()` registers the fully constructed Game at a paused frame-zero baseline; `Game.dispose()` or page unload unregisters it.
+
+Runtime Snapshots automatically inspect public own component fields and setter-backed accessors while excluding `_` fields, `entity`, `game` and functions. A component can replace automatic discovery with the optional public contract:
+
+```ts
+class PathFinder extends Component {
+  inspectState(): unknown {
+    return { target: this.target, remaining: this.path.length }
+  }
+}
+```
+
+The return value still passes through the bounded safe projector; it is not serialized with arbitrary `toJSON()`. The package root exports the Runtime Snapshot, projection marker, metadata, control and activation types plus `RUNTIME_BRIDGE_PROTOCOL_VERSION` and `RUNTIME_PROJECTION_LIMITS`.

package/dist/authoring-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentClass } from './component.js';
+/**
+ * The public authoring surface of a component class: own enumerable fields
+ * plus setter-backed accessors (walking the whole prototype chain, so a
+ * getter/setter pair inherited from a base class counts), read through the
+ * getter so the value is the public one. Excludes `_`-prefixed keys, the
+ * base Component wiring (`entity`, `game`), anything the class (or an
+ * ancestor) declares `transient`, and values that are `undefined` or not
+ * JSON-serializable (`Map`, `Set`, functions, class instances).
+ */
+export declare function authoringDefaults(Class: ComponentClass, onError?: (error: unknown) => void): Record<string, unknown>;

package/dist/authoring-defaults.js

@@ -0,0 +1,51 @@
+const EXCLUDED_KEYS = new Set(['entity', 'game']);
+function isSerializable(value) {
+    if (value === null)
+        return true;
+    const kind = typeof value;
+    if (kind === 'string' || kind === 'number' || kind === 'boolean')
+        return true;
+    if (kind !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * The public authoring surface of a component class: own enumerable fields
+ * plus setter-backed accessors (walking the whole prototype chain, so a
+ * getter/setter pair inherited from a base class counts), read through the
+ * getter so the value is the public one. Excludes `_`-prefixed keys, the
+ * base Component wiring (`entity`, `game`), anything the class (or an
+ * ancestor) declares `transient`, and values that are `undefined` or not
+ * JSON-serializable (`Map`, `Set`, functions, class instances).
+ */
+export function authoringDefaults(Class, onError) {
+    let instance;
+    try {
+        instance = new Class();
+    }
+    catch (error) {
+        onError?.(error);
+        return {};
+    }
+    const transient = new Set(Class.transient ?? []);
+    const keys = new Set(Object.keys(instance));
+    for (let proto = Object.getPrototypeOf(instance); proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+            if (descriptor.set)
+                keys.add(key);
+        }
+    }
+    const result = {};
+    for (const key of keys) {
+        if (EXCLUDED_KEYS.has(key) || key.startsWith('_') || transient.has(key))
+            continue;
+        const value = instance[key];
+        if (value === undefined || !isSerializable(value))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}

package/dist/component-update-schedule.d.ts

@@ -0,0 +1,39 @@
+import type { ComponentClass } from './component.js';
+export type InvalidUpdateConstraintReason = 'unknown-target' | 'passive-declarer' | 'passive-target' | 'self-edge' | 'unregistered-component';
+export interface DuplicateComponentUpdateIssue {
+    readonly code: 'duplicate-component';
+    readonly componentNames: readonly string[];
+    readonly componentName: string;
+    readonly count: number;
+    readonly cause: string;
+}
+export interface InvalidComponentUpdateConstraintIssue {
+    readonly code: 'invalid-update-constraint';
+    readonly componentNames: readonly string[];
+    readonly declarer: string;
+    readonly target?: string;
+    readonly reason: InvalidUpdateConstraintReason;
+    readonly cause: string;
+}
+export interface ComponentUpdateCycleIssue {
+    readonly code: 'component-update-cycle';
+    readonly componentNames: readonly string[];
+    readonly cause: string;
+}
+export type ComponentUpdateScheduleIssue = DuplicateComponentUpdateIssue | InvalidComponentUpdateConstraintIssue | ComponentUpdateCycleIssue;
+export interface ValidComponentUpdateSchedule {
+    readonly ok: true;
+    readonly order: readonly string[];
+    readonly issues: readonly [];
+}
+export interface InvalidComponentUpdateSchedule {
+    readonly ok: false;
+    readonly issues: readonly ComponentUpdateScheduleIssue[];
+}
+export type ComponentUpdateScheduleResult = ValidComponentUpdateSchedule | InvalidComponentUpdateSchedule;
+export type ComponentUpdateRegistry = Readonly<Record<string, ComponentClass | undefined>>;
+/**
+ * Resolves one entity's deterministic component update schedule without
+ * constructing components or mutating either input.
+ */
+export declare function resolveComponentUpdateSchedule(componentNames: readonly string[], registry: ComponentUpdateRegistry): ComponentUpdateScheduleResult;

package/dist/component-update-schedule.js

@@ -0,0 +1,157 @@
+function codeUnitCompare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function registeredClass(registry, componentName) {
+    return Object.hasOwn(registry, componentName) ? registry[componentName] : undefined;
+}
+function updates(Class) {
+    return typeof Class?.prototype.onUpdate === 'function';
+}
+function updateCycles(nodes, outgoing) {
+    let nextIndex = 0;
+    const indices = new Map();
+    const lowLinks = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const cycles = [];
+    const visit = (node) => {
+        const index = nextIndex++;
+        indices.set(node, index);
+        lowLinks.set(node, index);
+        stack.push(node);
+        onStack.add(node);
+        for (const dependent of [...(outgoing.get(node) ?? [])].sort(codeUnitCompare)) {
+            if (!indices.has(dependent)) {
+                visit(dependent);
+                lowLinks.set(node, Math.min(lowLinks.get(node), lowLinks.get(dependent)));
+            }
+            else if (onStack.has(dependent)) {
+                lowLinks.set(node, Math.min(lowLinks.get(node), indices.get(dependent)));
+            }
+        }
+        if (lowLinks.get(node) !== indices.get(node))
+            return;
+        const group = [];
+        while (stack.length > 0) {
+            const member = stack.pop();
+            onStack.delete(member);
+            group.push(member);
+            if (member === node)
+                break;
+        }
+        if (group.length > 1)
+            cycles.push(group.sort(codeUnitCompare));
+    };
+    for (const node of nodes) {
+        if (!indices.has(node))
+            visit(node);
+    }
+    return cycles.sort((left, right) => codeUnitCompare(left[0], right[0]));
+}
+/**
+ * Resolves one entity's deterministic component update schedule without
+ * constructing components or mutating either input.
+ */
+export function resolveComponentUpdateSchedule(componentNames, registry) {
+    const present = new Set(componentNames);
+    const nodes = [...present]
+        .filter((name) => updates(registeredClass(registry, name)))
+        .sort(codeUnitCompare);
+    const outgoing = new Map(nodes.map((name) => [name, new Set()]));
+    const indegree = new Map(nodes.map((name) => [name, 0]));
+    const issues = [];
+    const counts = new Map();
+    for (const name of componentNames)
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    for (const [componentName, count] of [...counts].sort(([left], [right]) => codeUnitCompare(left, right))) {
+        if (count < 2)
+            continue;
+        issues.push({
+            code: 'duplicate-component',
+            componentName,
+            componentNames: [componentName],
+            count,
+            cause: `Component "${componentName}" appears ${count} times on the same entity; component identity must be unique.`,
+        });
+    }
+    for (const declarer of [...present].sort(codeUnitCompare)) {
+        const Class = registeredClass(registry, declarer);
+        if (Class?.updateAfter !== undefined && !updates(Class)) {
+            issues.push({
+                code: 'invalid-update-constraint',
+                reason: 'passive-declarer',
+                declarer,
+                componentNames: [declarer],
+                cause: `Passive component "${declarer}" declares updateAfter but does not implement onUpdate.`,
+            });
+        }
+    }
+    for (const declarer of nodes) {
+        const Class = registeredClass(registry, declarer);
+        for (const target of new Set(Class?.updateAfter ?? [])) {
+            if (!present.has(target)) {
+                if (!registeredClass(registry, target)) {
+                    issues.push({
+                        code: 'invalid-update-constraint',
+                        reason: 'unknown-target',
+                        declarer,
+                        target,
+                        componentNames: [declarer, target],
+                        cause: `Component "${declarer}" declares updateAfter target "${target}", which is neither present nor registered.`,
+                    });
+                }
+                continue;
+            }
+            if (target === declarer) {
+                issues.push({
+                    code: 'invalid-update-constraint',
+                    reason: 'self-edge',
+                    declarer,
+                    target,
+                    componentNames: [declarer],
+                    cause: `Component "${declarer}" cannot declare itself in updateAfter.`,
+                });
+                continue;
+            }
+            if (!outgoing.has(target)) {
+                issues.push({
+                    code: 'invalid-update-constraint',
+                    reason: 'passive-target',
+                    declarer,
+                    target,
+                    componentNames: [declarer, target],
+                    cause: `Component "${declarer}" declares updateAfter target "${target}", but "${target}" does not implement onUpdate.`,
+                });
+                continue;
+            }
+            const readers = outgoing.get(target);
+            if (readers.has(declarer))
+                continue;
+            readers.add(declarer);
+            indegree.set(declarer, (indegree.get(declarer) ?? 0) + 1);
+        }
+    }
+    for (const componentNames of updateCycles(nodes, outgoing)) {
+        issues.push({
+            code: 'component-update-cycle',
+            componentNames,
+            cause: `Component update cycle among ${componentNames.map((name) => `"${name}"`).join(', ')}.`,
+        });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    const ready = nodes.filter((name) => indegree.get(name) === 0);
+    const order = [];
+    while (ready.length > 0) {
+        ready.sort(codeUnitCompare);
+        const next = ready.shift();
+        order.push(next);
+        for (const dependent of [...(outgoing.get(next) ?? [])].sort(codeUnitCompare)) {
+            const remaining = (indegree.get(dependent) ?? 0) - 1;
+            indegree.set(dependent, remaining);
+            if (remaining === 0)
+                ready.push(dependent);
+        }
+    }
+    return { ok: true, order, issues: [] };
+}

package/dist/component.d.ts

@@ -7,8 +7,10 @@ export interface ParamSpec {
     min?: number;
     max?: number;
     step?: number;
-    /** Allowed values for a string param; rendered as a dropdown. */
+    /** Allowed values for a string param; rendered as a dropdown. Takes precedence over ref. */
     options?: string[];
+    /** Project value this string param names; rendered and validated as a typed reference. */
+    ref?: 'prefab' | 'stat' | 'action' | 'clip';
 }
 export interface ComponentClass<T extends Component = Component> {
     new (): T;
@@ -21,6 +23,14 @@ export interface ComponentClass<T extends Component = Component> {
     displayName?: string;
     /** Which properties the inspector exposes, with their ranges. */
     params?: Record<string, ParamSpec>;
+    /** Sibling component updates that must complete before this one when present. */
+    updateAfter?: readonly string[];
+    /**
+     * Instance fields holding runtime state rather than authorable defaults.
+     * Excluded from authoringDefaults(); a subclass that does not redeclare
+     * this inherits its base's list.
+     */
+    transient?: readonly string[];
 }
 /** Cardinal unit normal pointing away from the contacted Solid surface. */
 export interface ContactNormal {
@@ -43,8 +53,12 @@ export declare abstract class Component {
     static componentName: string;
     static displayName?: string;
     static params?: Record<string, ParamSpec>;
+    static updateAfter?: readonly string[];
+    static transient?: readonly string[];
     entity: Entity;
     game: Game;
+    /** Replaces automatic runtime-state discovery for Runtime Snapshots. */
+    inspectState?(): unknown;
     /** Runs once the component is mounted on its entity. */
     onReady?(): void;
     /** Runs once per frame. */

package/dist/component.js

@@ -6,6 +6,8 @@ export class Component {
     static componentName = 'Component';
     static displayName;
     static params;
+    static updateAfter;
+    static transient;
     entity;
     game;
 }

package/dist/components/animated-sprite.d.ts

@@ -12,6 +12,7 @@ import { type SheetCell, type SheetDef } from '../animation/sheet.js';
  */
 export declare class AnimatedSprite extends Component {
     static componentName: string;
+    static updateAfter: readonly string[];
     static params: {
         offsetX: {
             label: string;
@@ -26,6 +27,7 @@ export declare class AnimatedSprite extends Component {
             step: number;
         };
     };
+    static transient: string[];
     /** Spritesheet URL. */
     texture: string;
     /** Sheet grid dimensions. */

package/dist/components/animated-sprite.js

@@ -14,11 +14,22 @@ const loader = new THREE.TextureLoader();
  */
 export class AnimatedSprite extends Component {
     static componentName = 'AnimatedSprite';
+    static updateAfter = ['StateMachine'];
     static params = {
         offsetX: { label: 'x offset' },
         offsetY: { label: 'y offset' },
         layer: { label: 'layer', min: -5, max: 5, step: 1 },
     };
+    static transient = [
+        'current',
+        'player',
+        'sheets',
+        'texs',
+        'mesh',
+        'frame',
+        'frameScaleX',
+        'frameScaleY',
+    ];
     /** Spritesheet URL. */
     texture = '';
     /** Sheet grid dimensions. */

package/dist/components/sprite.d.ts

@@ -20,6 +20,7 @@ export declare class Sprite extends Component {
             step: number;
         };
     };
+    static transient: string[];
     private _width;
     private _height;
     get width(): number;

package/dist/components/sprite.js

@@ -12,6 +12,7 @@ export class Sprite extends Component {
         offsetY: { label: 'y offset' },
         layer: { label: 'layer', min: -5, max: 5, step: 1 },
     };
+    static transient = ['mesh'];
     // Size, color and offset are reactive so inspector edits update the live quad.
     // Texture still needs a rebuild. TODO(H1): fully reactive props.
     _width = 1;

package/dist/game.d.ts

@@ -57,10 +57,12 @@ export declare class Game {
     private readonly renderer;
     private readonly resizeObserver;
     private readonly updateFns;
+    private readonly invalidUpdateCompositions;
     private readonly resolution;
     private viewHeight;
     private sceneCamera;
     private lastTime;
+    private runtimeBridge;
     constructor(options: GameOptions);
     /** Creates a live entity in the scene. */
     spawn(name: string): Entity;
@@ -88,7 +90,12 @@ export declare class Game {
     setViewHeight(value: number): void;
     /** Shuts the game down completely (loop, input, GPU). */
     dispose(): void;
+    private resumeRuntime;
     private tick;
+    private runFrame;
+    private unregisterRuntimeBridge;
+    private renderSurface;
+    private componentUpdateSchedule;
     private updateSceneCamera;
     private dispatchCollisions;
     private resize;

package/dist/game.js

@@ -1,10 +1,13 @@
 import * as THREE from 'three';
 import { collisionOverlap } from './collision-shape.js';
 import { resolveSceneCamera, stepSceneCamera } from './camera.js';
+import { resolveComponentUpdateSchedule } from './component-update-schedule.js';
 import { Hitbox } from './components/hitbox.js';
 import { Entity } from './entity.js';
 import { Emitter } from './events.js';
 import { Input } from './input.js';
+import { activeRuntimeBridgeHook, EngineRuntimeBridge, } from './runtime-bridge.js';
+import { RuntimeInspector } from './runtime-inspection.js';
 import { registryEntry, spawnFromJson } from './scene.js';
 import { Stats } from './stats.js';
 import { GameUi } from './ui.js';
@@ -33,10 +36,12 @@ export class Game {
     renderer;
     resizeObserver;
     updateFns = new Set();
+    invalidUpdateCompositions = new WeakMap();
     resolution;
     viewHeight;
     sceneCamera = null;
     lastTime = 0;
+    runtimeBridge = null;
     constructor(options) {
         const { canvas, background = 0x1a1a2e, viewHeight = 10 } = options;
         this.viewHeight = viewHeight;
@@ -124,6 +129,25 @@ export class Game {
         this.setViewHeight(this.sceneCamera.zoom);
     }
     start() {
+        const activation = activeRuntimeBridgeHook();
+        if (activation) {
+            if (!this.runtimeBridge) {
+                const inspector = new RuntimeInspector(this);
+                this.runtimeBridge = new EngineRuntimeBridge(this.renderer.domElement, activation, {
+                    step: (dt) => this.runFrame(dt),
+                    resume: (frame) => this.resumeRuntime(frame),
+                    pause: () => this.stop(),
+                    injectAction: (action, operation) => this.input.injectAction(action, operation),
+                    availableActions: () => this.input.availableActions(),
+                    heldActions: () => this.input.heldActions(),
+                    inspect: (metadata, filters) => inspector.snapshot(metadata, filters),
+                });
+                activation.register(this.runtimeBridge);
+                window.addEventListener('pagehide', this.unregisterRuntimeBridge);
+            }
+            this.renderSurface();
+            return;
+        }
         this.renderer.setAnimationLoop((time) => this.tick(time));
     }
     stop() {
@@ -146,6 +170,7 @@ export class Game {
     /** Shuts the game down completely (loop, input, GPU). */
     dispose() {
         this.stop();
+        this.unregisterRuntimeBridge();
         this.input.dispose();
         this.resizeObserver.disconnect();
         this.ui.dispose();
@@ -153,13 +178,27 @@ export class Game {
             entity.destroy();
         this.renderer.dispose();
     }
+    resumeRuntime(frame) {
+        let previousTime = null;
+        this.renderer.setAnimationLoop((time) => {
+            const dt = previousTime === null ? 0 : Math.min((time - previousTime) / 1000, 0.1);
+            previousTime = time;
+            frame(dt);
+        });
+    }
     tick(time) {
         // Clamp dt: switching tabs or pausing doesn't fast-forward the simulation.
         const dt = Math.min((time - this.lastTime) / 1000, 0.1);
         this.lastTime = time;
+        this.runFrame(dt);
+    }
+    runFrame(dt) {
         if (this.simulate) {
             for (const entity of [...this.entities]) {
-                for (const component of [...entity.components])
+                const schedule = this.componentUpdateSchedule(entity);
+                if (!schedule)
+                    continue;
+                for (const component of schedule)
                     component.onUpdate?.(dt);
             }
             this.dispatchCollisions();
@@ -170,6 +209,15 @@ export class Game {
         for (const fn of this.updateFns)
             fn(dt);
         this.input.endFrame();
+        this.renderSurface();
+    }
+    unregisterRuntimeBridge = () => {
+        window.removeEventListener('pagehide', this.unregisterRuntimeBridge);
+        this.runtimeBridge?.unregister();
+        this.runtimeBridge = null;
+    };
+    renderSurface() {
+        this.ui.setActive(this.simulate);
         if (this.resolution) {
             // Letterbox bars: clear the whole canvas, then render inside the scissor.
             this.renderer.setScissorTest(false);
@@ -179,6 +227,36 @@ export class Game {
         }
         this.renderer.render(this.scene, this.camera);
     }
+    componentUpdateSchedule(entity) {
+        const components = [...entity.components];
+        const registry = {
+            ...(this.registry?.components ?? {}),
+        };
+        const byName = new Map();
+        const names = [];
+        const signatureParts = [];
+        for (const component of components) {
+            const Class = component.constructor;
+            const name = Class.componentName;
+            registry[name] = Class;
+            names.push(name);
+            byName.set(name, component);
+            signatureParts.push(`${name}:${typeof Class.prototype.onUpdate === 'function' ? 'updates' : 'passive'}:` +
+                [...new Set(Class.updateAfter ?? [])].sort().join(','));
+        }
+        const result = resolveComponentUpdateSchedule(names, registry);
+        if (!result.ok) {
+            const signature = signatureParts.sort().join('|');
+            if (this.invalidUpdateCompositions.get(entity) !== signature) {
+                this.invalidUpdateCompositions.set(entity, signature);
+                console.error(`[waica] invalid component update schedule for "${entity.name}": ` +
+                    result.issues.map((issue) => issue.cause).join(' '));
+            }
+            return null;
+        }
+        this.invalidUpdateCompositions.delete(entity);
+        return result.order.map((name) => byName.get(name));
+    }
     updateSceneCamera(dt) {
         const cam = this.sceneCamera;
         if (!cam)

package/dist/index.d.ts

@@ -4,11 +4,18 @@ export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.j
 export type { SceneCameraJson, CameraLimitsJson, ResolvedSceneCamera } from './camera.js';
 export { Entity } from './entity.js';
 export { Component } from './component.js';
+export { authoringDefaults } from './authoring-defaults.js';
 export type { ComponentClass, ContactNormal, ParamSpec, SolidContact, } from './component.js';
 export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
 export type { ComponentModule } from './component-registry.js';
+export { resolveComponentUpdateSchedule } from './component-update-schedule.js';
+export type { ComponentUpdateCycleIssue, ComponentUpdateRegistry, ComponentUpdateScheduleIssue, ComponentUpdateScheduleResult, DuplicateComponentUpdateIssue, InvalidComponentUpdateConstraintIssue, InvalidComponentUpdateSchedule, InvalidUpdateConstraintReason, ValidComponentUpdateSchedule, } from './component-update-schedule.js';
 export { Input, DEFAULT_BINDINGS } from './input.js';
-export type { ActionName, InputBindings } from './input.js';
+export type { ActionName, InjectedActionOperation, InputBindings } from './input.js';
+export { RUNTIME_BRIDGE_PROTOCOL_VERSION, RUNTIME_BRIDGE_SYMBOL, RuntimeBridgeOperationError, } from './runtime-bridge.js';
+export type { RuntimeBridge, RuntimeBridgeActivation, RuntimeControlRequest, RuntimeControlResult, RuntimeMetadata, RuntimeMode, } from './runtime-bridge.js';
+export { RUNTIME_PROJECTION_LIMITS } from './runtime-inspection.js';
+export type { ProjectedValue, ProjectionIssue, ProjectionMarker, ProjectionMarkerKind, RuntimeComponentSnapshot, RuntimeEntitySnapshot, RuntimeSnapshot, RuntimeSnapshotFilters, RuntimeTransformSnapshot, } from './runtime-inspection.js';
 export type { ArchetypeArt, ArchetypeManifest, BrowserArchetypeManifest, EntityTemplate, } from './archetype.js';
 export { Stats } from './stats.js';
 export type { StatValue } from './stats.js';

package/dist/index.js

@@ -2,8 +2,12 @@ export { Game } from './game.js';
 export { CAMERA_DEFAULTS, resolveSceneCamera, stepSceneCamera } from './camera.js';
 export { Entity } from './entity.js';
 export { Component } from './component.js';
+export { authoringDefaults } from './authoring-defaults.js';
 export { collectModuleComponents, mergeRegistryComponents } from './component-registry.js';
+export { resolveComponentUpdateSchedule } from './component-update-schedule.js';
 export { Input, DEFAULT_BINDINGS } from './input.js';
+export { RUNTIME_BRIDGE_PROTOCOL_VERSION, RUNTIME_BRIDGE_SYMBOL, RuntimeBridgeOperationError, } from './runtime-bridge.js';
+export { RUNTIME_PROJECTION_LIMITS } from './runtime-inspection.js';
 export { Stats } from './stats.js';
 export { GameUi } from './ui.js';
 export { Sprite } from './components/sprite.js';