murow 0.0.73 → 0.1.3

package/dist/netcode/types/client/game-client.d.ts

@@ -0,0 +1,139 @@
+import type { Entity, World } from 'murow/ecs';
+import type { GameLoop } from 'murow/game';
+import type { TransportAdapter } from 'murow/net';
+import { Network } from '../network/base';
+import { SnapshotInterpolation } from './strategies/snapshot-interpolation';
+import type { DefinedIntents, IntentPayload, IntentSchemaMap } from '../intents/define-intents';
+import type { DefinedRpcs, RpcPayload, RpcSchemaMap } from '../rpcs/define-rpcs';
+import type { DefinedPredictions } from '../predictions/define-predictions';
+/**
+ * Snapshot interpolation strategy. The client holds the last few
+ * snapshots and renders peer entities `delay` ms behind newest, lerping
+ * between the two snapshots straddling that past time. This is the
+ * Source-engine model and the right default for action games, MMOs,
+ * MOBAs, and `.io` titles.
+ */
+export interface SnapshotInterpolationStrategy {
+    kind: 'snapshot-interpolation';
+    /** Snapshot interpolation delay, ms. Default 100. */
+    delay?: number;
+    /**
+     * Max ms between snapshots before history is dropped as stale.
+     * Defaults to `delay * 2 + 100`.
+     */
+    staleWindow?: number;
+    /**
+     * Desync past which the play-out clock snaps instead of warping, ms.
+     * Scaled by tick rate internally. Default 500.
+     */
+    maxDesync?: number;
+    /**
+     * Largest data gap a peer may have before its value is held instead of
+     * interpolated across, ms. Smaller gaps are bridged. Default 250.
+     */
+    maxBridgeGap?: number;
+}
+/**
+ * How peer entities are rendered on the client. Local-player rendering
+ * is driven by `prediction` (separate axis) and is independent of the
+ * peer strategy.
+ *
+ * Today only `snapshot-interpolation` ships. Extrapolation and rollback
+ * variants will slot in here without protocol changes.
+ */
+export type PeerRenderStrategy = SnapshotInterpolationStrategy;
+export interface GameClientOptions<I extends IntentSchemaMap, R extends RpcSchemaMap> {
+    world: World;
+    loop: GameLoop<any>;
+    transport: TransportAdapter;
+    protocol: {
+        intents: DefinedIntents<I>;
+        rpcs: DefinedRpcs<R>;
+    };
+    /**
+     * Peer-rendering strategy. Defaults to snapshot interpolation with
+     * a 100 ms delay.
+     */
+    strategy?: PeerRenderStrategy;
+    prediction?: {
+        /** Max buffered unacked predictions kept for rollback. Default 64. */
+        bufferSize?: number;
+    };
+    now?: () => number;
+}
+export declare class GameClient<I extends IntentSchemaMap = IntentSchemaMap, R extends RpcSchemaMap = RpcSchemaMap> extends Network<'client', R> {
+    readonly world: World;
+    readonly loop: GameLoop<any>;
+    readonly transport: TransportAdapter;
+    readonly intents: DefinedIntents<I>;
+    readonly rpcs: DefinedRpcs<R>;
+    private predictionMap;
+    private predictionBufferSize;
+    private reconciler;
+    private localTick;
+    private intentSequence;
+    private lastServerTick;
+    private lastReconciledServerTick;
+    private serverToLocal;
+    private syncedComponents;
+    private syncedNumMaskWords;
+    private rng;
+    private lastDt;
+    private predictedEntities;
+    /** Set when MSG_ASSIGN_ENTITY lands before the matching spawn. */
+    private pendingAssignedServerEid;
+    /** Spawns discovered during a decode, emitted once values are written. */
+    private deferredSpawns;
+    /** Resolved local entity for the server's assignment. Default for sendIntent. */
+    private _assignedEntity;
+    interpBuffer: SnapshotInterpolation;
+    private _rttMs;
+    private now;
+    /**
+     * Local entity the server has assigned to this peer, or `null` if no
+     * assignment has been received yet. `sendIntent` is a no-op (emits an
+     * `'error'` event) until this is set.
+     */
+    get assignedEntity(): Entity | null;
+    /**
+     * Last measured round-trip time in milliseconds, or `null` if no pong
+     * has come back yet. Updated whenever a `'pong'` event fires.
+     */
+    get rttMs(): number | null;
+    constructor(opts: GameClientOptions<I, R>);
+    private discoverSyncedComponents;
+    private wireTransport;
+    private wireLoop;
+    private handleIncoming;
+    private handleSnapshot;
+    private ensureEntity;
+    private applyAssignment;
+    /**
+     * Rewind predicted entities to authoritative state, drop predictions
+     * the server has acked, replay the rest on top.
+     */
+    private reconcile;
+    private handleRpc;
+    use(bundle: DefinedPredictions<I>): this;
+    /**
+     * Send an intent to the server. `ctx.entity` in the prediction is the
+     * server-assigned entity. Target entities (chestId, targetId, etc.)
+     * belong in the payload itself.
+     *
+     * Returns `true` when the intent was sent, `false` when blocked. Both
+     * blocked paths emit an `'error'` event so calling code can react:
+     * - Unknown intent name.
+     * - No entity assigned yet (server hasn't called `assignEntity` for
+     *   this peer). Check `client.assignedEntity` if you want to know
+     *   without sending.
+     */
+    sendIntent<K extends keyof I & string>(name: K, payload: IntentPayload<I, K>): boolean;
+    sendRpc<K extends keyof R & string>(name: K, payload: RpcPayload<R, K>): void;
+    ping(): void;
+    getLocalTick(): number;
+    getPredictionDepth(): number;
+    get interpolationDelay(): number;
+    setInterpolationDelay(ms: number): void;
+    setMaxDesync(ms: number): void;
+    setMaxBridgeGap(ms: number): void;
+}

