@multitapio/multitap 0.0.1

package/dist/stats.d.ts

@@ -0,0 +1,21 @@
+export declare class RollingCounter {
+    private readonly buffer;
+    private readonly windowMs;
+    private head;
+    private tail;
+    private size;
+    constructor(windowMs?: number, maxEvents?: number);
+    /**
+     * Record a single event at the given timestamp
+     */
+    inc(): void;
+    /**
+     * Returns number of events within the rolling window
+     */
+    count(now?: number): number;
+    /**
+     * Returns the rate of events per second
+     */
+    rate(now?: number): number;
+}
+//# sourceMappingURL=stats.d.ts.map

package/dist/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/stats.ts"],"names":[],"mappings":"AAEA,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;gBAEL,QAAQ,GAAE,MAAa,EAAE,SAAS,GAAE,MAAa;IAK7D;;OAEG;IACH,GAAG,IAAI,IAAI;IAcX;;OAEG;IACH,KAAK,CAAC,GAAG,GAAE,MAA0B,GAAG,MAAM;IAc9C;;OAEG;IACH,IAAI,CAAC,GAAG,GAAE,MAA0B,GAAG,MAAM;CAG9C"}

package/dist/test-session.d.ts

@@ -0,0 +1,170 @@
+/**
+ * TestSession - Headless simulation testing for Multitap games.
+ *
+ * Enables AI agents and developers to test game logic without network or WebWorkers.
+ * Wraps Rollback + InputGraph with a simple API for input simulation and state inspection.
+ *
+ * Features:
+ * - Auto-generated player keys (no crypto knowledge needed)
+ * - State history with cursor for rollback testing
+ * - Direct state buffer access for use with generated ECS bindings
+ *
+ * @module test-session
+ */
+import { type TickResult } from './rollback';
+import { type CompiledSchema, type StateSchema, type StateBuffer } from './state';
+import { type InputSchema } from './input-codec';
+import type { Participant, SessionOptions, MultitapPlugin } from './session';
+/**
+ * Options for creating a TestSession.
+ */
+export interface TestSessionOptions {
+    /** Plugins array (WASM modules in execution order) */
+    plugins: MultitapPlugin[];
+    /** State and input schemas */
+    schema: {
+        state: StateSchema | CompiledSchema;
+        input: InputSchema;
+    };
+    /** Tick rate in Hz (default: 20) */
+    tickRate?: number;
+    /** Maximum ticks for the session (default: 10000) */
+    maxTicks?: number;
+}
+/**
+ * A test player that can submit inputs.
+ */
+export interface TestPlayer {
+    /** The player's slot index (0-15) */
+    readonly index: number;
+    /**
+     * Queue an input for this player.
+     * The input will be applied on the next tick() call.
+     *
+     * @param payload - Raw input bytes (use InputCodec to encode)
+     *
+     * @example
+     * ```typescript
+     * const inputCodec = compileInputCodec(inputSchema);
+     * const input = inputCodec.create();
+     * input.setFlags('buttons', { up: true, fire: true });
+     * player.input(input.encode());
+     * ```
+     */
+    input(payload: Uint8Array): void;
+}
+/**
+ * TestSession provides headless simulation testing for Multitap games.
+ *
+ * @example
+ * ```typescript
+ * const session = await TestSession.create({
+ *   plugins: [{ name: 'game', wasmBytes, reservedBytes: 4194304 }],
+ *   schema: { state: stateSchema, input: inputSchema },
+ * });
+ *
+ * const p1 = session.addPlayer();
+ * const p2 = session.addPlayer();
+ *
+ * p1.input({ buttons: { up: true } });
+ * p2.input({ buttons: { fire: true } });
+ *
+ * await session.tick();
+ * console.log('Tick:', session.getTick()); // 1
+ *
+ * // Test rollback
+ * await session.tick(10);
+ * session.rollback(5);
+ * await session.tick();
+ * console.log('Tick:', session.getTick()); // 6
+ *
+ * // Use state with generated bindings
+ * const state = session.getState();
+ * ```
+ */
+export declare class TestSession {
+    private inputGraph;
+    private asyncInputGraph;
+    private rollbackManager;
+    private executor;
+    private stateSchema;
+    private inputCodec;
+    private genesisHash;
+    private players;
+    private joinedPlayers;
+    private pendingInputs;
+    private states;
+    private cursor;
+    private constructor();
+    /**
+     * Create a new TestSession.
+     */
+    static create(options: TestSessionOptions): Promise<TestSession>;
+    getParticipants(): Participant[];
+    /**
+     * Create a TestSession from SessionOptions.
+     * Ignores network-related properties (playerKey, authority, renderer, etc.)
+     *
+     * This allows using the same options object for both production Session
+     * and headless TestSession.
+     */
+    static fromConfig(options: SessionOptions): Promise<TestSession>;
+    /**
+     * Add a new player to the session.
+     * Returns a TestPlayer wrapper for submitting inputs.
+     *
+     * @param privateKey - Optional private key for deterministic replay testing
+     */
+    addPlayer(privateKey?: Uint8Array): TestPlayer;
+    /**
+     * Queue an input for a player. Called by TestPlayer.input().
+     * @internal
+     */
+    _queueInput(playerIndex: number, privateKey: Uint8Array, payload: Uint8Array): void;
+    /**
+     * Advance the simulation by one or more ticks.
+     *
+     * If cursor is behind the state history, this just moves the cursor forward.
+     * Otherwise, it runs the actual simulation to compute new states.
+     */
+    tick(count?: number): Promise<TickResult>;
+    /**
+     * Run multiple ticks with an optional callback before each tick.
+     *
+     * @param count - Number of ticks to run
+     * @param onTick - Optional callback called before each tick with current tick number
+     * @returns The result of the last tick
+     *
+     * @example
+     * ```typescript
+     * // Run 50 ticks with player input each tick
+     * await session.runTicks(50, () => {
+     *   player.input(fireInput);
+     * });
+     * ```
+     */
+    runTicks(count: number, onTick?: (tick: number) => Promise<void>): Promise<TickResult>;
+    /**
+     * Rewind the simulation to a previous tick.
+     * The next tick() call will produce tick N+1.
+     */
+    rollback(toTick: number): void;
+    /**
+     * Get the current state buffer.
+     * Use with generated ECS bindings for state inspection.
+     */
+    getState(): StateBuffer;
+    /**
+     * Get the current tick number.
+     */
+    getTick(): number;
+    /**
+     * Clean up resources.
+     */
+    close(): void;
+    /**
+     * Compute the next tick by processing pending inputs.
+     */
+    private computeNextTick;
+}
+//# sourceMappingURL=test-session.d.ts.map

