murow 0.0.70 → 0.0.71

package/dist/net/types.js

@@ -1,31 +0,0 @@
-/**
- * Core networking types for transport-agnostic multiplayer game networking
- */
-/**
- * Message type identifiers for protocol discrimination
- */
-export var MessageType;
-(function (MessageType) {
-    /** Client -> Server: Intent/command */
-    MessageType[MessageType["INTENT"] = 1] = "INTENT";
-    /** Server -> Client: State snapshot */
-    MessageType[MessageType["SNAPSHOT"] = 2] = "SNAPSHOT";
-    /** Bidirectional: Heartbeat/ping */
-    MessageType[MessageType["HEARTBEAT"] = 3] = "HEARTBEAT";
-    /** Bidirectional: Custom application message */
-    MessageType[MessageType["CUSTOM"] = 255] = "CUSTOM";
-})(MessageType || (MessageType = {}));
-/**
- * Message priority levels for send queue
- */
-export var MessagePriority;
-(function (MessagePriority) {
-    /** Lowest priority - can be dropped if queue is full (e.g., chat) */
-    MessagePriority[MessagePriority["LOW"] = 0] = "LOW";
-    /** Normal priority - most game messages (e.g., movement) */
-    MessagePriority[MessagePriority["NORMAL"] = 1] = "NORMAL";
-    /** High priority - important events (e.g., damage, scoring) */
-    MessagePriority[MessagePriority["HIGH"] = 2] = "HIGH";
-    /** Critical priority - never drop (e.g., connection control) */
-    MessagePriority[MessagePriority["CRITICAL"] = 3] = "CRITICAL";
-})(MessagePriority || (MessagePriority = {}));

package/dist/net/validators.js

@@ -1,88 +0,0 @@
-/**
- * Common intent validation helpers
- */
-/**
- * Validate that intent tick is not in the past (with tolerance for network lag)
- *
- * NOTE: Pass the current tick value at the time you create the validator.
- * If your tick advances, you'll need to recreate the validator or use a function
- * that captures the current tick dynamically.
- *
- * @param currentTick Current server tick
- * @param tolerance Number of ticks to allow in the past (default: 10)
- *
- * @example
- * ```ts
- * // Option 1: Recreate validator each tick (simple but allocates)
- * function onTick(currentTick: number) {
- *   const validator = validateTickNotTooOld(currentTick);
- *   // use validator...
- * }
- *
- * // Option 2: Manual validation (zero allocation)
- * if (intent.tick >= currentTick - 10) {
- *   // intent is valid
- * }
- * ```
- */
-export function validateTickNotTooOld(currentTick, tolerance = 10) {
-    return (_peerId, intent) => {
-        return intent.tick >= currentTick - tolerance;
-    };
-}
-/**
- * Validate that intent tick is not too far in the future
- * @param currentTick Current server tick
- * @param tolerance Number of ticks to allow in the future (default: 5)
- */
-export function validateTickNotTooFuture(currentTick, tolerance = 5) {
-    return (_peerId, intent) => {
-        return intent.tick <= currentTick + tolerance;
-    };
-}
-/**
- * Validate intent tick is within acceptable range
- * @param currentTick Current server tick
- * @param pastTolerance Ticks allowed in past (default: 10)
- * @param futureTolerance Ticks allowed in future (default: 5)
- */
-export function validateTickRange(currentTick, pastTolerance = 10, futureTolerance = 5) {
-    return (_peerId, intent) => {
-        return (intent.tick >= currentTick - pastTolerance &&
-            intent.tick <= currentTick + futureTolerance);
-    };
-}
-/**
- * Combine multiple validators with AND logic
- */
-export function combineValidators(...validators) {
-    return (peerId, intent) => {
-        for (const validator of validators) {
-            if (!validator(peerId, intent)) {
-                return false;
-            }
-        }
-        return true;
-    };
-}
-/**
- * Validate that a numeric field is within a range
- */
-export function validateRange(field, min, max) {
-    return (_peerId, intent) => {
-        const value = intent[field];
-        if (typeof value !== "number") {
-            return false;
-        }
-        return value >= min && value <= max;
-    };
-}
-/**
- * Validate that a field exists and is of expected type
- */
-export function validateFieldType(field, expectedType) {
-    return (_peerId, intent) => {
-        const value = intent[field];
-        return typeof value === expectedType;
-    };
-}