package/dist/netcode/types/client/index.d.ts

@@ -0,0 +1 @@
+export * from './game-client';

package/dist/netcode/types/client/strategies/snapshot-interpolation.d.ts

@@ -0,0 +1,33 @@
+import type { Component, Entity, World } from 'murow/ecs';
+export interface BufferedSnapshot {
+    receivedAt: number;
+    serverTick: number;
+    entityIds: number[];
+    componentValuesByEntity: Map<number, Map<Component<any>, Record<string, number>>>;
+}
+/**
+ * Snapshot-interpolation strategy: renders peer entities `delay` ms behind the
+ * newest snapshot, lerping between the two snapshots straddling that past time.
+ * Composes a core `Timeline` (snapshot history) and a core `SlewClock`
+ * (play-out clock). Predicted entities are skipped; reconciliation drives them.
+ */
+export declare class SnapshotInterpolation {
+    private serverToLocal;
+    private timeline;
+    private clock;
+    private smoothedTickRateMs;
+    private nominalTickMs;
+    delay: number;
+    maxDesync: number;
+    maxBridgeGap: number;
+    constructor(serverToLocal: Map<number, Entity>, capacity: number, delayMs: number, staleWindowMs: number, maxDesyncMs?: number, nominalTickMs?: number, maxBridgeGapMs?: number);
+    get staleWindow(): number;
+    setDelay(delayMs: number): void;
+    setStaleWindow(staleWindowMs: number): void;
+    setMaxDesync(maxDesyncMs: number): void;
+    setMaxBridgeGap(maxBridgeGapMs: number): void;
+    record(snapshot: BufferedSnapshot): void;
+    clear(): void;
+    apply(world: World, now: number, components: Component<any>[], shouldSkip: (entity: Entity) => boolean): void;
+    private writeSnapshot;
+}

package/dist/netcode/types/client/strategies/snapshot-interpolation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/codec/delta-codec.d.ts

@@ -0,0 +1,17 @@
+import type { Component, World } from 'murow/ecs';
+export declare function encodeDelta(world: World, tick: number, entities: number[], components: Component<any>[], numMaskWords: number, despawned?: number[], clientAckTick?: number, includeComponent?: (entity: number, component: Component<any>) => boolean): Uint8Array;
+export interface DecodedDelta {
+    tick: number;
+    clientAckTick: number;
+    entityIds: number[];
+    serverEntityIds: number[];
+    despawnedServerIds: number[];
+    valuesByServerEntity: Map<number, Map<Component<any>, Record<string, any>>>;
+}
+export declare function decodeDelta(world: World, buf: Uint8Array, components: Component<any>[], numMaskWords: number, ensureEntity: (serverEntityId: number, presentComponents: Component<any>[]) => number, 
+/**
+ * Return false to skip overwriting this entity's component values.
+ * Components missing on the entity are still archetype-initialized
+ * either way so the local entity has the right shape.
+ */
+shouldApply?: (localEntity: number) => boolean): DecodedDelta;