package/dist/test-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-session.d.ts","sourceRoot":"","sources":["../../src/test-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAkB,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAClG,OAAO,EAAsC,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAIrF,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAM7E;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,OAAO,EAAE,cAAc,EAAE,CAAC;IAE1B,8BAA8B;IAC9B,MAAM,EAAE;QACN,KAAK,EAAE,WAAW,GAAG,cAAc,CAAC;QACpC,KAAK,EAAE,WAAW,CAAC;KACpB,CAAC;IAEF,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CAClC;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAW;IAEtB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAe;IACtC,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,QAAQ,CAA0B;IAG1C,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,UAAU,CAAa;IAG/B,OAAO,CAAC,WAAW,CAAa;IAGhC,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,aAAa,CAA0B;IAG/C,OAAO,CAAC,aAAa,CAA2E;IAGhG,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,MAAM,CAAa;IAE3B,OAAO;IAuBP;;OAEG;WACU,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC;IAgEtE,eAAe,IAAI,WAAW,EAAE;IAIhC;;;;;;OAMG;WACU,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IAStE;;;;;OAKG;IACH,SAAS,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,UAAU;IAQ9C;;;OAGG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAInF;;;;;OAKG;IACG,IAAI,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAuBlD;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;IAW5F;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO9B;;;OAGG;IACH,QAAQ,IAAI,WAAW;IAIvB;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;YACW,eAAe;CA+C9B"}

