@driftengine/network 3.61.0

package/dist/authority.js

@@ -0,0 +1,235 @@
+import { BROADCAST } from './transport.js';
+import { MESSAGE_INPUT, MESSAGE_STATE, createDecoded, decode, encodeInput, encodeState, } from './wire.js';
+/** The machine whose world is the truth. */
+export class AuthorityHost {
+    transport;
+    loop;
+    inputs;
+    replicator;
+    stateEvery;
+    outgoing;
+    decoded = createDecoded();
+    published = 0;
+    constructor(options) {
+        this.transport = options.transport;
+        this.loop = options.loop;
+        this.inputs = options.inputs;
+        this.replicator = options.replicator;
+        this.stateEvery = Math.max(1, Math.trunc(options.stateEvery ?? 3));
+        this.outgoing = new Uint8Array(16 + Math.max(64, options.maxStateBytes ?? 8192));
+    }
+    /** How many state messages have gone out. For a consumer measuring what replication costs. */
+    get publishedStates() {
+        return this.published;
+    }
+    poll() {
+        this.transport.drain((_from, message) => {
+            if (!decode(message, this.decoded))
+                return;
+            if (this.decoded.kind !== MESSAGE_INPUT)
+                return;
+            const stride = this.decoded.payloadBytes;
+            for (let i = 0; i < this.decoded.count; i++) {
+                const tick = this.decoded.tick + i;
+                const at = this.decoded.payloadAt + i * stride;
+                if (this.inputs.isConfirmed(this.decoded.participant, tick))
+                    continue;
+                this.loop.supply(this.decoded.participant, tick, message.subarray(at, at + stride));
+            }
+        });
+    }
+    /**
+     * Take a tick, then publish if this is a publishing tick.
+     *
+     * **The state is encoded *after* the step**, so it describes the world at the end of `tick`, and
+     * a client applying it reconciles at `tick + 1`. Publishing before the step would send the world
+     * as it was when the tick began, which is the state the client already had.
+     */
+    advance(dt, tick) {
+        this.loop.advance(dt, tick);
+        const earliest = this.loop.earliest;
+        if (earliest > 0)
+            this.inputs.retain(earliest);
+        if (tick % this.stateEvery !== 0)
+            return;
+        const bytes = this.replicator.encode(this.outgoing.subarray(16), tick);
+        if (bytes < 0)
+            return;
+        const length = encodeState(this.outgoing, tick + 1, this.outgoing.subarray(16, 16 + bytes));
+        if (length < 0)
+            return;
+        this.published += 1;
+        this.transport.send(BROADCAST, this.outgoing.subarray(0, length));
+    }
+}
+/** A machine that predicts its own player and corrects toward the authority. */
+export class PredictingClient {
+    self;
+    transport;
+    loop;
+    inputs;
+    replicator;
+    predict;
+    redundancy;
+    recent;
+    outgoing;
+    decoded = createDecoded();
+    recentFrom = -1;
+    recentCount = 0;
+    correctionsValue = 0;
+    lastAppliedState = -1;
+    constructor(options) {
+        this.transport = options.transport;
+        this.loop = options.loop;
+        this.inputs = options.inputs;
+        this.replicator = options.replicator;
+        this.self = options.self;
+        this.predict = options.predict ?? true;
+        this.redundancy = Math.max(1, Math.trunc(options.redundancy ?? 4));
+        this.recent = new Uint8Array(this.redundancy * this.inputs.inputBytes);
+        this.outgoing = new Uint8Array(64 + this.redundancy * this.inputs.inputBytes);
+    }
+    /** How many authoritative states have been applied. Each one is a rewind. */
+    get corrections() {
+        return this.correctionsValue;
+    }
+    /**
+     * Send this input and, when predicting, apply it locally on the same tick.
+     *
+     * **No input delay**, unlike lockstep. A delay there buys exactness for everybody; here the
+     * authority is the source of truth anyway, so delaying the local input would add latency to the
+     * player's own controls and buy nothing.
+     */
+    submit(tick, payload) {
+        if (this.predict)
+            this.inputs.set(this.self, tick, payload);
+        this.remember(tick, payload);
+        const length = encodeInput(this.outgoing, this.self, this.recentFrom, this.recent, this.inputs.inputBytes, this.recentCount);
+        if (length < 0)
+            return;
+        this.transport.send(BROADCAST, this.outgoing.subarray(0, length));
+    }
+    poll() {
+        this.transport.drain((_from, message) => {
+            if (!decode(message, this.decoded))
+                return;
+            if (this.decoded.kind !== MESSAGE_STATE)
+                return;
+            const tick = this.decoded.tick;
+            /* An older state than one already applied is a reordered packet, not news. */
+            if (tick <= this.lastAppliedState)
+                return;
+            const payload = message.subarray(this.decoded.payloadAt, this.decoded.payloadAt + this.decoded.payloadBytes);
+            /*
+             * **A state for a tick the ring no longer holds is applied whole rather than reconciled.**
+             * There is nothing left to replay over it — the local history that far back is gone — so the
+             * honest response is to accept the authority's world and carry on from there. That is a
+             * visible jump, and it is what a client that has been away should see.
+             */
+            const applied = this.loop.reconcileSnapshot(tick, () => this.replicator.apply(payload, tick));
+            if (!applied)
+                this.replicator.apply(payload, tick);
+            this.lastAppliedState = tick;
+            this.correctionsValue += 1;
+        });
+    }
+    advance(dt, tick) {
+        this.loop.advance(dt, tick);
+        const earliest = this.loop.earliest;
+        if (earliest > 0)
+            this.inputs.retain(earliest);
+    }
+    remember(tick, payload) {
+        const stride = this.inputs.inputBytes;
+        if (this.recentFrom < 0 || tick !== this.recentFrom + this.recentCount) {
+            this.recentFrom = tick;
+            this.recentCount = 0;
+        }
+        if (this.recentCount === this.redundancy) {
+            this.recent.copyWithin(0, stride);
+            this.recentFrom += 1;
+            this.recentCount -= 1;
+        }
+        const at = this.recentCount * stride;
+        for (let i = 0; i < stride; i++)
+            this.recent[at + i] = payload[i] ?? 0;
+        this.recentCount += 1;
+    }
+}
+/**
+ * Two authoritative states and where between them to draw.
+ *
+ * **Rendering at a delay is what stops a remote body teleporting.** States arrive every few ticks
+ * and unevenly; drawing the newest one puts a body wherever the last packet said, which on a jittery
+ * link is a stutter. Drawing *between* the two most recent, a fixed distance behind the newest, costs
+ * that distance in latency and buys smooth motion — and the latency is honest, because the position
+ * shown is one the authority actually published rather than one guessed forward.
+ *
+ * This owns the timing and none of the content: `sample` answers which two payloads and how far
+ * between, and the consumer decodes and blends. It cannot do otherwise, since the payload's shape is
+ * the consumer's.
+ */
+export class StateInterpolator {
+    delayTicks;
+    ticks;
+    payloads;
+    lengths;
+    count = 0;
+    cursor = 0;
+    constructor(capacity = 8, maxBytes = 8192, delayTicks = 4) {
+        const slots = Math.max(2, Math.trunc(capacity));
+        this.ticks = new Int32Array(slots).fill(-1);
+        this.lengths = new Int32Array(slots);
+        this.payloads = Array.from({ length: slots }, () => new Uint8Array(maxBytes));
+        this.delayTicks = Math.max(0, Math.trunc(delayTicks));
+    }
+    /** Keep a state. The bytes are copied, because the transport reuses its buffer. */
+    push(tick, payload) {
+        const slot = this.cursor;
+        const room = this.payloads[slot];
+        const length = Math.min(payload.length, room.length);
+        room.set(payload.subarray(0, length));
+        this.lengths[slot] = length;
+        this.ticks[slot] = tick;
+        this.cursor = (this.cursor + 1) % this.ticks.length;
+        if (this.count < this.ticks.length)
+            this.count += 1;
+    }
+    /**
+     * The two states to blend at `renderTick`, and how far between them, or null.
+     *
+     * `alpha` is clamped to [0, 1]: past the newest state it holds there rather than extrapolating,
+     * which is the same choice `TickTrace.sample` makes at the end of a recording and for the same
+     * reason — a character who has finished should look like they finished.
+     */
+    sample(renderTick) {
+        if (this.count === 0)
+            return null;
+        const target = renderTick - this.delayTicks;
+        let before = -1;
+        let after = -1;
+        for (let i = 0; i < this.ticks.length; i++) {
+            const at = this.ticks[i];
+            if (at < 0)
+                continue;
+            if (at <= target && (before < 0 || at > this.ticks[before]))
+                before = i;
+            if (at > target && (after < 0 || at < this.ticks[after]))
+                after = i;
+        }
+        if (before < 0 && after < 0)
+            return null;
+        if (before < 0)
+            return { from: this.slice(after), to: this.slice(after), alpha: 0 };
+        if (after < 0)
+            return { from: this.slice(before), to: this.slice(before), alpha: 1 };
+        const fromTick = this.ticks[before];
+        const toTick = this.ticks[after];
+        const span = toTick - fromTick;
+        const alpha = span <= 0 ? 1 : Math.min(1, Math.max(0, (target - fromTick) / span));
+        return { from: this.slice(before), to: this.slice(after), alpha };
+    }
+    slice(slot) {
+        return this.payloads[slot].subarray(0, this.lengths[slot]);
+    }
+}