package/dist/netcode/types/codec/delta-codec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/codec/index.d.ts

@@ -0,0 +1 @@
+export * from './delta-codec';

package/dist/netcode/types/components/index.d.ts

@@ -0,0 +1 @@
+export * from './sync-spec';

package/dist/netcode/types/components/sync-spec.d.ts

@@ -0,0 +1,49 @@
+/**
+ * - `lerp`  linear (positions, scalars)
+ * - `slerp` spherical (quaternions)
+ * - `step`  hold older value until t >= 0.5, then snap (enums, ids)
+ * - `none`  always newest (strings, references)
+ */
+export type InterpolationMode = 'lerp' | 'slerp' | 'step' | 'none';
+/**
+ * - `every-tick`  shipped every snapshot tick
+ * - `on-change`   shipped only when a field changed
+ * - `{ every: N }` every N ticks regardless
+ */
+export type SyncRate = 'every-tick' | 'on-change' | {
+    every: number;
+};
+/** `'global'` or a plugin name (e.g. an `AoiGrid` instance's `name`). */
+export type InterestRule = 'global' | (string & {});
+export interface SyncSpec {
+    /** Snapshot eligibility cadence. */
+    rate: SyncRate;
+    /** Visibility filter (e.g. AOI plugin name) or `'global'`. */
+    interest: InterestRule;
+    /** Default interpolation mode for this component's fields. */
+    interp?: InterpolationMode;
+    /** Override the reconciliation snap threshold for this component. */
+    snapThreshold?: number;
+}
+/**
+ * Identity helper that gives full TypeScript checking on the `sync` block
+ * of a `defineComponent` call. Plain object literals also work, but the
+ * function call site catches typos (`'evry-tick'`, `interest: 42`) at
+ * compile time and provides autocomplete on the union members.
+ *
+ * @example
+ * import { defineComponent, f32 } from 'murow';
+ * import { networked } from 'murow/netcode';
+ *
+ * const Position = defineComponent('Position', {
+ *   schema: { x: f32, y: f32 },
+ *   sync: networked({ rate: 'every-tick', interest: 'aoi', interp: 'lerp' }),
+ * });
+ */
+export declare function networked(spec: SyncSpec): SyncSpec;
+/**
+ * Whether a component's value rides along in the snapshot for the given
+ * tick. `every-tick` always; `on-change` only when the field changed
+ * since the last snapshot; `{ every: N }` on every Nth tick or on change.
+ */
+export declare function rateIncludes(rate: SyncRate, dirty: boolean, tick: number): boolean;

package/dist/netcode/types/components/sync-spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/ctx.d.ts