package/dist/types/cache.d.ts

@@ -0,0 +1,117 @@
+/**
+ * State Cache for Rollback Networking
+ *
+ * Provides O(1) lookup of cached states by their stateId.
+ * Used during rollback to avoid redundant state transitions when
+ * authoritative inputs match predictions.
+ *
+ * @module state-cache
+ */
+/**
+ * Convert a 32-byte stateId to a 64-character hex string for use as Map key.
+ */
+export declare function stateIdToKey(stateId: Uint8Array): string;
+/**
+ * Convert a 64-character hex string back to a 32-byte stateId.
+ */
+export declare function keyToStateId(key: string): Uint8Array;
+/**
+ * Options for StateCache configuration.
+ */
+export interface StateCacheOptions {
+    /** Maximum number of states to cache. Default: 100. */
+    maxSize?: number;
+}
+/**
+ * Cache for state snapshots keyed by stateId.
+ *
+ * Provides O(1) lookup to avoid redundant state transitions during rollback.
+ * When authoritative inputs match predictions, we can retrieve the cached
+ * state instead of recomputing.
+ *
+ * @example
+ * ```typescript
+ * const cache = new StateCache();
+ *
+ * // After computing a state transition
+ * cache.store(state);
+ *
+ * // Before computing a state transition, check cache
+ * const cached = cache.getCached(prevState, tick, orderedPayloadsHash);
+ * if (cached) {
+ *   // Use cached state, skip computation
+ *   return cached;
+ * }
+ * ```
+ */
+export declare class StateCache {
+    private cache;
+    private maxSize;
+    constructor(options?: StateCacheOptions);
+    /**
+     * Store a state in the cache, keyed by its embedded stateId.
+     * Makes a copy of the state buffer to prevent mutation issues.
+     *
+     * @param state - State buffer to cache
+     */
+    store(state: Uint8Array): void;
+    /**
+     * Get a cached state by its stateId.
+     * Returns a copy of the cached state, or undefined if not found.
+     *
+     * @param stateId - 32-byte stateId to look up
+     * @returns Copy of cached state, or undefined
+     */
+    getByStateId(stateId: Uint8Array): Uint8Array | undefined;
+    /**
+     * Get the cached state that would result from a state transition.
+     *
+     * This is the key API for rollback optimization:
+     * - Computes what the resulting stateId would be
+     * - Looks up that stateId in the cache
+     * - If found, returns the cached state (avoiding recomputation)
+     *
+     * @param prevState - Previous state buffer
+     * @param tick - Tick number
+     * @param orderedPayloadsHash - 32-byte hash of ordered payloads (one per participant at stable indices)
+     * @returns Copy of cached state, or undefined if not found
+     */
+    getCached(prevState: Uint8Array, tick: number, orderedPayloadsHash: Uint8Array): Uint8Array | undefined;
+    /**
+     * Check if we have a cached state for a given stateId.
+     *
+     * @param stateId - 32-byte stateId to check
+     * @returns true if cached
+     */
+    has(stateId: Uint8Array): boolean;
+    /**
+     * Check if we would have a cached state after a transition.
+     *
+     * @param prevState - Previous state buffer
+     * @param tick - Tick number
+     * @param orderedPayloadsHash - 32-byte hash of ordered payloads (one per participant at stable indices)
+     * @returns true if we have a cached result for this transition
+     */
+    hasCached(prevState: Uint8Array, tick: number, orderedPayloadsHash: Uint8Array): boolean;
+    /**
+     * Remove a cached state by its stateId.
+     *
+     * @param stateId - 32-byte stateId to remove
+     * @returns true if the state was in the cache
+     */
+    delete(stateId: Uint8Array): boolean;
+    /**
+     * Clear all cached states.
+     */
+    clear(): void;
+    /**
+     * Get the number of cached states.
+     */
+    get size(): number;
+    /**
+     * Get all cached stateIds (as hex keys).
+     * Useful for debugging.
+     */
+    keys(): IterableIterator<string>;
+}
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAOxD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CASpD;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,GAAE,iBAAsB;IAK3C;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAgB9B;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS;IAMzD;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS;IAMvG;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO;IAKjC;;;;;;;OAOG;IACH,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,GAAG,OAAO;IAMxF;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO;IAKpC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC;CAGjC"}