package/dist/fingerprint.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A hash of simulation state, so a divergence has a tick number attached to it.
+ *
+ * **The value is not detection, it is *localisation*.** Two peers whose worlds have drifted apart
+ * will notice eventually, because something visible will differ; what they cannot do without this is
+ * say *when* it started. A fingerprint per confirmed tick turns "we are out of sync" into "we
+ * disagreed first at tick 4,182", and the tick is the whole of the debugging: it names the inputs
+ * that were live, the entities that moved, and the one step to re-run under a debugger.
+ *
+ * Two FNV-1a streams over the bytes, which is the shape `fingerprintColliders` and
+ * `fingerprintChemistry` already use here. Sixty-four bits from two thirty-two-bit streams rather
+ * than one, because a thirty-two-bit hash collides at about seventy thousand samples by the birthday
+ * bound and a session is sixty samples a second.
+ *
+ * ---
+ *
+ * ## Floats are hashed as bits, and that is the point
+ *
+ * A hash of `x.toString()` or of a rounded value would agree across a difference of one ulp, which
+ * is exactly the difference this exists to find. So every number goes in as its eight bytes.
+ *
+ * **A consequence worth stating: `-0` and `+0` hash differently, and `NaN` hashes as whatever
+ * payload produced it.** Both are correct — two peers holding different zeroes have genuinely
+ * diverged, and a simulation that has produced a NaN has a bigger problem than a fingerprint.
+ */
+import type { WorldSnapshot } from '@driftengine/entities';
+/**
+ * An FNV-1a pair, fed bytes and numbers, answering sixteen hex characters.
+ *
+ * A class rather than a function over one buffer, because state worth fingerprinting is rarely one
+ * buffer: a consumer combines a world, a generator's position and whatever they keep beside both,
+ * and the order they feed it in is theirs to fix.
+ */
+export declare class Fingerprint {
+    private low;
+    private high;
+    private readonly scratch;
+    /** Start again, so one instance serves a whole session without allocating. */
+    reset(): this;
+    byte(value: number): this;
+    /** A 32-bit integer, low byte first. */
+    int32(value: number): this;
+    /** A double, as its eight bytes. See the header for why not as text. */
+    float(value: number): this;
+    /** A typed array's bytes, up to `count` elements, or all of them. */
+    array(values: ArrayLike<number> & {
+        BYTES_PER_ELEMENT?: number;
+    }, count?: number): this;
+    /** Sixteen lowercase hex characters. */
+    digest(): string;
+}
+/**
+ * A world snapshot's fingerprint.
+ *
+ * **The stores are walked in id order rather than in map order.** A `Map` iterates in insertion
+ * order, and two peers create their stores in whatever order their code first asked for them —
+ * which is a property of the load path, not of the world. Sorting makes the hash a function of the
+ * state instead of a function of the state and the startup sequence.
+ *
+ * The allocator goes in first, and `highWater` with it: two worlds holding identical components on
+ * identical handles but differing in how many slots have ever been used are genuinely different,
+ * because the next spawn differs.
+ */
+export declare function fingerprintSnapshot(slot: WorldSnapshot, into?: Fingerprint): string;

