@multitapio/multitap 0.0.1

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

@@ -0,0 +1,51 @@
+/**
+ * Player component and command event injection for codegen.
+ *
+ * This module provides functions to automatically generate:
+ * - Player component from input schema controls
+ * - Command events from input schema commands
+ *
+ * @module codegen/inject
+ */
+import type { StateSchema, ComponentDef, EventDef, CompiledInputSchema } from '../schema';
+/**
+ * Build a Player component definition from compiled input schema controls.
+ *
+ * The Player component contains:
+ * - `index` field (uint8) - identifies which player owns this entity
+ * - One field per control, with vec2/vec3/quat flattened to x/y/z/w components
+ * - Flag types (flags8/16/32) map to uint8/16/32
+ */
+export declare function buildPlayerComponent(inputSchema: CompiledInputSchema): ComponentDef;
+/**
+ * Inject the Player component into a state schema.
+ * Mutates the schema in place.
+ *
+ * @throws Error if schema already contains a 'Player' component
+ */
+export declare function injectPlayerComponent(schema: {
+    components: ComponentDef[];
+}, inputSchema: CompiledInputSchema): void;
+/**
+ * Build event definitions from compiled input schema commands.
+ *
+ * Each command becomes a `{Name}Command` event with:
+ * - `player_index` field (uint8) - identifies which player issued the command
+ * - One field per command argument, with vec2/vec3/quat flattened to x/y/z/w components
+ */
+export declare function buildCommandEvents(inputSchema: CompiledInputSchema): EventDef[];
+/**
+ * Inject command-derived events into a state schema.
+ * Mutates the schema in place.
+ *
+ * @throws Error if schema already contains an event with a conflicting name
+ */
+export declare function injectCommandEvents(schema: {
+    events?: EventDef[];
+}, inputSchema: CompiledInputSchema): void;
+/**
+ * Prepare a state schema for codegen by injecting Player component and command events.
+ * Returns a new schema object (does not mutate the original).
+ */
+export declare function prepareStateSchema(stateSchema: StateSchema, inputSchema: CompiledInputSchema): StateSchema;
+//# sourceMappingURL=inject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject.d.ts","sourceRoot":"","sources":["../../../src/codegen/inject.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,QAAQ,EAER,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAMnB;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,GAAG,YAAY,CAgDnF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE;IAAE,UAAU,EAAE,YAAY,EAAE,CAAA;CAAE,EACtC,WAAW,EAAE,mBAAmB,GAC/B,IAAI,CAWN;AAMD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ,EAAE,CAyD/E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE;IAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,EAC/B,WAAW,EAAE,mBAAmB,GAC/B,IAAI,CAsBN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,mBAAmB,GAC/B,WAAW,CAeb"}

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

@@ -0,0 +1,22 @@
+/**
+ * Rust code generator for state and input bindings.
+ *
+ * Generates Rust code from compiled schemas using template literals.
+ *
+ * @module codegen/rust
+ */
+import type { CompiledStateSchema, CompiledInputSchema } from '../schema';
+import type { Generator, GeneratorOptions } from './generator';
+/**
+ * Rust code generator.
+ * Generates Rust accessors for state and input schemas.
+ */
+export declare class RustGenerator implements Generator {
+    readonly language: "rust";
+    private opts;
+    constructor(opts?: GeneratorOptions);
+    generateState(schema: CompiledStateSchema): string;
+    generateInput(schema: CompiledInputSchema): string;
+    generateGame(state: CompiledStateSchema, input: CompiledInputSchema): string;
+}
+//# sourceMappingURL=rust.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../../src/codegen/rust.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EAKpB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAy5C/D;;;GAGG;AACH,qBAAa,aAAc,YAAW,SAAS;IAC7C,QAAQ,CAAC,QAAQ,EAAG,MAAM,CAAU;IACpC,OAAO,CAAC,IAAI,CAAmB;gBAEnB,IAAI,GAAE,gBAAqB;IAIvC,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM;IA2ClD,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM;IA2BlD,YAAY,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;CAe7E"}

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