@@ -0,0 +1,105 @@
+import type { Component, Entity, World } from 'murow/ecs';
+import type { SimpleRNG } from 'murow/core/simple-rng';
+/**
+ * Per-component typed-array bundle returned by `ctx.fields(C)`. Maps every
+ * field name in the component's schema to its underlying typed array.
+ */
+export type ComponentFields<T extends object> = Readonly<Record<keyof T & string, Float32Array | Int32Array | Uint32Array | Uint16Array | Uint8Array>>;
+export interface PredictionContext {
+    world: World;
+    entity: Entity;
+    tick: number;
+    /** Seconds since last tick. */
+    deltaTime: number;
+    /** Deterministic per-tick RNG. Don't use Math.random in predictions. */
+    rng: SimpleRNG;
+    /**
+     * Get raw typed-array access to a component's fields for `ctx.entity`.
+     *
+     * Same shared bundle as `world.fields(C)`, plus automatic dirty tracking
+     * for networked components: calling `ctx.fields(C)` marks `ctx.entity`
+     * dirty for `C`, so the next snapshot picks up the write. Zero garbage,
+     * RAW-speed reads/writes.
+     *
+     * @example
+     * ```ts
+     * move: ({ dx, dz }, ctx) => {
+     *   const pos = ctx.fields(Position);
+     *   pos.x[ctx.entity] += dx * MOVE_SPEED * ctx.deltaTime;
+     *   pos.z[ctx.entity] += dz * MOVE_SPEED * ctx.deltaTime;
+     * }
+     * ```
+     */
+    fields<T extends object>(component: Component<T>): ComponentFields<T>;
+    /**
+     * Explicitly mark an entity dirty for one or more networked components.
+     *
+     * Use this when you reach into `ctx.world.fields(C)` directly (bypassing
+     * `ctx.fields`'s auto-mark) and want to control exactly when the dirty
+     * bit gets set - typically to skip the cost on no-op paths, to batch
+     * dirty marks across multiple components after a multi-field write, or
+     * to mark a target entity other than `ctx.entity` (e.g. a damage handler
+     * that mutates the victim's Health bundle).
+     *
+     * Silently no-ops for components without `sync` metadata, and for
+     * components that were never registered with the world. Defaults to
+     * `ctx.entity` if no entity argument is supplied.
+     *
+     * @example
+     * ```ts
+     * // Single component, default entity.
+     * ctx.markDirty(Position);
+     *
+     * // Multiple components, default entity (one call instead of two).
+     * ctx.markDirty([Position, Health]);
+     *
+     * // Single component on a different entity.
+     * ctx.markDirty(Health, targetId);
+     *
+     * // Multiple components on a different entity.
+     * ctx.markDirty([Position, Health], targetId);
+     *
+     * // Conditional write - only pay the dirty-mark cost when something changed.
+     * const pos = ctx.world.fields(Position);
+     * if (Math.abs(pos.x[ctx.entity] - targetX) > EPSILON) {
+     *   pos.x[ctx.entity] = targetX;
+     *   ctx.markDirty(Position);
+     * }
+     * ```
+     */
+    markDirty(component: Component<any>, entity?: Entity): void;
+    markDirty(components: ReadonlyArray<Component<any>>, entity?: Entity): void;
+}
+export interface Peer {
+    peerId: string;
+    /** -1 until `server.assignEntity` is called. */
+    entity: Entity | -1;
+}
+/**
+ * Build the `fields` accessor for a prediction or handler context.
+ *
+ * Returns a closure that, when called with a component, marks the entity
+ * dirty (for synced components) and returns the world's pre-built field
+ * bundle. Bundle objects are stable for the world's lifetime, so this
+ * adds zero allocations on the hot path beyond the closure itself.
+ */
+export declare function makeFieldsAccessor(world: World, entity: Entity): <T extends object>(component: Component<T>) => ComponentFields<T>;
+/**
+ * Build the `markDirty` accessor for a prediction or handler context.
+ *
+ * Returns a closure that marks one or more (component, entity) pairs dirty
+ * for the snapshot pipeline. Accepts either a single component or an array;
+ * defaults to `ctxEntity` when no entity arg is passed. No-ops per component
+ * for unsynced or unregistered components.
+ */
+export declare function makeMarkDirty(world: World, ctxEntity: Entity): {
+    (component: Component<any>, entity?: Entity): void;
+    (components: ReadonlyArray<Component<any>>, entity?: Entity): void;
+};
+export interface ServerHandlerContext extends PredictionContext {
+    peer: Peer;
+    /** Tick the client claimed they were on when they sent the intent. */
+    clientTick: number;
+    /** Rewind world state to `clientTick` for the duration of `fn`. */
+    lagCompensated<T>(fn: () => T): T;
+}

package/dist/netcode/types/ctx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/handlers/define-handlers.d.ts

@@ -0,0 +1,47 @@
+import type { DefinedIntents, IntentPayload, IntentSchemaMap } from '../intents/define-intents';
+import type { ServerHandlerContext } from '../ctx';
+/**
+ * A single server-only handler. Runs only when an intent arrives from a
+ * peer. May read/write server-only context (`peer`, `clientTick`,
+ * `lagCompensated`) and is never replayed on the client.
+ *
+ * Use for intents whose effect is intrinsically server-authoritative:
+ * hit detection with lag compensation, item purchases, anti-cheat
+ * checks, chat broadcasts.
+ */
+export type HandlerFn<P> = (payload: P, ctx: ServerHandlerContext) => void;
+/**
+ * Bundle of server-only handlers keyed by intent name. Partial: most
+ * games mix predictable intents (movement) with server-only handlers
+ * (combat, economy).
+ */
+export type HandlerMap<I extends IntentSchemaMap> = {
+    [K in keyof I]?: HandlerFn<IntentPayload<I, K>>;
+};
+/**
+ * Tagged bundle returned by `defineHandlers`. Pass to
+ * `server.use(handlers)`. Calling `client.use(handlers)` is a type error
+ * because the bundle's `__kind` is server-specific.
+ */
+export interface DefinedHandlers<I extends IntentSchemaMap> {
+    readonly __kind: 'handlers';
+    readonly intents: DefinedIntents<I>;
+    readonly map: HandlerMap<I>;
+}
+/**
+ * Bundle server-only intent handlers. Register via
+ * `server.use(handlers)`.
+ *
+ * @example
+ * const handlers = defineHandlers(intents, {
+ *   shoot: ({ from, dir }, ctx) => {
+ *     ctx.lagCompensated(() => {
+ *       const hit = raycast(ctx.world, from, dir);
+ *       if (hit) ctx.world.update(hit.entity, Health, { hp: ... });
+ *     });
+ *   },
+ * });
+ *
+ * server.use(handlers);
+ */
+export declare function defineHandlers<I extends IntentSchemaMap>(intents: DefinedIntents<I>, map: HandlerMap<I>): DefinedHandlers<I>;