package/dist/types/channel.d.ts

@@ -0,0 +1,91 @@
+import type { InputData, TickMessage } from './messages';
+import { InputGraph, type AsyncTickLog, type GetTicksAfterOptions, type Participant, type PayloadPredictor, type TickNode, type TickPrimitive } from './input-graph';
+export type TickListener = (tick: TickMessage, streamIndex: number) => void;
+export type StateListener = (connected: boolean) => void;
+export type StreamActivityListener = (streamIndex: number) => void;
+export type StreamLifecycleListener = (event: StreamLifecycleEvent) => void;
+export type UnsubscribeFn = () => void;
+export interface StreamLifecycleEvent {
+    type: 'added' | 'removed';
+    index: number;
+}
+export interface ChannelConfig {
+    /** multitap:// connection URL (will be base64-encoded for transport) */
+    connectionURL: string;
+    serverCertHash: string | null | undefined;
+    privateKey?: Uint8Array;
+    relayPubKey?: Uint8Array | undefined | null;
+    inputPayloadPredictor?: PayloadPredictor | null;
+    debug?: boolean | undefined;
+    autoConnect?: boolean | undefined;
+    connectionTimeoutMs?: number | undefined;
+    logSyncTicks?: boolean | undefined;
+}
+export declare class Channel implements AsyncTickLog {
+    readonly connectionURL: string;
+    readonly serverCertHash: string | null | undefined;
+    readonly connectionTimeoutMs: number;
+    private privateKey;
+    private publicKey;
+    private genesisHash;
+    private sessionConfig;
+    private transport;
+    private streams;
+    private replayStreams;
+    private roundRobinIndex;
+    private connectionGeneration;
+    private connected;
+    private stopped;
+    private debug;
+    private logSyncTicks;
+    private outbox;
+    private stateListeners;
+    private flushingOutbox;
+    private tickRate;
+    inputGraph: InputGraph;
+    private tickDeadlineWants;
+    private tickDeadlineTimer;
+    private tickDeadlineGrace;
+    private stats;
+    constructor(config: ChannelConfig);
+    connect(): Promise<void>;
+    getPublicKey(): Promise<Uint8Array<ArrayBufferLike>>;
+    getGenesisHash(): Promise<Uint8Array<ArrayBufferLike>>;
+    onStateChange(fn: StateListener): UnsubscribeFn;
+    getStats(): {
+        activeStreams: number;
+        totalStreams: number;
+        messagesRecv: number;
+        messagesSent: number;
+        reconnections: number;
+    };
+    getTickRate(): Promise<number>;
+    getParticipantSlots(tick: number): Promise<Participant[]>;
+    getSyncHead(): Promise<TickNode>;
+    getPredictedHead(): Promise<TickNode>;
+    addSyncTick(msg: TickMessage): Promise<void>;
+    addOptimisticInput(input: InputData, preVerifiedSigner?: Uint8Array): Promise<void>;
+    getPredictionCount(): Promise<number>;
+    getTicksAfter(nodeId: string | null, options?: GetTicksAfterOptions): Promise<TickPrimitive[]>;
+    setOnParticipantJoined(fn: (participant: Participant) => void): Promise<void>;
+    expose(port: MessagePort): Promise<void>;
+    close(): Promise<void>;
+    private _setConnected;
+    private _send;
+    private _generateNullInput;
+    sendSignedInput(payload: Uint8Array, targetTick?: number): Promise<Uint8Array>;
+    private _nextStream;
+    private _connectLoop;
+    private _acceptStreamsLoop;
+    private _addStream;
+    private _dropStream;
+    private _cleanupHandle;
+    private _flushOutbox;
+    private _cleanupTransport;
+    private _readLoop;
+    private _maybeResetDeadline;
+    private _resetDeadline;
+    private _onTickDeadlineExceeded;
+    private _concatBuffers;
+}
+//# sourceMappingURL=channel.d.ts.map

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

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

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

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

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

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