@@ -0,0 +1,22 @@
+/**
+ * TypeScript code generator for state and input bindings.
+ *
+ * Generates TypeScript code from compiled schemas using template literals.
+ *
+ * @module codegen/typescript
+ */
+import type { CompiledStateSchema, CompiledInputSchema } from '../schema';
+import type { Generator, GeneratorOptions } from './generator';
+/**
+ * TypeScript code generator.
+ * Generates TypeScript accessors for state and input schemas.
+ */
+export declare class TypeScriptGenerator implements Generator {
+    readonly language: "typescript";
+    private opts;
+    constructor(opts?: GeneratorOptions);
+    generateState(schema: CompiledStateSchema): string;
+    generateInput(schema: CompiledInputSchema): string;
+    generateGame(state: CompiledStateSchema, input: CompiledInputSchema): string;
+}
+//# sourceMappingURL=typescript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/codegen/typescript.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EAMpB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAklD/D;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,SAAS;IACnD,QAAQ,CAAC,QAAQ,EAAG,YAAY,CAAU;IAC1C,OAAO,CAAC,IAAI,CAAmB;gBAEnB,IAAI,GAAE,gBAAqB;IAIvC,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM;IA0ClD,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM;IAyClD,YAAY,CAAC,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;CAG7E"}

package/dist/types/constants.d.ts

@@ -0,0 +1,5 @@
+/** Maximum ticks the predicted head can run ahead of sync head before stalling */
+export declare const ROLLBACK_WINDOW = 20;
+/** Range around current tick where inputs are valid (±10 ticks) */
+export declare const INPUT_VALIDITY_WINDOW = 10;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAGA,kFAAkF;AAClF,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,KAAK,CAAC"}

package/dist/types/crypto.d.ts