package/dist/protocol/index.js

@@ -1,92 +0,0 @@
-/**
- * Protocol Layer - Type-safe networking primitives
- *
- * This layer enforces:
- * - Type-safe intent definitions (use defineIntent helper)
- * - Type-safe snapshot definitions (Snapshot<YourState>)
- * - Memory-efficient encoding (use BinaryCodec from core)
- *
- * You provide:
- * - Your intent types (via defineIntent)
- * - Your state types
- * - Your schemas (for binary encoding)
- *
- * @example Using defineIntent with enums (recommended)
- * ```ts
- * import { defineIntent, IntentRegistry } from './protocol';
- * import { BinaryCodec } from './core/binary-codec';
- *
- * // Define all your intent kinds in one place
- * enum IntentKind {
- *   Move = 1,
- *   Attack = 2,
- *   Jump = 3,
- * }
- *
- * // Define intents with automatic type inference
- * // kind and tick are added automatically!
- * const MoveIntent = defineIntent({
- *   kind: IntentKind.Move,
- *   schema: {
- *     dx: BinaryCodec.f32,
- *     dy: BinaryCodec.f32,
- *   }
- * });
- *
- * const AttackIntent = defineIntent({
- *   kind: IntentKind.Attack,
- *   schema: {
- *     targetId: BinaryCodec.u32,
- *     damage: BinaryCodec.f32,
- *   }
- * });
- *
- * type MoveIntent = typeof MoveIntent.type;
- * type AttackIntent = typeof AttackIntent.type;
- *
- * // Register and use
- * const intentRegistry = new IntentRegistry();
- * intentRegistry.register(MoveIntent.kind, MoveIntent.codec);
- * intentRegistry.register(AttackIntent.kind, AttackIntent.codec);
- *
- * const move: MoveIntent = {
- *   kind: IntentKind.Move,
- *   tick: 100, // tick is automatically available
- *   dx: 1.5,
- *   dy: -2.0,
- * };
- *
- * const buf = intentRegistry.encode(move);
- * const decoded = intentRegistry.decode(IntentKind.Move, buf);
- * ```
- *
- * @example Manual definition (legacy)
- * ```ts
- * // Define your types
- * interface MoveIntent extends Intent {
- *   kind: 1;
- *   tick: number;
- *   dx: number;
- *   dy: number;
- * }
- *
- * interface GameState {
- *   players: Record<number, { x: number; y: number }>;
- * }
- *
- * // Create codecs once (reuse these!)
- * const intentRegistry = new IntentRegistry();
- * intentRegistry.register(1, new PooledCodec(moveSchema));
- *
- * const snapshotCodec = new SnapshotCodec<GameState>(
- *   new PooledCodec(stateSchema)
- * );
- *
- * // Use them
- * const buf = intentRegistry.encode(intent);
- * const snapshot = snapshotCodec.decode(buf);
- * ```
- */
-export * from "./intent";
-export * from "./snapshot";
-export * from "./rpc";

package/dist/protocol/intent/define-intent.js