package/dist/types/codegen/config.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Configuration loading and plugin graph management for codegen.
+ *
+ * This module provides:
+ * - Config type matching mt.config.json structure
+ * - Project loading and config file discovery
+ * - Plugin dependency graph construction
+ * - Schema merging across plugins
+ *
+ * @module codegen/config
+ */
+import type { StateSchema, InputSchema } from '../schema';
+/**
+ * WASM configuration for plugins.
+ */
+export interface WasmConfig {
+    /** Number of bytes to reserve in shared WASM memory for this plugin */
+    reservedBytes: number;
+}
+/**
+ * Root configuration structure (mt.config.json).
+ */
+export interface Config {
+    appID: string;
+    entrypoint: string;
+    output: string;
+    tests?: string[];
+    tickRate: number;
+    maxTicks: number;
+    maxParticipants: number;
+    plugins?: string[];
+    wasm?: WasmConfig;
+    input: InputSchema;
+    state: StateSchema;
+    fixtures?: unknown;
+}
+/**
+ * A loaded project with its configuration and paths.
+ */
+export interface Project {
+    /** Parsed project configuration */
+    config: Config;
+    /** Absolute path to the config file */
+    configPath: string;
+    /** Absolute path to the project directory */
+    dir: string;
+}
+/**
+ * A node in the plugin dependency graph.
+ */
+export interface PluginNode {
+    /** Absolute path to the plugin directory */
+    path: string;
+    /** Parsed plugin configuration */
+    config: Config;
+    /** Absolute paths of plugins this node depends on */
+    dependencies: string[];
+}
+/**
+ * The complete plugin dependency graph.
+ */
+export interface ConfigGraph {
+    /** Root project */
+    root: Project;
+    /** Plugin nodes mapped by absolute path */
+    plugins: Map<string, PluginNode>;
+    /** Topologically sorted list of plugin paths (dependencies first) */
+    order: string[];
+}
+/**
+ * Result of merging all plugin configs.
+ */
+export interface MergedConfig {
+    /** Merged configuration with all components */
+    config: Config;
+    /** Execution order of plugins (dependencies first) */
+    pluginOrder: string[];
+    /** Maps component names to the plugin path that defined them */
+    componentOwners: Map<string, string>;
+}
+/**
+ * Find a *mt.config.json file in the given path.
+ * If path is a file, returns it directly.
+ * If path is a directory, searches for files ending in mt.config.json.
+ */
+export declare function findConfig(path: string): string;
+/**
+ * Load and parse a config file.
+ */
+export declare function loadConfig(path: string): Config;
+/**
+ * Load a project from the given path.
+ * If path is a file, loads that config directly.
+ * If path is a directory, searches for a *mt.config.json file.
+ */
+export declare function loadProject(path: string): Project;
+/**
+ * Load the complete plugin dependency graph starting from a root project.
+ * Uses BFS to walk the dependency DAG.
+ */
+export declare function loadConfigGraph(root: Project): ConfigGraph;
+/**
+ * Merge all plugin configs into a single config.
+ * Components and events are merged in topological order with conflict detection.
+ */
+export declare function mergeConfigs(graph: ConfigGraph): MergedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/types/codegen/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/codegen/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAA0B,MAAM,WAAW,CAAC;AAMlF;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAMD;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,mBAAmB;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,2CAA2C;IAC3C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,qEAAqE;IACrE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gEAAgE;IAChE,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC;AAMD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB/C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ/C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAUjD;AAgBD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAsE1D;AAsDD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAqF7D"}