package/dist/netcode/types/handlers/index.d.ts

@@ -0,0 +1 @@
+export * from './define-handlers';

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

@@ -0,0 +1,11 @@
+export * from './intents';
+export * from './rpcs';
+export * from './predictions';
+export * from './handlers';
+export * from './network';
+export * from './server';
+export * from './client';
+export * from './codec';
+export * from './transports';
+export * from './components';
+export * from './ctx';

package/dist/netcode/types/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/intents/define-intents.d.ts

@@ -0,0 +1,53 @@
+import { IntentRegistry, defineIntent } from 'murow/protocol';
+/**
+ * User-supplied schema map for `defineIntents`. Each entry maps an
+ * intent name to a field schema. The reserved `kind` and `tick` fields
+ * are added automatically when the wire packet is built; users only
+ * declare payload fields.
+ */
+export type IntentSchemaMap = Record<string, Record<string, any>>;
+/** Payload type for a named intent, inferred from its schema. */
+export type IntentPayload<I extends IntentSchemaMap, K extends keyof I> = {
+    [P in keyof I[K]]: I[K][P] extends {
+        read(dv: DataView, o: number): infer R;
+    } ? R : never;
+};
+/**
+ * Result of `defineIntents`. `registry` plugs into `GameServer` and
+ * `GameClient` via the `protocol` option; `__payloads` is a phantom used
+ * purely for type inference at `sendIntent` call sites.
+ */
+export interface DefinedIntents<I extends IntentSchemaMap> {
+    /** Underlying `DefinedIntent` objects keyed by name. */
+    readonly defs: {
+        readonly [K in keyof I]: ReturnType<typeof defineIntent<number, I[K]>>;
+    };
+    /** Intent name to numeric kind. */
+    readonly kindByName: {
+        readonly [K in keyof I]: number;
+    };
+    /** Numeric kind back to intent name. */
+    readonly nameByKind: Readonly<Record<number, keyof I & string>>;
+    /** Pre-populated registry ready to plug into the network layer. */
+    readonly registry: IntentRegistry;
+    /** Phantom field for type inference, never read at runtime. */
+    readonly __payloads: {
+        [K in keyof I]: IntentPayload<I, K>;
+    };
+}
+/**
+ * Declare every intent the game uses in one map. Numeric kinds are
+ * auto-assigned in insertion order starting at 1 (0 is reserved for
+ * engine control frames).
+ *
+ * @example
+ * const intents = defineIntents({
+ *   move:  { dx: f32, dy: f32 },
+ *   jump:  {},
+ *   shoot: { from: vec2_le, dir: vec2_le },
+ * });
+ *
+ * client.sendIntent('move', { dx: 1, dy: 0 });
+ * server.on('intent', ({ name, payload }) => { ... });
+ */
+export declare function defineIntents<I extends IntentSchemaMap>(intents: I): DefinedIntents<I>;

package/dist/netcode/types/intents/define-intents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/netcode/types/intents/index.d.ts

@@ -0,0 +1 @@
+export * from './define-intents';

package/dist/netcode/types/network/base.d.ts