@@ -0,0 +1,141 @@
+import type { InputData } from './messages';
+export declare const SIGNATURE_SIZE = 65;
+export declare const COMPRESSED_PUBKEY_SIZE = 33;
+export declare const COMPRESSED_PUB_KEY_SIZE = 33;
+export declare const PRIVATE_KEY_SIZE = 32;
+export declare const HASH_SIZE = 32;
+export declare const INPUT_HEADER_SIZE = 5;
+export declare const GENESIS_HASH_SIZE = 16;
+/**
+ * Generate a new secp256k1 private key.
+ * @returns 32-byte private key
+ */
+export declare function generateKeyPair(): Uint8Array;
+/**
+ * Derive the compressed public key from a private key.
+ * @param privateKey 32-byte private key
+ * @returns 33-byte compressed public key
+ */
+export declare function pubKeyFromPrivate(privateKey: Uint8Array): Uint8Array;
+/**
+ * Sign a 32-byte message hash with a private key.
+ * Returns a 65-byte recoverable signature in format [r:32][s:32][v:1].
+ * @param privateKey 32-byte private key
+ * @param messageHash 32-byte message hash
+ * @returns 65-byte signature
+ */
+export declare function sign(privateKey: Uint8Array, messageHash: Uint8Array): Uint8Array;
+/**
+ * Recover the compressed public key from a message hash and signature.
+ * @param messageHash 32-byte message hash
+ * @param signature 65-byte signature in format [r:32][s:32][v:1]
+ * @returns 33-byte compressed public key
+ */
+export declare function recoverPubKey(messageHash: Uint8Array, signature: Uint8Array): Uint8Array;
+/**
+ * Verify that a signature was created by the owner of the given public key.
+ * @param pubKey 33-byte compressed public key
+ * @param messageHash 32-byte message hash
+ * @param signature 65-byte signature
+ * @returns true if valid
+ */
+export declare function verifySignature(pubKey: Uint8Array, messageHash: Uint8Array, signature: Uint8Array): boolean;
+/**
+ * Compute SHA-256 hash of arbitrary data.
+ * @param data Data to hash
+ * @returns 32-byte hash
+ */
+export declare function hashMessage(data: Uint8Array): Uint8Array;
+/**
+ * Compute a short truncated SHA256 hash used to shard sessions based on simulation/schema/input compatibility.
+ * Returns the first 8 bytes of SHA256(data).
+ * @param data Data to hash
+ * @returns 8-byte truncated hash
+ */
+export declare function sessionCompatibilityHash(data: Uint8Array): Uint8Array;
+/**
+ * Compute a truncated SHA256 hash of a JavaScript object using deterministic CBOR encoding.
+ * This ensures cross-platform compatibility - the same object will produce the same hash
+ * in both Go and JavaScript implementations.
+ *
+ * CBOR encoding rules (RFC 8949 §4.2 Core Deterministic Encoding):
+ * - Map keys sorted by byte string length, then lexicographically
+ * - Smallest possible integer encodings
+ * - No indefinite-length encodings
+ *
+ * @param obj JavaScript object to hash (must be CBOR-serializable)
+ * @returns 8-byte truncated hash
+ */
+export declare function hashContent(obj: unknown): Uint8Array;
+/**
+ * Compute the hash for signing an input message.
+ * Format: SHA256(genesisHash || targetTick || payload)
+ * @param genesisHash 16-byte genesis hash (from SessionConfig.toGenesisHash())
+ * @param targetTick Target tick number (uint32)
+ * @param payload Variable-length input payload (0-255 bytes)
+ * @returns 32-byte hash
+ */
+export declare function hashInputMessage(genesisHash: Uint8Array, targetTick: number, payload: Uint8Array): Uint8Array;
+/**
+ * Compute the hash for signing a tick message.
+ * Format: SHA256(genesisHash || tickNum || inputsHash || prevTickSig)
+ * @param genesisHash 16-byte genesis hash (from SessionConfig.toGenesisHash())
+ * @param tickNum Tick number (uint32)
+ * @param inputsHash 32-byte hash of concatenated inputs
+ * @param prevTickSig 65-byte previous tick's signature
+ * @returns 32-byte hash
+ */
+export declare function hashTickMessage(genesisHash: Uint8Array, tickNum: number, inputsHash: Uint8Array, prevTickSig: Uint8Array): Uint8Array;
+/**
+ * Compute a hash over all inputs in a tick.
+ * Format: SHA256(input1 || input2 || ... || inputN)
+ * where each input is: [targetTick:4][payloadLen:1][payload:0-255][signature:65]
+ * Returns zero hash if there are no inputs.
+ * @param inputs Array of input messages
+ * @returns 32-byte hash
+ */
+export declare function hashInputs(inputs: InputData[]): Uint8Array;
+/**
+ * Compute a hash over ordered payloads for stateId computation.
+ * Format: SHA256(payload1 || payload2 || ... || payloadN)
+ * Returns zero hash if there are no payloads.
+ *
+ * NOTE: This is distinct from hashInputs() which hashes full input messages
+ * (including signatures) for the tick signature chain. hashPayloads() hashes
+ * only the raw payloads in participant order, for state identity caching.
+ *
+ * @param payloads Array of payload bytes, ordered by participant index
+ * @returns 32-byte hash
+ */
+export declare function hashPayloads(payloads: Uint8Array[]): Uint8Array;
+/**
+ * Compute the hash for connection authentication.
+ * Format: SHA256("multitap:session:" || genesisHash || ":" || timestamp)
+ * @param genesisHash 16-byte genesis hash (from SessionConfig.toGenesisHash())
+ * @param timestampMs Timestamp in milliseconds
+ * @returns 32-byte hash
+ */
+export declare function hashAuthMessage(genesisHash: Uint8Array, timestampMs: number): Uint8Array;
+/**
+ * Encode a 16-byte genesis hash to base64url (no padding).
+ * A genesis hash is the deterministic session identity from SessionConfig.toGenesisHash().
+ * @param bytes 16-byte genesis hash
+ * @returns base64url string (22 chars)
+ */
+export declare function genesisHashToString(bytes: Uint8Array): string;
+/**
+ * Decode a base64url (no padding) string to a 16-byte genesis hash.
+ * Throws if the string is invalid or decodes to all zeros.
+ * @param str base64url string (22 chars)
+ * @returns 16-byte genesis hash
+ */
+export declare function genesisHashFromString(str: string): Uint8Array;
+/**
+ * Convert signature to hex string for URL encoding.
+ */
+export declare function signatureToHex(signature: Uint8Array): string;
+/**
+ * Parse hex string to signature bytes.
+ */
+export declare function hexToSignature(hex: string): Uint8Array;
+//# sourceMappingURL=crypto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/crypto.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,eAAe,IAAI,UAAU,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,GAAG,UAAU,CAehF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,UAAU,CAkBxF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO,CAO3G;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAGrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,CAIpD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,UAAU,CAc7G;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,UAAU,EACvB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,UAAU,GACtB,UAAU,CAiBZ;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,UAAU,CAkC1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,CAkC/D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAkBxF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAU7D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM,CAI5D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAMtD"}