package/dist/types/codegen/generator.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Code generator interface and utilities for codegen.
+ *
+ * This module defines the Generator interface and provides common utilities
+ * for name conversion and type mapping used by language-specific generators.
+ *
+ * @module codegen/generator
+ */
+import type { CompiledStateSchema, CompiledInputSchema } from '../schema';
+/**
+ * Options for code generators.
+ */
+export interface GeneratorOptions {
+    /** Optional plugin name for prefixing (e.g., "physics") */
+    pluginName?: string;
+}
+/**
+ * Code generator interface.
+ * Implementations produce language-specific code from compiled schemas.
+ */
+export interface Generator {
+    /** The target language */
+    readonly language: 'typescript' | 'rust';
+    /**
+     * Generate state accessor code from a compiled state schema.
+     * @param schema - Compiled state schema with layout information
+     * @returns Generated source code as a string
+     */
+    generateState(schema: CompiledStateSchema): string;
+    /**
+     * Generate input codec code from a compiled input schema.
+     * @param schema - Compiled input schema with control/command information
+     * @returns Generated source code as a string
+     */
+    generateInput(schema: CompiledInputSchema): string;
+    /**
+     * Generate combined game module with both state and input.
+     * @param state - Compiled state schema
+     * @param input - Compiled input schema
+     * @returns Generated source code as a string
+     */
+    generateGame(state: CompiledStateSchema, input: CompiledInputSchema): string;
+}
+/**
+ * Convert a string from PascalCase/camelCase to UPPER_SNAKE_CASE.
+ * @example toUpperSnake("RigidBodyType") // "RIGID_BODY_TYPE"
+ * @example toUpperSnake("shapeType") // "SHAPE_TYPE"
+ */
+export declare function toUpperSnake(s: string): string;
+/**
+ * Convert a string to lower_snake_case.
+ * @example toLowerSnake("RigidBodyType") // "rigid_body_type"
+ * @example toLowerSnake("PlayerIndex") // "player_index"
+ */
+export declare function toLowerSnake(s: string): string;
+/**
+ * Convert a string to camelCase.
+ * @example toCamelCase("player_index") // "playerIndex"
+ * @example toCamelCase("RIGID_BODY_TYPE") // "rigidBodyType"
+ */
+export declare function toCamelCase(s: string): string;
+/**
+ * Convert a string to PascalCase.
+ * @example toPascalCase("player_index") // "PlayerIndex"
+ * @example toPascalCase("rigidBodyType") // "RigidBodyType"
+ */
+export declare function toPascalCase(s: string): string;
+/**
+ * Parse array type string like "uint16[8]" into [elementType, length].
+ * Returns null if not a valid array type (must have primitive element type).
+ * Matches Go's ParseArrayType behavior which only allows primitive element types.
+ */
+export declare function parseArrayType(type: string): [string, number] | null;
+/** Check if a type needs endianness handling (multi-byte types) */
+export declare function needsEndian(type: string): boolean;
+/** Get the element size for a primitive type */
+export declare function getElementSize(type: string): number;
+//# sourceMappingURL=generator.d.ts.map

package/dist/types/codegen/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/codegen/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAM1E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,0BAA0B;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC;IAEzC;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAAC;IAEnD;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAAC;IAEnD;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAAC;CAC9E;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAU9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAU9C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAiB9C;AAmBD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CASpE;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYjD;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBnD"}

package/dist/types/codegen/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Code generation module for Multitap.
+ *
+ * Provides TypeScript and Rust code generators from compiled schemas.
+ *
+ * @module codegen
+ */
+export { type Config, type WasmConfig, type Project, type PluginNode, type ConfigGraph, type MergedConfig, findConfig, loadConfig, loadProject, loadConfigGraph, mergeConfigs, } from './config';
+export { buildPlayerComponent, injectPlayerComponent, buildCommandEvents, injectCommandEvents, prepareStateSchema, } from './inject';
+export { type Generator, type GeneratorOptions, toUpperSnake, toLowerSnake, toCamelCase, toPascalCase, parseArrayType, needsEndian, getElementSize, } from './generator';
+export { TypeScriptGenerator } from './typescript';
+export { RustGenerator } from './rust';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/codegen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/codegen/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,UAAU,EACV,UAAU,EACV,WAAW,EACX,eAAe,EACf,YAAY,GACb,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,cAAc,EACd,WAAW,EACX,cAAc,GACf,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC"}