@@ -1,125 +0,0 @@
-import { BinaryCodec } from "../../core/binary-codec";
-/**
- * Simple codec implementation that uses BinaryCodec for encoding/decoding.
- * @template T The intent type
- */
-class IntentCodec {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    encode(value) {
-        return BinaryCodec.encode(this.schema, value);
-    }
-    decode(buf) {
-        // Create a target object with nil values
-        const target = {};
-        for (const key of Object.keys(this.schema)) {
-            const field = this.schema[key];
-            target[key] = field.toNil();
-        }
-        return BinaryCodec.decode(this.schema, buf, target);
-    }
-}
-/**
- * Define a type-safe intent with automatic schema generation.
- *
- * This helper ensures that your intent's TypeScript interface and binary schema
- * stay in sync by deriving the type from the schema definition.
- *
- * The `kind` and `tick` fields are automatically added to the schema:
- * - `kind`: u8 codec (always FIRST byte - required for IntentRegistry.decode)
- * - `tick`: u32 codec (default, can be overridden by including it in your schema)
- *
- * IMPORTANT: If you use PooledCodec directly instead of defineIntent(), you MUST
- * ensure `kind: BinaryPrimitives.u8` is the FIRST field in your schema, or
- * IntentRegistry.decode() will fail.
- *
- * @template K The intent kind (numeric literal)
- * @template S The schema type
- * @param definition Intent configuration with kind and schema
- * @returns A DefinedIntent object with type, codec, and kind
- *
- * @example Using enums (recommended for managing multiple intents)
- * ```ts
- * // Define all your intent kinds in one place
- * enum IntentKind {
- *   Move = 1,
- *   Attack = 2,
- *   Jump = 3,
- *   Chat = 4,
- * }
- *
- * const MoveIntent = defineIntent({
- *   kind: IntentKind.Move,
- *   schema: {
- *     dx: BinaryCodec.f32,
- *     dy: BinaryCodec.f32,
- *   }
- * });
- *
- * const AttackIntent = defineIntent({
- *   kind: IntentKind.Attack,
- *   schema: {
- *     targetId: BinaryCodec.u32,
- *     damage: BinaryCodec.f32,
- *   }
- * });
- *
- * // Use the inferred types
- * type MoveIntent = typeof MoveIntent.type;
- * type AttackIntent = typeof AttackIntent.type;
- *
- * // Register with IntentRegistry
- * const registry = new IntentRegistry();
- * registry.register(MoveIntent.kind, MoveIntent.codec);
- * registry.register(AttackIntent.kind, AttackIntent.codec);
- *
- * // Create instances - tick is automatically available
- * const move: MoveIntent = {
- *   kind: IntentKind.Move,
- *   tick: 100,
- *   dx: 1.5,
- *   dy: -2.0,
- * };
- * ```
- *
- * @example Using literal types (simple cases)
- * ```ts
- * const MoveIntent = defineIntent({
- *   kind: 1 as const,
- *   schema: {
- *     dx: BinaryCodec.f32,
- *     dy: BinaryCodec.f32,
- *   }
- * });
- *
- * type MoveIntent = typeof MoveIntent.type;
- * ```
- *
- * @example Custom tick encoding
- * ```ts
- * const SmallIntent = defineIntent({
- *   kind: IntentKind.Small,
- *   schema: {
- *     tick: BinaryCodec.u16, // Override default u32 with u16
- *     action: BinaryCodec.u8,
- *   }
- * });
- * ```
- */
-export function defineIntent(definition) {
-    // Create the full schema with kind and tick fields
-    // Add tick with default u32 if not provided by user
-    const fullSchema = {
-        kind: BinaryCodec.u8,
-        tick: BinaryCodec.u32, // Default tick encoding
-        ...definition.schema, // User can override tick if needed
-    };
-    // Create the codec using BinaryCodec directly
-    const codec = new IntentCodec(fullSchema);
-    return {
-        type: undefined, // Phantom type for inference
-        codec,
-        kind: definition.kind,
-    };
-}

package/dist/protocol/intent/index.js