package/dist/fingerprint.js

@@ -0,0 +1,108 @@
+const OFFSET_BASIS = 0x811c9dc5;
+const PRIME = 0x01000193;
+/**
+ * An FNV-1a pair, fed bytes and numbers, answering sixteen hex characters.
+ *
+ * A class rather than a function over one buffer, because state worth fingerprinting is rarely one
+ * buffer: a consumer combines a world, a generator's position and whatever they keep beside both,
+ * and the order they feed it in is theirs to fix.
+ */
+export class Fingerprint {
+    low = OFFSET_BASIS;
+    high = OFFSET_BASIS;
+    scratch = new DataView(new ArrayBuffer(8));
+    /** Start again, so one instance serves a whole session without allocating. */
+    reset() {
+        this.low = OFFSET_BASIS;
+        this.high = OFFSET_BASIS;
+        return this;
+    }
+    byte(value) {
+        const b = value & 0xff;
+        this.low = Math.imul(this.low ^ b, PRIME) >>> 0;
+        /*
+         * The high stream consumes the low stream's *current* state rather than the same byte, which is
+         * what makes the two halves independent. Two streams fed identical input with different bases
+         * stay correlated and the pair is worth barely more than one of them.
+         */
+        this.high = Math.imul(this.high ^ (this.low & 0xff), PRIME) >>> 0;
+        return this;
+    }
+    /** A 32-bit integer, low byte first. */
+    int32(value) {
+        const v = value | 0;
+        this.byte(v);
+        this.byte(v >>> 8);
+        this.byte(v >>> 16);
+        this.byte(v >>> 24);
+        return this;
+    }
+    /** A double, as its eight bytes. See the header for why not as text. */
+    float(value) {
+        this.scratch.setFloat64(0, value);
+        for (let i = 0; i < 8; i++)
+            this.byte(this.scratch.getUint8(i));
+        return this;
+    }
+    /** A typed array's bytes, up to `count` elements, or all of them. */
+    array(values, count = values.length) {
+        const limit = Math.min(count, values.length);
+        this.int32(limit);
+        if (values instanceof Float64Array || values instanceof Float32Array) {
+            for (let i = 0; i < limit; i++)
+                this.float(values[i]);
+            return this;
+        }
+        for (let i = 0; i < limit; i++)
+            this.int32(values[i]);
+        return this;
+    }
+    /** Sixteen lowercase hex characters. */
+    digest() {
+        return hex(this.high) + hex(this.low);
+    }
+}
+function hex(value) {
+    return (value >>> 0).toString(16).padStart(8, '0');
+}
+/**
+ * A world snapshot's fingerprint.
+ *
+ * **The stores are walked in id order rather than in map order.** A `Map` iterates in insertion
+ * order, and two peers create their stores in whatever order their code first asked for them —
+ * which is a property of the load path, not of the world. Sorting makes the hash a function of the
+ * state instead of a function of the state and the startup sequence.
+ *
+ * The allocator goes in first, and `highWater` with it: two worlds holding identical components on
+ * identical handles but differing in how many slots have ever been used are genuinely different,
+ * because the next spawn differs.
+ */
+export function fingerprintSnapshot(slot, into = new Fingerprint()) {
+    into.reset();
+    const allocator = slot.allocator;
+    into.int32(allocator.highWater);
+    into.int32(allocator.aliveCount);
+    into.array(allocator.generations, allocator.highWater);
+    into.array(allocator.live, allocator.highWater);
+    into.array(allocator.free, allocator.freeCount);
+    const ids = [...slot.stores.keys()].sort((a, b) => a - b);
+    into.int32(ids.length);
+    for (const id of ids) {
+        const store = slot.stores.get(id);
+        if (store === undefined)
+            continue;
+        into.int32(id);
+        into.int32(store.count);
+        into.array(store.dense, store.count);
+        /* Columns by name, sorted, for the reason the stores are: a schema's field order is a property
+           of the declaration and a map's order is a property of construction. */
+        const fields = [...store.columns.keys()].sort();
+        for (const field of fields) {
+            const column = store.columns.get(field);
+            if (column === undefined || Array.isArray(column))
+                continue;
+            into.array(column, store.count);
+        }
+    }
+    return into.digest();
+}

