@driftengine/network 3.61.0

package/src/authority.ts

@@ -0,0 +1,340 @@
+/**
+ * One machine's state is the truth, and everybody else predicts and corrects.
+ *
+ * **The correction is a rewind**, which is why this file is short. A client that mispredicted has
+ * computed some ticks from a world that was wrong; putting the authority's world back at that tick
+ * and replaying the local inputs over it is exactly `reconcileSnapshot`. There is no second
+ * mechanism here, only a different reason for reaching the same one.
+ *
+ * ---
+ *
+ * ## What crosses, and who decides
+ *
+ * A `Replicator` is supplied by the consumer. This package cannot know which of a game's fields are
+ * authoritative, which are cosmetic, or how to pack them — and an engine that did would be a
+ * particular game's engine. What it does own is *when*: the host publishes on a cadence, and the
+ * client applies at the tick the message names.
+ *
+ * ## Prediction is for the local participant only
+ *
+ * A client predicts *its own* entity from its own inputs, immediately, because the whole point is
+ * that a player's controls feel attached to their hands. It does **not** extrapolate other players
+ * forward. Extrapolation is a choice between showing a stale position and showing a wrong one, and
+ * which is worse depends on the game: a wrong position in a shooter decides a hit, and a stale one
+ * in a racing game is a car in the wrong place on a corner. So remote bodies are *interpolated*
+ * between two states the authority actually sent — `StateInterpolator` below — and anything more
+ * aggressive is a consumer's to write.
+ *
+ * ## What is not here
+ *
+ * **Lag compensation.** An authority rewinding the world to a shooter's view of the past, so their
+ * shot hits what was on their screen, is a real technique and a policy about who wins a disputed
+ * shot. `RewindLoop.rewindTo` is public so it can be built; choosing it for every game is not this
+ * package's business.
+ *
+ * **Interest management.** A world large enough that a client should not receive all of it needs
+ * spatial partitioning of replication state. Reversed by a consumer measuring replication bandwidth
+ * as their constraint.
+ */
+import type { InputLog } from './inputLog.ts';
+import type { RewindLoop } from './rewind.ts';
+import { BROADCAST, type PeerId, type Transport } from './transport.ts';
+import {
+  MESSAGE_INPUT,
+  MESSAGE_STATE,
+  createDecoded,
+  decode,
+  encodeInput,
+  encodeState,
+} from './wire.ts';
+
+/**
+ * What a consumer packs and unpacks.
+ *
+ * `encode` answers -1 when the state does not fit, for the reason the wire encoders do: the caller
+ * is a frame loop and `AGENTS.md` forbids throwing in one.
+ */
+export interface Replicator {
+  encode(into: Uint8Array, tick: number): number;
+  apply(from: Uint8Array, tick: number): void;
+}
+
+export interface AuthorityOptions<S> {
+  readonly transport: Transport;
+  readonly loop: RewindLoop<S>;
+  readonly inputs: InputLog;
+  readonly replicator: Replicator;
+  /**
+   * How often the authoritative state is published, in ticks.
+   *
+   * **Three at 60 Hz is twenty a second**, which is what most shipped netcode settles near: often
+   * enough that a correction is small, rare enough that the bandwidth is a fraction of what a
+   * per-tick broadcast costs. A consumer whose state is tiny can publish every tick and one whose
+   * world is large should publish less and send deltas.
+   */
+  readonly stateEvery?: number;
+  /** Room for one encoded state. 8 KB by default; a state that does not fit is a state to delta. */
+  readonly maxStateBytes?: number;
+}
+
+/** The machine whose world is the truth. */
+export class AuthorityHost<S> {
+  private readonly transport: Transport;
+  private readonly loop: RewindLoop<S>;
+  private readonly inputs: InputLog;
+  private readonly replicator: Replicator;
+  private readonly stateEvery: number;
+  private readonly outgoing: Uint8Array;
+  private readonly decoded = createDecoded();
+  private published = 0;
+
+  constructor(options: AuthorityOptions<S>) {
+    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(): number {
+    return this.published;
+  }
+
+  poll(): void {
+    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: number, tick: number): void {
+    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));
+  }
+}
+
+export interface ClientOptions<S> {
+  readonly transport: Transport;
+  readonly loop: RewindLoop<S>;
+  readonly inputs: InputLog;
+  readonly replicator: Replicator;
+  readonly self: PeerId;
+  /** Predict the local participant. Off means wait for the authority, which is the control. */
+  readonly predict?: boolean;
+  /** Recent inputs carried in every packet, for the reason `LockstepSession` documents. */
+  readonly redundancy?: number;
+}
+
+/** A machine that predicts its own player and corrects toward the authority. */
+export class PredictingClient<S> {
+  readonly self: PeerId;
+
+  private readonly transport: Transport;
+  private readonly loop: RewindLoop<S>;
+  private readonly inputs: InputLog;
+  private readonly replicator: Replicator;
+  private readonly predict: boolean;
+  private readonly redundancy: number;
+  private readonly recent: Uint8Array;
+  private readonly outgoing: Uint8Array;
+  private readonly decoded = createDecoded();
+
+  private recentFrom = -1;
+  private recentCount = 0;
+  private correctionsValue = 0;
+  private lastAppliedState = -1;
+
+  constructor(options: ClientOptions<S>) {
+    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(): number {
+    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: number, payload: Uint8Array): void {
+    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(): void {
+    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: number, tick: number): void {
+    this.loop.advance(dt, tick);
+    const earliest = this.loop.earliest;
+    if (earliest > 0) this.inputs.retain(earliest);
+  }
+
+  private remember(tick: number, payload: Uint8Array): void {
+    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 {
+  readonly delayTicks: number;
+
+  private readonly ticks: Int32Array;
+  private readonly payloads: Uint8Array[];
+  private readonly lengths: Int32Array;
+  private count = 0;
+  private 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: number, payload: Uint8Array): void {
+    const slot = this.cursor;
+    const room = this.payloads[slot] as Uint8Array;
+    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: number): { from: Uint8Array; to: Uint8Array; alpha: number } | null {
+    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] as number;
+      if (at < 0) continue;
+      if (at <= target && (before < 0 || at > (this.ticks[before] as number))) before = i;
+      if (at > target && (after < 0 || at < (this.ticks[after] as number))) 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] as number;
+    const toTick = this.ticks[after] as number;
+    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 };
+  }
+
+  private slice(slot: number): Uint8Array {
+    return (this.payloads[slot] as Uint8Array).subarray(0, this.lengths[slot] as number);
+  }
+}

