@multitapio/multitap 0.0.1

package/dist/types/react/views/index.d.ts

@@ -0,0 +1,21 @@
+import type { ViewType } from '../types';
+import type { View } from './types';
+/**
+ * Get a view implementation by type
+ */
+export declare function getView(type: ViewType): View;
+export { FirstPersonView } from './FirstPersonView';
+export { ThirdPersonView } from './ThirdPersonView';
+export { ThirdPersonFixedView } from './ThirdPersonFixedView';
+export { TopDownView } from './TopDownView';
+export { TopDownFixedView } from './TopDownFixedView';
+export { IsometricView } from './IsometricView';
+export { SideOnView } from './SideOnView';
+export { MapView } from './MapView';
+export { VehicleView } from './VehicleView';
+export { VehicleFixedView } from './VehicleFixedView';
+export { TwinStickView } from './TwinStickView';
+export { MobaView } from './MobaView';
+export { AsteroidsView } from './AsteroidsView';
+export type { CrosshairConfig, CrosshairMode, View, ViewContext, ViewState } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/react/views/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/react/views/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAkCnC;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAE5C;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA"}

package/dist/types/react/views/types.d.ts

@@ -0,0 +1,136 @@
+import type { Camera, Object3D, Quaternion, Vector2, Vector3 } from 'three';
+import type { RawInput } from '../input/types';
+import type { PlayerProps } from '../types';
+/**
+ * State managed by a view
+ *
+ * Coordinate convention (matches Three.js):
+ * - Right-handed, Y-up, XZ ground plane
+ * - Forward = -Z in heading-space (matches Three.js camera/object look direction)
+ *
+ * Intent model:
+ * - `heading`: Movement reference frame (move vector is relative to this)
+ * - `aim`: Attack/targeting direction (where camera points)
+ * - `move`: Movement intent relative to heading (move.z < 0 = forward, move.z > 0 = backward)
+ *
+ * For many views, heading === aim (same quaternion value).
+ *
+ * Views where aim can differ from heading:
+ * - Orbit-style thirdPerson: aim follows direction of travel while heading stays camera-relative.
+ * - Vehicle: heading = body direction (from server), aim = mouse direction
+ * - TwinStick: heading = screen up (fixed), aim = cursor direction
+ * - Moba: heading = iso camera direction (fixed), aim = cursor direction
+ */
+export interface ViewState {
+    /** Horizontal orbit angle (radians) */
+    yaw: number;
+    /** Vertical look angle (radians, clamped) */
+    pitch: number;
+    /** Movement reference frame (facing direction quaternion) */
+    heading: Quaternion;
+    /** Attack/look direction (where camera points) */
+    aim: Quaternion;
+    /** Current movement intent relative to heading (move.z < 0 = forward) */
+    move: Vector3;
+    /** Standard action flags (bitmask of ACTION_* constants, passed through from RawInput) */
+    actions: number;
+    /** Pan offset X (world units) - used by GodCam */
+    panX?: number;
+    /** Pan offset Z (world units) - used by GodCam */
+    panZ?: number;
+    /** Zoom multiplier - used by GodCam */
+    zoom?: number;
+    /** Facing direction (+1 or -1) - used by SideOnView */
+    facingDirection?: number;
+}
+/**
+ * Context passed to view update/apply functions
+ */
+export interface ViewContext {
+    /** Current body position */
+    position: Vector3;
+    /** Current body rotation */
+    rotation: Quaternion;
+    /**
+     * Pointer position in normalized device coordinates (NDC), typically from R3F:
+     * - x,y are in [-1, +1]
+     * - (0,0) is the center of the canvas
+     *
+     * Optional for backwards compatibility; views that need cursor-based aiming can use it.
+     */
+    pointer?: Vector2;
+    /** Camera pivot (controls yaw and follows player) */
+    pivot: Object3D;
+    /** Camera (controls pitch and distance from pivot) */
+    camera: Camera;
+    /** Raw input from input mapper */
+    input: RawInput;
+    /** Delta time since last frame */
+    delta: number;
+    /** View-specific props from Player component (all optional) */
+    props: {
+        cameraDistance: number | undefined;
+        cameraHeight: number | undefined;
+        cameraOffset: PlayerProps['cameraOffset'];
+        damping: number | undefined;
+        cameraAngle: number | undefined;
+        fixedYaw: number | undefined;
+        reverseCam: boolean | undefined;
+    };
+}
+/**
+ * Interface for view implementations
+ */
+/**
+ * Crosshair positioning mode for different view types
+ */
+export type CrosshairMode = 'center' | 'cursor' | 'none';
+/**
+ * Crosshair configuration for a view
+ */
+export interface CrosshairConfig {
+    mode: CrosshairMode;
+    /**
+     * Vertical offset as percentage of screen height (positive = down).
+     * Used to compensate for parallax in third-person views where bullets
+     * fire from player position, not camera position.
+     */
+    offsetY?: number;
+}
+export interface View {
+    /** Human-readable name */
+    name: string;
+    /**
+     * If true, the player body rotation follows the view's heading.
+     * Used by firstPerson and thirdPersonFixed where camera+body rotate together.
+     * Default: false (body rotation comes from server/props)
+     */
+    bodyFollowsHeading?: boolean;
+    /**
+     * How the crosshair should be positioned for this view.
+     * - 'center': Fixed at screen center (FPS, third-person mouselook)
+     * - 'cursor': Follows mouse cursor position (twin-stick, MOBA)
+     * - 'none': No crosshair (map, sideOn, asteroids)
+     * Default: 'none'
+     */
+    crosshairMode?: CrosshairMode;
+    /**
+     * Vertical offset for the crosshair as percentage of screen height.
+     * Positive values move the crosshair down.
+     * Used to compensate for parallax in third-person views.
+     */
+    crosshairOffsetY?: number;
+    /** Initialize view state, optionally preserving values from previous view */
+    init(prevState?: ViewState): ViewState;
+    /**
+     * Update view state based on input
+     * Called every frame when enableInput is true
+     */
+    update(state: ViewState, ctx: ViewContext): ViewState;
+    /**
+     * Position and orient the pivot and camera based on current state
+     * Called every frame
+     */
+    applyToCamera(state: ViewState, ctx: ViewContext): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/react/views/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/react/views/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAA;IACX,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,OAAO,EAAE,UAAU,CAAA;IACnB,kDAAkD;IAClD,GAAG,EAAE,UAAU,CAAA;IACf,yEAAyE;IACzE,IAAI,EAAE,OAAO,CAAA;IACb,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAA;IAGf,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,QAAQ,EAAE,OAAO,CAAA;IACjB,4BAA4B;IAC5B,QAAQ,EAAE,UAAU,CAAA;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,qDAAqD;IACrD,KAAK,EAAE,QAAQ,CAAA;IACf,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAA;IACd,kCAAkC;IAClC,KAAK,EAAE,QAAQ,CAAA;IACf,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,+DAA+D;IAC/D,KAAK,EAAE;QACL,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;QAClC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;QAChC,YAAY,EAAE,WAAW,CAAC,cAAc,CAAC,CAAA;QACzC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;QAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;QAC/B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;QAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;KAChC,CAAA;CACF;AAED;;GAEG;AACH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAA;AAExD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAA;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,IAAI;IACnB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAE5B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAE7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,6EAA6E;IAC7E,IAAI,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;IAEtC;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,SAAS,CAAA;IAErD;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAAA;CACxD"}

package/dist/types/rollback.d.ts

@@ -0,0 +1,193 @@
+/**
+ * StateManager - Orchestrates InputGraph, state transitions, and caching with automatic rollback support.
+ *
+ * Key features:
+ * - Pure determinism: Transition function receives only what it needs
+ * - Automatic rollback: Detects when ticks arrive earlier than current position
+ * - Cache optimization: Skips computation when cache hits
+ * - Sync checkpoint: Pins sync head state (can never rollback past it)
+ * - Web worker ready: Transferable Uint8Array buffers
+ * - Pluggable transitions: Same interface for JS or WASM implementations
+ *
+ * @module state-manager
+ */
+import { type AsyncTickLog } from './input-graph';
+import { type InputCodec, InputInstance } from './input-codec';
+import { StateCache } from './cache';
+import { type CompiledSchema, type StateBuffer } from './state';
+import { type BatchTransitionExecutor, type ExecutorOptions } from './executor';
+/**
+ * Context passed to per-tick JS transition functions.
+ * Used with createJsTransition helper.
+ */
+export interface TransitionContext {
+    /** Compiled state schema (pass to state.ts functions) */
+    schema: CompiledSchema;
+    /** State buffer to mutate */
+    state: StateBuffer;
+    /** Current tick number */
+    tick: number;
+    /** Decoded inputs, one per participant */
+    inputs: InputInstance[];
+}
+/**
+ * Result of a tick() call.
+ */
+export interface TickResult {
+    /** The state buffer after applying ticks (transferable) */
+    state: Uint8Array;
+    /** The tick number of the returned state - null if t=0 is not yet initialized */
+    tick: number | null;
+    /** Node ID for the returned state (pass to next tick() call) */
+    nodeId: string;
+    /** True if rollback occurred */
+    rolledBack: boolean;
+    /** Number of ticks computed (0 if all cache hits) */
+    ticksComputed: number;
+}
+/**
+ * Options for StateManager configuration.
+ */
+export type RollbackOptions = {
+    /** Be noisy in the console */
+    debug?: boolean | undefined;
+    /** Compiled state schema */
+    stateSchema: CompiledSchema;
+    /** InputGraph for tick data - pass via setLog() for MessagePort transfer to work */
+    log?: AsyncTickLog;
+    /** Genesis hash for genesis state */
+    genesisHash: Uint8Array;
+    /** Tick rate in Hz (ticks per second) - stored in state header for physics */
+    tickRate?: number;
+    /** Optional cache (created internally if not provided) */
+    cache?: StateCache;
+    /**
+     * Executor configuration - either:
+     * - ExecutorOptions: WASM module config (creates Executor internally)
+     * - BatchTransitionExecutor: Pre-built executor (useful for testing/mocking)
+     */
+    executor: ExecutorOptions | BatchTransitionExecutor;
+    /** grace backoff period between tick attempts that result in no new ticks (default 10ms) */
+    tickGraceMs?: number | undefined;
+    /** number of ticks to lag behind the input graph (default 1), larger will mean
+     * fewer rollbacks but simulation will lag behind reality */
+    tickLag?: number | undefined;
+    /** maximum number of ticks to process in a single batch (default 100) */
+    maxBatchSize?: number | undefined;
+    /** disable the tick loop (default false) - you will have to manually call tick() to advance the state*/
+    disableTicking?: boolean | undefined;
+};
+/**
+ * Create a batch transition function from a per-tick JS function.
+ */
+export declare function createJsExecutor(schema: CompiledSchema, inputCodec: InputCodec, perTick: (ctx: TransitionContext) => void): BatchTransitionExecutor;
+type OnStateUpdateFn = (state: StateBuffer) => void;
+/**
+ * Manages state transitions with automatic rollback support.
+ *
+ * @example
+ * ```typescript
+ * ```
+ */
+export declare class Rollback {
+    private debug;
+    private stateSchema;
+    private inputs;
+    private cache;
+    private executor;
+    private genesisStateId;
+    private options;
+    private ticking;
+    private tickGraceMs;
+    private tickLag;
+    private maxBatchSize;
+    private currentState;
+    private currentTick;
+    private currentNodeId;
+    private prevOnStateUpdateState;
+    private onStateUpdate?;
+    private syncCheckpoint;
+    private readonly stateHistory;
+    private readonly maxHistory;
+    private stats;
+    constructor(options: RollbackOptions);
+    /**
+     * Set the tick log (for MessagePort transfer via comlink).
+     * Must be called before init() if log wasn't provided in constructor.
+     */
+    setLog(port: MessagePort): void;
+    /**
+     * Set the state update callback.
+     * Must be called before init() if onStateUpdate wasn't provided in constructor.
+     */
+    setOnStateUpdate(callback: OnStateUpdateFn | null): void;
+    init(): Promise<StateBuffer>;
+    private loop;
+    private _loop;
+    /**
+     * Advance state by processing available ticks from InputGraph.
+     * Automatically handles rollback when earlier ticks arrive.
+     *
+     * Strategy:
+     * 1. Fast-forward through cache hits (O(1) lookup per tick)
+     * 2. Split remaining ticks at sync boundary
+     * 3. Process sync ticks, checkpoint the result
+     * 4. Process predicted ticks
+     * @param maxTickNum - Optional limit on largest tick number to process.
+     *
+     * @returns TickResult with new state and metadata
+     */
+    tick(maxTickNum?: number | null): Promise<TickResult>;
+    getStats(): Promise<{
+        rollbacks: number;
+        executions: number;
+        updates: number;
+    }>;
+    /**
+     * Process ticks with cache fast-forward, then batch the rest.
+     *
+     * @returns Number of ticks computed (excludes cache hits)
+     */
+    private processTicks;
+    /**
+     * Compute the final stateId after processing a batch of ticks.
+     * StateId is computed incrementally: hash(prevStateId || tick || payloads)
+     */
+    private computeBatchStateId;
+    /**
+     * Get current state (copy, safe to transfer).
+     */
+    getState(): Uint8Array;
+    /**
+     * Get current tick number.
+     */
+    getTick(): number | null;
+    /**
+     * Reset to genesis state.
+     */
+    reset(): void;
+    close(): void;
+    /**
+     * Rollback to process from the target tick onwards.
+     *
+     * The goal is to find the best starting point:
+     * - If checkpoint is at or past the target, we can skip some ticks
+     * - Otherwise, find the closest state before the target
+     */
+    private rollbackTo;
+    /**
+     * Update the sync checkpoint with the latest sync tick state.
+     * This state is pinned and won't be evicted.
+     */
+    private updateSyncCheckpoint;
+    /**
+     * Record a recent snapshot for rollback recovery.
+     */
+    private recordStateSnapshot;
+    /**
+     * Find the newest snapshot at or before the requested tick.
+     */
+    private findSnapshotAtOrBefore;
+}
+export {};
+//# sourceMappingURL=rollback.d.ts.map

package/dist/types/rollback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollback.d.ts","sourceRoot":"","sources":["../../src/rollback.ts"],"names":[],"mappings":"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"}

package/dist/types/rollback.worker.d.ts

@@ -0,0 +1,3 @@
+declare const _default: new () => Worker;
+export default _default;
+//# sourceMappingURL=rollback.worker.d.ts.map

package/dist/types/rollback.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollback.worker.d.ts","sourceRoot":"","sources":["../../src/rollback.worker.ts"],"names":[],"mappings":"wBAMkC,UAAU,MAAM;AAAlD,wBAAmD"}

package/dist/types/schema.d.ts

@@ -0,0 +1,309 @@
+/**
+ * Shared schema types and compilation for state and input.
+ *
+ * This module contains all type definitions and compilation functions needed
+ * by both the runtime (state.ts, input-codec.ts) and the codegen system.
+ *
+ * @module schema
+ */
+/**
+ * Magic number for state buffer header: "MTAP" in ASCII (0x4D544150)
+ * Used to identify valid state buffers.
+ */
+export declare const MAGIC = 1297367376;
+/**
+ * Null entity reference value (0xFFFFFFFF).
+ * Used to represent "no entity" in entityRef fields.
+ */
+export declare const NULL_ENTITY: EntityRef;
+/** Size of the state buffer header in bytes */
+export declare const HEADER_SIZE = 44;
+/** Offset of the stateId field in the header */
+export declare const STATE_ID_OFFSET = 8;
+/** Size of the stateId field (SHA256 hash) */
+export declare const STATE_ID_SIZE = 32;
+/** Offset of the tick field in the header */
+export declare const TICK_OFFSET = 40;
+/** Offset of the tick rate field in the header (uses one of the reserved bytes) */
+export declare const TICK_RATE_OFFSET = 6;
+/** Byte sizes for state primitive types (excludes input-specific flags types) */
+export declare const TYPE_SIZES: Record<string, number>;
+/** Byte sizes for input types (includes flags types) */
+export declare const INPUT_TYPE_SIZES: Record<string, number>;
+/** Valid primitive types that can be used as array element types */
+export declare const PRIMITIVE_TYPES: Set<string>;
+/** Valid primitive scalar types for input array elements (excludes entityRef) */
+export declare const INPUT_PRIMITIVE_SCALAR_TYPES: Set<string>;
+export type Vec2 = [number, number];
+export type Vec3 = [number, number, number];
+export type Quat = [number, number, number, number];
+/**
+ * Primitive field types supported by the ECS.
+ */
+export type PrimitiveType = 'bool' | 'uint8' | 'int8' | 'uint16' | 'int16' | 'uint32' | 'int32' | 'entityRef' | 'f32';
+/**
+ * Compound field types (vectors and quaternions).
+ */
+export type CompoundType = 'vec2' | 'vec3' | 'quat';
+/**
+ * Fixed-size array type pattern: "type[length]"
+ */
+export type ArrayType = `${PrimitiveType}[${number}]`;
+/**
+ * Enum field type (backed by uint8).
+ */
+export type EnumType = 'enum';
+/**
+ * All valid field types.
+ */
+export type FieldType = PrimitiveType | CompoundType | ArrayType | EnumType;
+/**
+ * Entity reference - a 32-bit packed value containing index and generation.
+ */
+export type EntityRef = number;
+/**
+ * State buffer type alias.
+ */
+export type StateBuffer = Uint8Array;
+/**
+ * Field definition for compound components.
+ */
+export interface FieldDef {
+    readonly name: string;
+    readonly type: string;
+    readonly variants?: readonly string[];
+}
+/**
+ * Component definition.
+ */
+export interface ComponentDef {
+    readonly name: string;
+    readonly type: string;
+    readonly singleton?: boolean;
+    readonly fields?: readonly FieldDef[];
+    readonly variants?: readonly string[];
+}
+/**
+ * Event definition.
+ */
+export interface EventDef {
+    readonly name: string;
+    readonly maxEvents?: number;
+    readonly fields: readonly FieldDef[];
+}
+/**
+ * State schema definition.
+ */
+export interface StateSchema {
+    readonly maxEntities: number;
+    readonly components: readonly ComponentDef[];
+    readonly events?: readonly EventDef[];
+}
+/**
+ * Flag type names for input controls.
+ */
+export type FlagType = 'flags8' | 'flags16' | 'flags32';
+/**
+ * Input field type (includes flag types).
+ */
+export type InputFieldType = PrimitiveType | FlagType | CompoundType | ArrayType;
+/**
+ * Control definition in input schema.
+ */
+export interface ControlDef {
+    readonly name: string;
+    readonly type: string;
+    readonly options?: readonly string[];
+    readonly hint?: string;
+    readonly retain?: 'tick' | 'always';
+}
+/**
+ * Command argument definition.
+ */
+export interface CommandArgDef {
+    readonly name: string;
+    readonly type: string;
+}
+/**
+ * Command definition in input schema.
+ */
+export interface CommandDef {
+    readonly name: string;
+    readonly args: readonly CommandArgDef[];
+}
+/**
+ * Input schema definition.
+ */
+export interface InputSchema {
+    readonly controls: readonly ControlDef[];
+    readonly commands: readonly CommandDef[];
+}
+/**
+ * Compiled field information with pre-calculated offsets.
+ */
+export interface CompiledField {
+    name: string;
+    type: FieldType;
+    size: number;
+    offset: number;
+    arrayLength?: number;
+    arrayElementType?: PrimitiveType;
+    variants?: string[];
+}
+/**
+ * Compiled component information with pre-calculated offsets.
+ */
+export interface CompiledComponent {
+    name: string;
+    index: number;
+    isTag: boolean;
+    isSingleton: boolean;
+    size: number;
+    storageOffset: number;
+    fields: CompiledField[];
+}
+/**
+ * Compiled event information with pre-calculated layout.
+ */
+export interface CompiledEvent {
+    name: string;
+    index: number;
+    maxEvents: number;
+    recordSize: number;
+    storageOffset: number;
+    bufferSize: number;
+    fields: CompiledField[];
+}
+/**
+ * Compiled state schema with all pre-calculated layout information.
+ */
+export interface CompiledStateSchema {
+    maxEntities: number;
+    components: CompiledComponent[];
+    entityComponents: CompiledComponent[];
+    singletonComponents: CompiledComponent[];
+    componentByName: Map<string, CompiledComponent>;
+    definition: StateSchema;
+    events?: CompiledEvent[] | undefined;
+    eventByName?: Map<string, CompiledEvent> | undefined;
+    headerOffset: 0;
+    headerSize: number;
+    entityTableOffset: number;
+    entityRecordSize: number;
+    freeStackOffset: number;
+    freeStackSize: number;
+    componentStorageOffset: number;
+    singletonStorageOffset: number;
+    singletonStorageSize: number;
+    eventStorageOffset?: number | undefined;
+    eventStorageSize?: number | undefined;
+    totalSize: number;
+    bitmaskSize: number;
+}
+/**
+ * Compiled control information with pre-calculated layout.
+ * Matches Go's CompiledControl structure for codegen compatibility.
+ */
+export interface CompiledControl {
+    name: string;
+    index: number;
+    type: string;
+    size: number;
+    options?: readonly string[] | undefined;
+    hint?: string | undefined;
+    retain: 'tick' | 'always';
+}
+/**
+ * Compiled command argument (uses same structure as CompiledField).
+ */
+export interface CompiledCommandArg {
+    name: string;
+    type: string;
+    size: number;
+    offset: number;
+    arrayLength?: number;
+    arrayElementType?: string;
+}
+/**
+ * Compiled command information with pre-calculated layout.
+ */
+export interface CompiledCommand {
+    name: string;
+    index: number;
+    args: CompiledCommandArg[];
+    totalSize: number;
+}
+/**
+ * Compiled input schema with pre-calculated information for encoding/decoding.
+ */
+export interface CompiledInputSchema {
+    controls: CompiledControl[];
+    commands: CompiledCommand[];
+    controlByName: Map<string, CompiledControl>;
+    commandByName: Map<string, CompiledCommand>;
+}
+/**
+ * Parse an array type string like "uint16[8]" into element type and length.
+ * Only primitive types (not vec2/vec3) are valid array element types.
+ */
+export declare function parseArrayType(type: string): {
+    elementType: PrimitiveType;
+    length: number;
+} | null;
+/**
+ * Parse an input array type string (allows any primitive scalar type).
+ */
+export declare function parseInputArrayType(type: string): {
+    elementType: string;
+    length: number;
+} | null;
+/**
+ * Calculate the byte size of a state field type.
+ */
+export declare function getTypeSize(type: FieldType): number;
+/**
+ * Calculate the byte size of an input field type.
+ */
+export declare function getInputTypeSize(type: string): number;
+/**
+ * Wrapper around getTypeSize that rethrows errors with component/field context.
+ */
+export declare function getValidatedTypeSize(type: string, componentName: string, fieldName?: string): number;
+/**
+ * Validate enum variants.
+ */
+export declare function validateEnumVariants(rawVariants: unknown, subject: string): string[];
+/**
+ * Convert a string from PascalCase/camelCase to UPPER_SNAKE_CASE.
+ */
+export declare function toUpperSnake(s: string): string;
+/**
+ * Convert a string to lower_snake_case.
+ */
+export declare function toLowerSnake(s: string): string;
+/**
+ * Convert a string to camelCase.
+ */
+export declare function toCamelCase(s: string): string;
+/**
+ * Convert a string to PascalCase.
+ */
+export declare function toPascalCase(s: string): string;
+/**
+ * Check if a schema is already compiled.
+ */
+export declare function isCompiledStateSchema(schema: StateSchema | CompiledStateSchema): schema is CompiledStateSchema;
+/**
+ * Compile a state schema if needed, or return it if already compiled.
+ * Also hydrates componentByName and eventByName Maps for Go-compiled schemas.
+ */
+export declare function ensureCompiledStateSchema(schema: StateSchema | CompiledStateSchema): CompiledStateSchema;
+/**
+ * Compile a state schema definition into a CompiledStateSchema with all layout offsets.
+ */
+export declare function compileStateSchema(schema: StateSchema): CompiledStateSchema;
+/**
+ * Compile an input schema definition into a CompiledInputSchema.
+ */
+export declare function compileInputSchema(schema: InputSchema): CompiledInputSchema;
+//# sourceMappingURL=schema.d.ts.map