@@ -1,91 +0,0 @@
-/**
- * Intent system for client-to-server actions.
- *
- * Intents are player/AI actions that need to be:
- * 1. Encoded efficiently (binary)
- * 2. Sent over network
- * 3. Decoded on the other end
- * 4. Processed deterministically
- *
- * @example Using defineIntent with enums (recommended)
- * ```ts
- * import { defineIntent, IntentRegistry } from './protocol/intent';
- * import { BinaryCodec } from '../core/binary-codec';
- *
- * // 1. Define all your intent kinds in one place
- * enum IntentKind {
- *   Move = 1,
- *   Attack = 2,
- *   Jump = 3,
- * }
- *
- * // 2. Define your intents with automatic type inference
- * // kind and tick are added automatically!
- * const MoveIntent = defineIntent({
- *   kind: IntentKind.Move,
- *   schema: {
- *     dx: BinaryCodec.f32,
- *     dy: BinaryCodec.f32,
- *   }
- * });
- *
- * const AttackIntent = defineIntent({
- *   kind: IntentKind.Attack,
- *   schema: {
- *     targetId: BinaryCodec.u32,
- *     damage: BinaryCodec.f32,
- *   }
- * });
- *
- * // 3. Extract the types
- * type MoveIntent = typeof MoveIntent.type;
- * type AttackIntent = typeof AttackIntent.type;
- *
- * // 4. Create registry and register
- * const registry = new IntentRegistry();
- * registry.register(MoveIntent.kind, MoveIntent.codec);
- * registry.register(AttackIntent.kind, AttackIntent.codec);
- *
- * // 5. Create instances with full type safety
- * const move: MoveIntent = {
- *   kind: IntentKind.Move,
- *   tick: 100, // tick is automatically available
- *   dx: 1.5,
- *   dy: -2.0,
- * };
- *
- * // 6. Encode/decode
- * const buf = registry.encode(move);
- * const decoded = registry.decode(buf);
- * ```
- *
- * @example Manual definition (legacy)
- * ```ts
- * import { Intent, IntentRegistry } from './protocol/intent';
- * import { PooledCodec } from '../core/pooled-codec';
- * import { BinaryCodec } from '../core/binary-codec';
- *
- * // 1. Define your intent type
- * interface MoveIntent extends Intent {
- *   kind: 1;
- *   tick: number;
- *   dx: number;
- *   dy: number;
- * }
- *
- * // 2. Create registry and register once (reuse this instance)
- * const registry = new IntentRegistry();
- * registry.register(1, new PooledCodec({
- *   kind: BinaryCodec.u8,
- *   tick: BinaryCodec.u32,
- *   dx: BinaryCodec.f32,
- *   dy: BinaryCodec.f32,
- * }));
- *
- * // 3. Encode/decode
- * const buf = registry.encode(intent);
- * const decoded = registry.decode(buf);
- * ```
- */
-export { IntentRegistry } from "./intent-registry";
-export { defineIntent } from "./define-intent";

package/dist/protocol/intent/intent-registry.js

@@ -1,91 +0,0 @@
-/**
- * Registry for mapping intent kinds to their codecs.
- *
- * Users instantiate this once and register their intent types with
- * PooledCodec instances (from core/pooled-codec).
- *
- * @example
- * ```ts
- * import { IntentRegistry } from './protocol/intent';
- * import { PooledCodec } from './core/pooled-codec';
- * import { BinaryCodec } from './core/binary-codec';
- *
- * const registry = new IntentRegistry();
- *
- * registry.register(1, new PooledCodec({
- *   kind: BinaryCodec.u8,
- *   tick: BinaryCodec.u32,
- *   dx: BinaryCodec.f32,
- *   dy: BinaryCodec.f32,
- * }));
- *
- * // Encode/decode
- * const buf = registry.encode(intent);
- * const decoded = registry.decode(buf);
- * ```
- */
-export class IntentRegistry {
-    constructor() {
-        this.codecs = new Map();
-    }
-    /**
-     * Register a codec for a specific intent kind.
-     * Call this once per intent type at startup.
-     */
-    register(intent) {
-        if (this.codecs.has(intent.kind)) {
-            throw new Error(`Intent kind ${intent.kind} is already registered`);
-        }
-        this.codecs.set(intent.kind, intent.codec);
-    }
-    /**
-     * Encode an intent into binary format.
-     */
-    encode(intent) {
-        const codec = this.codecs.get(intent.kind);
-        if (!codec) {
-            throw new Error(`No codec registered for intent kind ${intent.kind}`);
-        }
-        return codec.encode(intent);
-    }
-    /**
-     * Decode binary data into an intent.
-     * Extracts the kind from the first byte of the buffer.
-     */
-    decode(buf) {
-        if (buf.byteLength === 0) {
-            throw new Error('Cannot decode empty buffer');
-        }
-        // Extract kind from first byte (all intent codecs must encode kind as u8 in first byte)
-        const kind = buf[0];
-        const codec = this.codecs.get(kind);
-        if (!codec) {
-            throw new Error(`No codec registered for intent kind ${kind}`);
-        }
-        return codec.decode(buf);
-    }
-    /**
-     * Decode binary data into an intent when kind is already known.
-     * Useful for testing or when kind is transmitted separately.
-     * @deprecated Use decode(buf) instead for standard intent decoding
-     */
-    decodeWithKnownKind(kind, buf) {
-        const codec = this.codecs.get(kind);
-        if (!codec) {
-            throw new Error(`No codec registered for intent kind ${kind}`);
-        }
-        return codec.decode(buf);
-    }
-    has(kind) {
-        return this.codecs.has(kind);
-    }
-    unregister(kind) {
-        return this.codecs.delete(kind);
-    }
-    clear() {
-        this.codecs.clear();
-    }
-    getKinds() {
-        return Array.from(this.codecs.keys());
-    }
-}