@@ -0,0 +1,120 @@
+import { EventSystem } from 'murow/core/events';
+import type { Peer } from '../ctx';
+import type { RpcPayload, RpcSchemaMap } from '../rpcs/define-rpcs';
+/**
+ * Discriminated union over every RPC name in `R`. `name` narrows
+ * `payload` to that RPC's typed payload.
+ */
+export type RpcEvent<R extends RpcSchemaMap> = {
+    [K in keyof R & string]: {
+        name: K;
+        payload: RpcPayload<R, K>;
+    };
+}[keyof R & string];
+/** Same as `RpcEvent<R>` but with the originating `peer` field. */
+export type ServerRpcEvent<R extends RpcSchemaMap> = {
+    [K in keyof R & string]: {
+        peer: Peer;
+        name: K;
+        payload: RpcPayload<R, K>;
+    };
+}[keyof R & string];
+export interface ServerEventPayloads<R extends RpcSchemaMap = RpcSchemaMap> {
+    /** A new peer connected. */
+    connection: {
+        peer: Peer;
+    };
+    /** A peer disconnected. */
+    disconnection: {
+        peer: Peer;
+        reason: string;
+    };
+    /** An intent arrived from a peer and dispatched to its handler. */
+    intent: {
+        peer: Peer;
+        kind: number;
+        name: string;
+        payload: unknown;
+        tick: number;
+    };
+    /** Engine-level intent failure: decode error or unknown kind. */
+    'intent-failed': {
+        peer: Peer;
+        kind: number;
+        reason: string;
+    };
+    /** An RPC arrived from a peer. `name` and `payload` are correlated. */
+    rpc: ServerRpcEvent<R>;
+    /** A snapshot was packed and sent to a peer. */
+    snapshot: {
+        peer: Peer;
+        tick: number;
+        byteSize: number;
+    };
+    /** Unhandled error. */
+    error: {
+        error: Error;
+        context: string;
+    };
+}
+export interface ClientEventPayloads<R extends RpcSchemaMap = RpcSchemaMap> {
+    /** Transport opened. */
+    connected: {};
+    /** Transport closed. */
+    disconnected: {
+        reason: string;
+    };
+    /** Server sent a kick frame; disconnect imminent. */
+    kicked: {
+        reason: string;
+    };
+    /** A snapshot arrived. */
+    snapshot: {
+        tick: number;
+        byteSize: number;
+    };
+    /** An RPC arrived from the server. `name` and `payload` are correlated. */
+    rpc: RpcEvent<R>;
+    /** A new networked entity appeared in the client's view. */
+    spawn: {
+        entity: number;
+        components: Record<string, unknown>;
+    };
+    /** A networked entity left the client's view (despawn or out-of-AOI). */
+    despawn: {
+        entity: number;
+    };
+    /** Reconciliation rollback occurred. */
+    reconciled: {
+        rewindTick: number;
+        replayed: number;
+    };
+    /**
+     * Fires once the server-assigned entity exists locally. The engine
+     * buffers assignments that arrive before the matching spawn and
+     * resolves them when the entity appears. The entity is auto-marked
+     * predicted.
+     */
+    assigned: {
+        entity: number;
+    };
+    /** Round-trip measurement from the most recent `client.ping()`. */
+    pong: {
+        rtt: number;
+    };
+    /** Unhandled error. */
+    error: {
+        error: Error;
+        context: string;
+    };
+}
+type ToEventTuple<P> = {
+    [K in keyof P]: [K, P[K]];
+}[keyof P];
+export type NetworkEvents<T extends 'client' | 'server', R extends RpcSchemaMap = RpcSchemaMap> = T extends 'server' ? Array<ToEventTuple<ServerEventPayloads<R>>> : Array<ToEventTuple<ClientEventPayloads<R>>>;
+export declare class Network<T extends 'client' | 'server', R extends RpcSchemaMap = RpcSchemaMap> extends EventSystem<NetworkEvents<T, R> extends [string, unknown][] ? NetworkEvents<T, R> : never> {
+    constructor(events: string[]);
+}
+/** Narrowed event surface. `emit` is engine-internal. */
+export type PublicEventSurface<T extends 'client' | 'server', R extends RpcSchemaMap = RpcSchemaMap> = Pick<Network<T, R>, 'on' | 'once' | 'off'>;
+export {};

package/dist/netcode/types/network/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base';
+export * from './transport';

package/dist/netcode/types/network/transport.d.ts

@@ -0,0 +1 @@
+export type { TransportAdapter, ServerTransportAdapter, NetworkConfig, PeerState, LagSimulation, } from 'murow/net';

package/dist/netcode/types/packets/convergence.test.d.ts

@@ -0,0 +1 @@
+export {};