package/dist/types/debug.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Debug logging utility for the multitap SDK.
+ *
+ * Wraps console.* methods with an enable/disable toggle.
+ * Disabled by default so library consumers don't see logs unless they opt-in.
+ *
+ * Usage:
+ *   import { debug } from './debug';
+ *   debug.warn('something happened');
+ *
+ * To enable logging (e.g., for debugging):
+ *   import { setDebugEnabled } from './debug';
+ *   setDebugEnabled(true);
+ */
+/** Enable or disable debug logging globally */
+export declare function setDebugEnabled(value: boolean): void;
+/** Check if debug logging is currently enabled */
+export declare function isDebugEnabled(): boolean;
+export declare const debug: {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    /** Returns a group function; if disabled, returns noop */
+    group: (label?: string) => void;
+    groupEnd: () => void;
+    /** Table output for structured data */
+    table: (data: unknown) => void;
+    /** Get the underlying console method (for advanced use) */
+    readonly raw: Console | {
+        log: () => void;
+        warn: () => void;
+        error: () => void;
+        info: () => void;
+        debug: () => void;
+    };
+};
+//# sourceMappingURL=debug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/debug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEpD;AAED,kDAAkD;AAClD,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAID,eAAO,MAAM,KAAK;mBACD,OAAO,EAAE,KAAG,IAAI;oBAGf,OAAO,EAAE,KAAG,IAAI;qBAGf,OAAO,EAAE,KAAG,IAAI;oBAGjB,OAAO,EAAE,KAAG,IAAI;qBAGf,OAAO,EAAE,KAAG,IAAI;IAGjC,0DAA0D;oBAC1C,MAAM,KAAG,IAAI;oBAGf,IAAI;IAGlB,uCAAuC;kBACzB,OAAO,KAAG,IAAI;IAG5B,2DAA2D;;;;;;;;CAI5D,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * Diagnostics client for e2e testing.
+ *
+ * Minimal browser client that:
+ * - Parses URL params (connectionURL, serverCertHash, relayPubKey)
+ * - Creates a Session with zero plugins (channel-only mode)
+ * - Generates random inputs on 50ms interval
+ * - Logs SYNC ticks to console for conformance testing
+ * - Exits when session duration elapses
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/types/e2e/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/e2e/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/e2e/cli.ts"],"names":[],"mappings":""}

package/dist/types/executor.d.ts