package/dist/protocol/rpc/define-rpc.js

@@ -1,84 +0,0 @@
-import { BinaryCodec } from "../../core/binary-codec";
-/**
- * Simple codec implementation that uses BinaryCodec for encoding/decoding.
- * @template T The RPC data type
- */
-class RpcCodecImpl {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    encode(value) {
-        return BinaryCodec.encode(this.schema, value);
-    }
-    decode(buf) {
-        // Create a target object with nil values
-        const target = {};
-        for (const key of Object.keys(this.schema)) {
-            const field = this.schema[key];
-            target[key] = field.toNil();
-        }
-        return BinaryCodec.decode(this.schema, buf, target);
-    }
-}
-/**
- * Define a type-safe RPC with automatic schema generation.
- *
- * RPCs are bidirectional one-off events/commands for:
- * - Meta-game events (achievements, notifications)
- * - Match lifecycle (countdown, results)
- * - Request/response patterns
- * - System announcements
- *
- * NOT for game state synchronization (use Snapshots) or player inputs (use Intents)
- *
- * @template S The schema type
- * @param definition RPC configuration with method and schema
- * @returns A DefinedRpc object with method and codec
- *
- * @example Server → Client RPC
- * ```ts
- * const MatchCountdown = defineRPC({
- *   method: 'matchCountdown',
- *   schema: {
- *     secondsRemaining: BinaryCodec.u8,
- *   }
- * });
- *
- * // Server sends
- * server.sendRpcBroadcast(MatchCountdown, { secondsRemaining: 10 });
- *
- * // Client receives
- * client.onRpc(MatchCountdown, (rpc) => {
- *   console.log(`Match starting in ${rpc.secondsRemaining}s`);
- * });
- * ```
- *
- * @example Client → Server RPC
- * ```ts
- * const BuyItem = defineRPC({
- *   method: 'buyItem',
- *   schema: {
- *     itemId: BinaryCodec.string(32),
- *   }
- * });
- *
- * // Client sends
- * client.sendRpc(BuyItem, { itemId: 'long_sword' });
- *
- * // Server receives
- * server.onRpc(BuyItem, (peerId, rpc) => {
- *   console.log(`${peerId} wants to buy ${rpc.itemId}`);
- * });
- * ```
- */
-export function defineRPC(definition) {
-    // Create the schema from definition
-    const schema = definition.schema;
-    // Create the codec using BinaryCodec
-    const codec = new RpcCodecImpl(schema);
-    return {
-        method: definition.method,
-        codec,
-        type: undefined, // Phantom type for inference
-    };
-}

package/dist/protocol/rpc/index.js

@@ -1,3 +0,0 @@
-export * from './rpc';
-export * from './define-rpc';
-export * from './rpc-registry';