package/src/fingerprint.ts

@@ -0,0 +1,143 @@
+/**
+ * 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';
+
+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 {
+  private low = OFFSET_BASIS;
+  private high = OFFSET_BASIS;
+  private readonly scratch = new DataView(new ArrayBuffer(8));
+
+  /** Start again, so one instance serves a whole session without allocating. */
+  reset(): this {
+    this.low = OFFSET_BASIS;
+    this.high = OFFSET_BASIS;
+    return this;
+  }
+
+  byte(value: number): this {
+    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: number): this {
+    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: number): this {
+    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: ArrayLike<number> & { BYTES_PER_ELEMENT?: number }, count = values.length): this {
+    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] as number);
+      return this;
+    }
+    for (let i = 0; i < limit; i++) this.int32(values[i] as number);
+    return this;
+  }
+
+  /** Sixteen lowercase hex characters. */
+  digest(): string {
+    return hex(this.high) + hex(this.low);
+  }
+}
+
+function hex(value: number): string {
+  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: WorldSnapshot, into = new Fingerprint()): string {
+  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/src/fixture.ts

@@ -0,0 +1,188 @@
+/**
+ * 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,
+  type Sim,
+  simAdd,
+  simDiv,
+  simFrom,
+  simMul,
+  simSqrt,
+  simSub,
+  simTo,
+} from './simNumber.ts';
+import { Fingerprint } from './fingerprint.ts';
+
+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 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 function createFixture(math: FixtureMath): {
+  runFloat(ticks: number): FixtureResult;
+  runFixed(ticks: number): FixtureResult;
+} {
+  /*
+   * 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: Sim): Sim => {
+    /* 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] as number;
+  };
+  const simCos = (angle: Sim): Sim => simSin(simAdd(angle, simFrom(TWO_PI / 4)));
+
+  return { runFloat, runFixed };
+
+  function runFloat(ticks: number): FixtureResult {
+    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] as number) - (x[i] as number);
+        const dy = (y[ahead] as number) - (y[i] as number);
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const steer = distance > 0 ? dy / (distance + 1) : 0;
+
+        angle[i] = (angle[i] as number) + steer * dt;
+        speed[i] = (speed[i] as number) * 0.99 + 0.02;
+        x[i] = (x[i] as number) + math.cos(angle[i] as number) * (speed[i] as number) * dt;
+        y[i] = (y[i] as number) + math.sin(angle[i] as number) * (speed[i] as number) * dt;
+      }
+    }
+
+    const fingerprint = new Fingerprint();
+    fingerprint.array(x).array(y).array(angle).array(speed);
+    return { digest: fingerprint.digest(), x: x[0] as number, y: y[0] as number };
+  }
+
+  /** The fixed arm. The same simulation, in `Sim`. */
+  function runFixed(ticks: number): FixtureResult {
+    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] as number, x[i] as number);
+        const dy = simSub(y[ahead] as number, y[i] as number);
+        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] as number, simMul(steer, dt));
+        speed[i] = simAdd(simMul(speed[i] as number, drag), gain);
+        const step = simMul(speed[i] as number, dt);
+        x[i] = simAdd(x[i] as number, simMul(simCos(angle[i] as number), step));
+        y[i] = simAdd(y[i] as number, simMul(simSin(angle[i] as number), step));
+      }
+    }
+
+    const fingerprint = new Fingerprint();
+    fingerprint.array(x).array(y).array(angle).array(speed);
+    return {
+      digest: fingerprint.digest(),
+      x: simTo(x[0] as number),
+      y: simTo(y[0] as number),
+    };
+  }
+}