package/dist/fixture.d.ts

@@ -0,0 +1,32 @@
+export declare const FIXTURE_BODIES = 12;
+/**
+ * The trigonometry, supplied rather than imported.
+ *
+ * **`@driftengine/core` is a devDependency here and must stay one.** This package imports
+ * `@driftengine/entities` at runtime and nothing else, which is the property that lets an
+ * authoritative host run it with no renderer in its module graph — and `boundaries.test.mjs`
+ * asserts it against the manifest rather than trusting the prose. So the fixture takes its
+ * reproducible sine and cosine as a capability, the way everything else in this package takes its
+ * dependencies, and a caller passes core's `exactSin` and `exactCos`.
+ */
+export interface FixtureMath {
+    sin(radians: number): number;
+    cos(radians: number): number;
+}
+export interface FixtureResult {
+    /** A hash of the whole state at the end. What another machine compares. */
+    readonly digest: string;
+    /** The first body's position, for a check that wants a number rather than a hash. */
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * The pair of arms, sharing one sine table and one starting state.
+ *
+ * `runFloat` uses only what `scripts/determinism.mjs` permits: arithmetic, `Math.sqrt`, and the
+ * supplied transcendentals. `runFixed` uses only `simNumber`.
+ */
+export declare function createFixture(math: FixtureMath): {
+    runFloat(ticks: number): FixtureResult;
+    runFixed(ticks: number): FixtureResult;
+};

package/dist/fixture.js

@@ -0,0 +1,136 @@
+/**
+ * One simulation, written twice: once in doubles behind the exactness gate, once in fixed point.
+ *
+ * **This is `SimNumber`'s consumer, and it exists because of a rule.** `AGENTS.md`: a feature
+ * nothing turns on is written rather than ported. An opt-in numeric type with no user in the
+ * repository would ship as untested surface area whose first real consumer finds its bugs — so the
+ * conformance fixture is written in it, and the exit test, the cross-machine script and the browser
+ * check all run both arms.
+ *
+ * **The two arms are not expected to agree with each other**, and a test asserting they did would be
+ * asserting something false: fixed point truncates where floating point rounds, so the arms diverge
+ * by design within the first few ticks. What each must be is *reproducible* — identical to itself
+ * across a rewind, across a process, and across a machine.
+ *
+ * ---
+ *
+ * ## What it simulates, and why it is this and not something simpler
+ *
+ * Bodies on a ring, each steered toward the one ahead and slowed by drag. It is chosen for what it
+ * exercises rather than for what it depicts:
+ *
+ * - **A transcendental per body per tick**, because that is where two engines disagree. The
+ *   floating arm calls `exactSin`/`exactCos`; the fixed arm uses a table, since a fixed-point sine
+ *   is a table by construction.
+ * - **A square root**, which is the operation `Math.sqrt` is exactly rounded for and `simSqrt` has
+ *   to earn by Newton iteration.
+ * - **A division**, which is the one operation the fixed arm is deterministic at rather than exact.
+ * - **Accumulated rotation**, so a one-ulp difference on tick one is visible by tick a thousand
+ *   instead of staying below the noise.
+ *
+ * A simulation of one body moving in a straight line would be reproducible on any implementation of
+ * anything, and would prove nothing.
+ */
+import { SIM_ONE, simAdd, simDiv, simFrom, simMul, simSqrt, simSub, simTo, } from './simNumber.js';
+import { Fingerprint } from './fingerprint.js';
+export const FIXTURE_BODIES = 12;
+/** How many entries the fixed arm's sine table holds over a full turn. A power of two, so the */
+/* index arithmetic is a mask rather than a modulo, and the same index is reached on every engine. */
+const TABLE_SIZE = 1024;
+const TABLE_MASK = TABLE_SIZE - 1;
+const TWO_PI = 6.283185307179586;
+/**
+ * The pair of arms, sharing one sine table and one starting state.
+ *
+ * `runFloat` uses only what `scripts/determinism.mjs` permits: arithmetic, `Math.sqrt`, and the
+ * supplied transcendentals. `runFixed` uses only `simNumber`.
+ */
+export function createFixture(math) {
+    /*
+     * The fixed arm's sine, as a table built once from the floating arm's own function.
+     *
+     * **A table rather than a fixed-point polynomial**, and the reason is the point of the whole arm:
+     * a polynomial would be arithmetic whose exactness needs an argument, and a table is a list of
+     * numbers. It is built from the same `sin` the floating arm calls, so the two arms start from one
+     * function rather than from two people's idea of one, and it is built here rather than on a tick.
+     */
+    const table = new Int32Array(TABLE_SIZE);
+    for (let i = 0; i < TABLE_SIZE; i++) {
+        table[i] = Math.round(math.sin((i / TABLE_SIZE) * TWO_PI) * SIM_ONE);
+    }
+    const simSin = (angle) => {
+        /* Angle in turns rather than radians, so the index is a multiply and a mask. */
+        const turns = simDiv(angle, simFrom(TWO_PI));
+        const index = Math.floor((turns / SIM_ONE) * TABLE_SIZE) & TABLE_MASK;
+        return table[index];
+    };
+    const simCos = (angle) => simSin(simAdd(angle, simFrom(TWO_PI / 4)));
+    return { runFloat, runFixed };
+    function runFloat(ticks) {
+        const x = new Float64Array(FIXTURE_BODIES);
+        const y = new Float64Array(FIXTURE_BODIES);
+        const angle = new Float64Array(FIXTURE_BODIES);
+        const speed = new Float64Array(FIXTURE_BODIES);
+        for (let i = 0; i < FIXTURE_BODIES; i++) {
+            x[i] = i * 0.37;
+            y[i] = -i * 0.11;
+            angle[i] = i * 0.19;
+            speed[i] = 1 + i * 0.013;
+        }
+        const dt = 1 / 60;
+        for (let tick = 0; tick < ticks; tick++) {
+            for (let i = 0; i < FIXTURE_BODIES; i++) {
+                const ahead = (i + 1) % FIXTURE_BODIES;
+                const dx = x[ahead] - x[i];
+                const dy = y[ahead] - y[i];
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                const steer = distance > 0 ? dy / (distance + 1) : 0;
+                angle[i] = angle[i] + steer * dt;
+                speed[i] = speed[i] * 0.99 + 0.02;
+                x[i] = x[i] + math.cos(angle[i]) * speed[i] * dt;
+                y[i] = y[i] + math.sin(angle[i]) * speed[i] * dt;
+            }
+        }
+        const fingerprint = new Fingerprint();
+        fingerprint.array(x).array(y).array(angle).array(speed);
+        return { digest: fingerprint.digest(), x: x[0], y: y[0] };
+    }
+    /** The fixed arm. The same simulation, in `Sim`. */
+    function runFixed(ticks) {
+        const x = new Float64Array(FIXTURE_BODIES);
+        const y = new Float64Array(FIXTURE_BODIES);
+        const angle = new Float64Array(FIXTURE_BODIES);
+        const speed = new Float64Array(FIXTURE_BODIES);
+        for (let i = 0; i < FIXTURE_BODIES; i++) {
+            x[i] = simFrom(i * 0.37);
+            y[i] = simFrom(-i * 0.11);
+            angle[i] = simFrom(i * 0.19);
+            speed[i] = simFrom(1 + i * 0.013);
+        }
+        const dt = simFrom(1 / 60);
+        const one = simFrom(1);
+        const drag = simFrom(0.99);
+        const gain = simFrom(0.02);
+        for (let tick = 0; tick < ticks; tick++) {
+            for (let i = 0; i < FIXTURE_BODIES; i++) {
+                const ahead = (i + 1) % FIXTURE_BODIES;
+                const dx = simSub(x[ahead], x[i]);
+                const dy = simSub(y[ahead], y[i]);
+                const distance = simSqrt(simAdd(simMul(dx, dx), simMul(dy, dy)));
+                const steer = distance > 0 ? simDiv(dy, simAdd(distance, one)) : 0;
+                angle[i] = simAdd(angle[i], simMul(steer, dt));
+                speed[i] = simAdd(simMul(speed[i], drag), gain);
+                const step = simMul(speed[i], dt);
+                x[i] = simAdd(x[i], simMul(simCos(angle[i]), step));
+                y[i] = simAdd(y[i], simMul(simSin(angle[i]), step));
+            }
+        }
+        const fingerprint = new Fingerprint();
+        fingerprint.array(x).array(y).array(angle).array(speed);
+        return {
+            digest: fingerprint.digest(),
+            x: simTo(x[0]),
+            y: simTo(y[0]),
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/network` — a transport seam, rewind and replay, and the two models built on them.
+ *
+ * **One rewind core under both models**, because prediction and rollback are the same operation:
+ * put the state back to tick *T*, correct what was wrong about *T*, step forward to where we were.
+ * A lockstep peer does it when a guessed input turns out wrong; a predicting client does it when
+ * its authority disagrees.
+ *
+ * **It imports `@driftengine/entities` and nothing else.** `boundaries.test.mjs` already makes the
+ * argument, about physics: a deterministic simulation with no renderer in its module graph is what
+ * an authoritative host runs. A network package that reaches no renderer is one such a host can
+ * run, and the test asserts it rather than this paragraph claiming it.
+ *
+ * **Nothing here knows what an input is.** A payload is a fixed number of bytes a consumer encodes,
+ * per `AGENTS.md`: an engine that knows a player presses a brake pedal has stopped being
+ * game-agnostic, and this is the place most netcode gives that up.
+ */
+export { RewindLoop } from './rewind.ts';
+export type { RewindOptions, SimStep, Snapshotter } from './rewind.ts';
+export { InputLog, repeatLastInput } from './inputLog.ts';
+export type { InputLogOptions, InputPredictor } from './inputLog.ts';
+export { BROADCAST } from './transport.ts';
+export type { MessageSink, PeerId, SessionRole, Transport, TransportState } from './transport.ts';
+export { ScriptSession } from './scriptSession.ts';
+export type { ScriptSessionOptions, SessionStatus } from './scriptSession.ts';
+export { createFixture, FIXTURE_BODIES } from './fixture.ts';
+export type { FixtureMath, FixtureResult } from './fixture.ts';
+export { SIM_FRACTION_BITS, SIM_MAX, SIM_MIN, SIM_ONE, simAbs, simAdd, simCompare, simDiv, simFrom, simFromInt, simMax, simMin, simMul, simNeg, simSqrt, simSub, simTo, } from './simNumber.ts';
+export type { Sim } from './simNumber.ts';
+export { AuthorityHost, PredictingClient, StateInterpolator } from './authority.ts';
+export type { AuthorityOptions, ClientOptions, Replicator } from './authority.ts';
+export { LockstepSession } from './lockstep.ts';
+export type { Desync, LockstepOptions, LockstepStatus } from './lockstep.ts';
+export { WebSocketTransport } from './websocket.ts';
+export type { SocketLike, WebSocketTransportOptions } from './websocket.ts';
+export { WebRtcTransport, unreliableChannel } from './webrtc.ts';
+export type { DataChannelLike, PeerConnectionLike, WebRtcTransportOptions } from './webrtc.ts';
+export { LoopbackNetwork, LoopbackTransport } from './loopback.ts';
+export type { Impairment, LoopbackOptions } from './loopback.ts';
+export { FINGERPRINT_BYTES, INPUT_HEADER_BYTES, MESSAGE_ACK, MESSAGE_FINGERPRINT, MESSAGE_INPUT, MESSAGE_JOIN, MESSAGE_PING, MESSAGE_STATE, MESSAGE_WELCOME, PROTOCOL_VERSION, STATE_HEADER_BYTES, createDecoded, decode, encodeAck, encodeFingerprint, encodeInput, encodeJoin, encodeState, encodeWelcome, } from './wire.ts';
+export type { DecodedMessage } from './wire.ts';
+export { Fingerprint, fingerprintSnapshot } from './fingerprint.ts';
+export { combineSnapshotters, randomSnapshotter, worldSnapshotter } from './snapshotter.ts';
+export type { SavablePosition } from './snapshotter.ts';

package/dist/index.js

@@ -0,0 +1,32 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/network` — a transport seam, rewind and replay, and the two models built on them.
+ *
+ * **One rewind core under both models**, because prediction and rollback are the same operation:
+ * put the state back to tick *T*, correct what was wrong about *T*, step forward to where we were.
+ * A lockstep peer does it when a guessed input turns out wrong; a predicting client does it when
+ * its authority disagrees.
+ *
+ * **It imports `@driftengine/entities` and nothing else.** `boundaries.test.mjs` already makes the
+ * argument, about physics: a deterministic simulation with no renderer in its module graph is what
+ * an authoritative host runs. A network package that reaches no renderer is one such a host can
+ * run, and the test asserts it rather than this paragraph claiming it.
+ *
+ * **Nothing here knows what an input is.** A payload is a fixed number of bytes a consumer encodes,
+ * per `AGENTS.md`: an engine that knows a player presses a brake pedal has stopped being
+ * game-agnostic, and this is the place most netcode gives that up.
+ */
+export { RewindLoop } from './rewind.js';
+export { InputLog, repeatLastInput } from './inputLog.js';
+export { BROADCAST } from './transport.js';
+export { ScriptSession } from './scriptSession.js';
+export { createFixture, FIXTURE_BODIES } from './fixture.js';
+export { SIM_FRACTION_BITS, SIM_MAX, SIM_MIN, SIM_ONE, simAbs, simAdd, simCompare, simDiv, simFrom, simFromInt, simMax, simMin, simMul, simNeg, simSqrt, simSub, simTo, } from './simNumber.js';
+export { AuthorityHost, PredictingClient, StateInterpolator } from './authority.js';
+export { LockstepSession } from './lockstep.js';
+export { WebSocketTransport } from './websocket.js';
+export { WebRtcTransport, unreliableChannel } from './webrtc.js';
+export { LoopbackNetwork, LoopbackTransport } from './loopback.js';
+export { FINGERPRINT_BYTES, INPUT_HEADER_BYTES, MESSAGE_ACK, MESSAGE_FINGERPRINT, MESSAGE_INPUT, MESSAGE_JOIN, MESSAGE_PING, MESSAGE_STATE, MESSAGE_WELCOME, PROTOCOL_VERSION, STATE_HEADER_BYTES, createDecoded, decode, encodeAck, encodeFingerprint, encodeInput, encodeJoin, encodeState, encodeWelcome, } from './wire.js';
+export { Fingerprint, fingerprintSnapshot } from './fingerprint.js';
+export { combineSnapshotters, randomSnapshotter, worldSnapshotter } from './snapshotter.js';