@@ -0,0 +1,130 @@
+/**
+ * WASM Executor - Manages state transition via WASM modules
+ *
+ * Supports multiple plugins executing serially on shared state.
+ *
+ * @module wasm-host
+ */
+import { type InputSchema } from './input-codec';
+import type { TickPrimitive } from './input-graph';
+import { type CompiledSchema, type StateBuffer } from './state';
+/**
+ * Batch transition execution interface.
+ *
+ * Takes input state and a batch of ticks, returns new state.
+ * Note: The function should NOT modify stateId - StateManager handles that.
+ */
+export interface BatchTransitionExecutor {
+    transition: (state: StateBuffer, ticks: TickPrimitive[]) => StateBuffer;
+    close: () => void;
+}
+export interface TransitionExports {
+    /** Per-tick transition function - mutates state in-place */
+    apply: (statePtr: number) => void;
+    /** WASM memory */
+    memory: WebAssembly.Memory;
+}
+/** Plugin definition for multi-plugin executor */
+export interface PluginDef {
+    name: string;
+    wasmBytes: Uint8Array;
+    /** Reserved bytes in shared WASM memory for this plugin's data section and stack */
+    reservedBytes: number;
+}
+export interface ExecutorOptions {
+    /** Be noisy in the console */
+    debug?: boolean | undefined;
+    /** The WASM module bytes (single plugin - deprecated, use plugins) */
+    moduleBytes?: Uint8Array;
+    /** Array of plugins in execution order */
+    plugins?: PluginDef[];
+    /** The state schema */
+    stateSchema: CompiledSchema;
+    /** The input schema */
+    inputSchema: InputSchema;
+    /** Maximum number of ticks per batch (for buffer sizing and yielding execution) */
+    maxTicksPerBatch: number;
+}
+export declare class Executor implements BatchTransitionExecutor {
+    private memory;
+    private plugins;
+    private options;
+    private stateSize;
+    private statePtr;
+    private heapPos;
+    private arenaResetMark;
+    private inputCodec;
+    private playerEntities;
+    constructor(options: ExecutorOptions);
+    /**
+     * Host-provided allocator for WASM modules.
+     * This enables shared memory across multiple plugins.
+     * Returns zeroed memory.
+     */
+    private hostAlloc;
+    /**
+     * Mark current heap position as the arena reset point.
+     * Called after init allocations (state buffers) but before game logic.
+     */
+    markArenaReset(): void;
+    /**
+     * Reset heap to the marked position, reclaiming temporary allocations.
+     * Called between tick batches.
+     */
+    resetArena(): void;
+    init(): Promise<Executor>;
+    /**
+     * Find an existing player entity by player index.
+     * Returns undefined if no entity exists for this player.
+     */
+    private findPlayerEntity;
+    /**
+     * Spawn a new player entity and set its Player.index field.
+     */
+    private spawnPlayerEntity;
+    /**
+     * Find or spawn a player entity for the given player index.
+     */
+    private findOrSpawnPlayerEntity;
+    /**
+     * Reset control fields in a Player component to zero/default.
+     * Called at tick start before writing new inputs.
+     * Skips controls with retain="always" (they persist until explicitly changed).
+     */
+    private resetPlayerControls;
+    /**
+     * Write decoded controls from an InputInstance to the Player component.
+     * Maps each control field to the corresponding Player component field.
+     *
+     * Note: vec2/vec3/quat controls are flattened to individual X/Y/Z/W fields
+     * by the Go codegen (e.g., "movement" becomes "movement_x", "movement_y").
+     */
+    private writeControlsToPlayer;
+    /**
+     * Push decoded commands to the generated command events.
+     * Each command becomes a {Name}Command event with playerIndex prepended.
+     */
+    private pushCommands;
+    /**
+     * Clear all command events at tick start.
+     */
+    private clearCommandEvents;
+    /**
+     * Decode all payloads for a tick and write to state.
+     * - Finds or spawns player entities
+     * - Writes controls to Player components
+     * - Pushes commands to command events
+     */
+    private decodePayloadsToState;
+    /**
+     * Execute state transition for a batch of ticks.
+     *
+     * @param state - Current state buffer
+     * @param ticks - Array of tick nodes to process
+     * @returns New state buffer after applying all ticks
+     */
+    transition(state: Uint8Array, ticks: TickPrimitive[]): Uint8Array;
+    close(): void;
+    getStateSize(): number;
+}
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/executor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAsC,KAAK,WAAW,EAAsB,MAAM,eAAe,CAAC;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,WAAW,EAWjB,MAAM,SAAS,CAAC;AAEjB;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,WAAW,CAAC;IACxE,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,kBAAkB;IAClB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;CAC5B;AAED,kDAAkD;AAClD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,UAAU,CAAC;IACtB,oFAAoF;IACpF,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,8BAA8B;IAC9B,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,sEAAsE;IACtE,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;IACtB,uBAAuB;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,uBAAuB;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,mFAAmF;IACnF,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAYD,qBAAa,QAAS,YAAW,uBAAuB;IACtD,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,OAAO,CAAkB;IAGjC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,QAAQ,CAAuB;IAGvC,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,cAAc,CAAa;IAGnC,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,cAAc,CAAqC;gBAE/C,OAAO,EAAE,eAAe;IAIpC;;;;OAIG;IACH,OAAO,CAAC,SAAS,CA2Bf;IAEF;;;OAGG;IACH,cAAc,IAAI,IAAI;IAItB;;;OAGG;IACH,UAAU,IAAI,IAAI;IAIZ,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC;IAyF/B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IA6C3B;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IA+C7B;;;OAGG;IACH,OAAO,CAAC,YAAY;IAuCpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IA+B7B;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,UAAU;IAuDjE,KAAK,IAAI,IAAI;IAKb,YAAY,IAAI,MAAM;CAOvB"}

package/dist/types/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/helpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAMlD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIpD"}

package/dist/types/input-codec.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Schema-driven input codec for variable-length game inputs.
+ *
+ * This module provides a TLV (type-length-value) encoding for game inputs that
+ * supports both real-time controls (buttons, axes) and discrete commands (RPC-style).
+ *
+ * Features:
+ * - Variable-length encoding: Only set fields are transmitted
+ * - Semantic hints: Controls declare meaning (momentary, toggle, axis) for prediction
+ * - Command support: RTS-style commands with typed arguments
+ * - Cross-language: Same wire format for TypeScript and Go
+ *
+ * See ADR-017: Input Encoding for specification details.
+ *
+ * @module input-codec
+ */
+import { type InputSchema, type ControlDef, type CommandDef, type CommandArgDef, type FlagType, type InputFieldType } from './schema';
+export type { InputSchema, ControlDef, CommandDef, CommandArgDef, FlagType, };
+export type { InputFieldType as FieldType };
+export type { PrimitiveType, CompoundType, ArrayType } from './schema';
+interface InternalCompiledField {
+    name: string;
+    type: string;
+    size: number;
+    offset: number;
+    options?: readonly string[] | undefined;
+    arrayLength?: number | undefined;
+    arrayElementType?: string | undefined;
+}
+interface InternalCompiledControl {
+    name: string;
+    index: number;
+    field: InternalCompiledField;
+    hint?: string | undefined;
+    retain: 'tick' | 'always';
+}
+interface InternalCompiledCommand {
+    name: string;
+    index: number;
+    args: InternalCompiledField[];
+    totalSize: number;
+}
+interface InternalCompiledInputSchema {
+    controls: InternalCompiledControl[];
+    commands: InternalCompiledCommand[];
+    controlByName: Map<string, InternalCompiledControl>;
+    commandByName: Map<string, InternalCompiledCommand>;
+}
+/** Decoded command with name and arguments */
+export interface DecodedCommand {
+    name: string;
+    [key: string]: unknown;
+}
+/** Input instance that can be encoded/decoded */
+export declare class InputInstance {
+    private schema;
+    private fields;
+    private commandList;
+    constructor(schema: InternalCompiledInputSchema);
+    /** Set a control value by name */
+    setControl(name: string, value: unknown): void;
+    /** Set a flags control from an object of boolean options */
+    setFlags(name: string, flags: Record<string, boolean>): void;
+    /** Set a vec2 control (f32 components) */
+    setVec2(name: string, value: [number, number]): void;
+    /** Set a vec3 control (f32 components) */
+    setVec3(name: string, value: [number, number, number]): void;
+    /** Set a quat control (f32 components: x, y, z, w) */
+    setQuat(name: string, value: [number, number, number, number]): void;
+    /** Get a control value by name */
+    getControl(name: string): unknown;
+    /** Get a flags control as an object of boolean options */
+    getFlags(name: string): Record<string, boolean>;
+    /** Get a vec2 control (f32 components) */
+    getVec2(name: string): [number, number];
+    /** Get a vec3 control (f32 components) */
+    getVec3(name: string): [number, number, number];
+    /** Get a quat control (f32 components: x, y, z, w) */
+    getQuat(name: string): [number, number, number, number];
+    /** Check if a control is set */
+    hasControl(name: string): boolean;
+    /** Add a command */
+    addCommand(name: string, args: Record<string, unknown>): void;
+    /** Get all commands */
+    getCommands(): DecodedCommand[];
+    /** Encode to TLV wire format */
+    encode(): Uint8Array;
+    /** Decode from TLV wire format */
+    static decode(schema: InternalCompiledInputSchema, bytes: Uint8Array): InputInstance;
+    /** Clear all set controls and commands */
+    clear(): void;
+    private encodeValue;
+    private decodeValue;
+    private getDefaultValue;
+}
+/** Compiled input codec with create/decode methods */
+export interface InputCodec {
+    /** Create a new empty input instance */
+    create(): InputInstance;
+    /** Decode bytes to an input instance */
+    decode(bytes: Uint8Array): InputInstance;
+    /** Get the compiled schema (internal format) */
+    readonly schema: InternalCompiledInputSchema;
+}
+/**
+ * Compile an input schema into a codec.
+ *
+ * @example
+ * ```typescript
+ * const codec = compileInputCodec({
+ *   controls: [
+ *     { name: "buttons", type: "flags8", options: ["w", "a", "s", "d", "jump", "fire"], hint: "momentary" },
+ *     { name: "aim", type: "vec2", hint: "axis" },
+ *   ],
+ *   commands: [
+ *     { name: "move", args: [{ name: "unitId", type: "uint16" }, { name: "pos", type: "vec2" }] },
+ *   ],
+ * });
+ *
+ * const input = codec.create();
+ * input.setFlags("buttons", { w: true, jump: true });
+ * input.setVec2("aim", [0.5, -0.25]);  // native f32 floats
+ * input.addCommand("move", { unitId: 12, pos: [100.0, 200.0] });
+ *
+ * const bytes = input.encode();
+ * const decoded = codec.decode(bytes);
+ * ```
+ *
+ * Also works with JSON-imported schemas:
+ * ```typescript
+ * import config from './game.config.json';
+ * const codec = compileInputCodec(config.input);
+ * ```
+ */
+export declare function compileInputCodec(schema: InputSchema): InputCodec;
+//# sourceMappingURL=input-codec.d.ts.map

package/dist/types/input-codec.d.ts.map

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