@fundamental-engine/core 0.8.0 → 0.9.0

package/dist/record/record.js

@@ -0,0 +1,172 @@
+/**
+ * Record / replay (BACKLOG tooling, #692) — capture a field run frame-by-frame and reproduce it
+ * deterministically for debugging and regression tests.
+ *
+ * The foundation rests on two existing seams:
+ *   - the injectable randomness (`FieldOptions.rng` / #371) + wall clock (`now`), so a *seeded* run
+ *     is fully reproducible — same seed, same stream, same trajectory;
+ *   - the render-agnostic swarm read-out (`FieldHandle.readParticles`, stride {@link PARTICLE_STRIDE},
+ *     wire version {@link PARTICLE_WIRE_VERSION}), the compact `[x, y, z, heat, size]` packing a
+ *     renderer already consumes — so a recording is just that wire buffer captured every frame.
+ *
+ * A run is driven on a {@link headlessHost} (no DOM, manual `tick()`), so this is pure and headless —
+ * it runs in a test or a Node service with no browser. The recorder captures per-frame particle state
+ * into ONE flat `Float32Array` (frames laid end to end), plus the metadata needed to reproduce the run.
+ * The replayer takes that metadata, re-runs the same config + seed, and yields identical frames;
+ * {@link verifyReplay} proves it.
+ *
+ * Scope of this foundational slice (and what is deferred):
+ *   - CAPTURED: per-frame particle positions, heat, and size via the readParticles wire format, plus
+ *     the env seed (rng) and the deterministic field config. (Velocities are NOT stored — the wire
+ *     format is position-based; positions are the verified invariant, and velocity is recoverable as a
+ *     per-frame position delta.)
+ *   - DEFERRED: an input timeline (burst/flowTo/setFormation calls interleaved with frames),
+ *     programmatic bodies (`addBody`) in the recorded config, and an on-disk serialization format.
+ *     The metadata + buffer here are the substrate those build on. See the module's `RecordedRun`.
+ */
+import { createField } from "../core/field.js";
+import { headlessHost } from "../core/host-headless.js";
+import { PARTICLE_STRIDE, PARTICLE_WIRE_VERSION } from "../core/types.js";
+import { seededRng } from "./rng.js";
+/** Build the deterministic field for a config on a fresh headless host + seeded rng. Shared by record
+ *  and replay so both drive byte-identical inputs. Returns the handle, the host, and a particle buffer
+ *  big enough for the pool. */
+function openRun(config) {
+    const host = headlessHost({ width: config.width, height: config.height });
+    const rng = seededRng(config.seed ?? 0);
+    // a deterministic wall clock that advances in lockstep with the headless tick (~1/60 s a frame), so
+    // wall-time-gated behaviour (the input-idle → ambient switch) is reproducible too — without it,
+    // `performance.now` would make two replays of the same config diverge once they cross an idle
+    // threshold at different real times. Starts at 0; the host's tick() drives the simulation clock,
+    // this drives the wall clock, and the seeded rng drives randomness — the three inputs a run needs.
+    let wall = 0;
+    const FRAME_MS = 1000 / 60;
+    const now = () => wall;
+    const field = createField(undefined, {
+        ...config.options,
+        host,
+        rng,
+        now,
+        render: 'none',
+    });
+    // expose the clock advance through the host's tick so callers drive both clocks with one call.
+    const baseTick = host.tick.bind(host);
+    host.tick = (t) => {
+        wall += FRAME_MS;
+        baseTick(t);
+    };
+    // size the scratch buffer to the live pool (it never grows mid-run beyond the seeded ceiling; a
+    // generous headroom covers source-spawned matter). readParticles writes min(count, capacity).
+    const cap = Math.max(field.particleCount() * 4, 1024);
+    return { field, host, scratch: new Float32Array(cap * PARTICLE_STRIDE) };
+}
+/**
+ * Record a deterministic field run: build the field, tick it `frames` times on a headless host, and
+ * capture each frame's particle state via `readParticles`. Pure given the config (seeded rng + manual
+ * clock). Returns a compact {@link RecordedRun}.
+ */
+export function recordRun(config) {
+    const { field, host, scratch } = openRun(config);
+    try {
+        const counts = [];
+        const perFrame = [];
+        let maxCount = 0;
+        for (let f = 0; f < config.frames; f++) {
+            host.tick();
+            const n = field.readParticles(scratch);
+            counts.push(n);
+            if (n > maxCount)
+                maxCount = n;
+            perFrame.push(scratch.slice(0, n * PARTICLE_STRIDE));
+        }
+        // pack the per-frame slices into one contiguous buffer with a uniform per-frame slot width.
+        const slot = maxCount * PARTICLE_STRIDE;
+        const particles = new Float32Array(config.frames * slot);
+        for (let f = 0; f < config.frames; f++) {
+            particles.set(perFrame[f], f * slot);
+        }
+        return {
+            wireVersion: PARTICLE_WIRE_VERSION,
+            stride: PARTICLE_STRIDE,
+            config,
+            frames: config.frames,
+            counts,
+            maxCount,
+            particles,
+        };
+    }
+    finally {
+        field.destroy();
+    }
+}
+/**
+ * Replay a recorded run: re-run the SAME config + seed and reproduce the per-frame particle state. The
+ * result is a fresh {@link RecordedRun} — deterministically identical to the original on the same build.
+ * Pass the original's `config` (or the whole `RecordedRun`); only the config drives the simulation.
+ */
+export function replayRun(run) {
+    const config = 'particles' in run ? run.config : run;
+    return recordRun(config);
+}
+/**
+ * Verify a replay reproduces a recording: compare every captured value frame by frame. Deterministic
+ * replay on the same build should be bit-identical (default `tol` 0); a small `tol` absorbs
+ * cross-platform float drift if a consumer compares runs from different machines.
+ */
+export function verifyReplay(expected, actual, tol = 0) {
+    if (expected.wireVersion !== actual.wireVersion) {
+        return {
+            ok: false,
+            maxDelta: Infinity,
+            mismatch: { frame: 0, particle: -1, reason: `wire version ${expected.wireVersion} → ${actual.wireVersion}` },
+        };
+    }
+    if (expected.frames !== actual.frames) {
+        return {
+            ok: false,
+            maxDelta: Infinity,
+            mismatch: { frame: Math.min(expected.frames, actual.frames), particle: -1, reason: `frame count ${expected.frames} → ${actual.frames}` },
+        };
+    }
+    const stride = expected.stride;
+    let maxDelta = 0;
+    for (let f = 0; f < expected.frames; f++) {
+        const ec = expected.counts[f] ?? 0;
+        const ac = actual.counts[f] ?? 0;
+        if (ec !== ac) {
+            return { ok: false, maxDelta, mismatch: { frame: f, particle: -1, reason: `particle count ${ec} → ${ac}` } };
+        }
+        const eSlot = f * expected.maxCount * stride;
+        const aSlot = f * actual.maxCount * stride;
+        for (let i = 0; i < ec; i++) {
+            for (let k = 0; k < stride; k++) {
+                const ev = expected.particles[eSlot + i * stride + k];
+                const av = actual.particles[aSlot + i * stride + k];
+                const d = Math.abs(ev - av);
+                if (d > maxDelta)
+                    maxDelta = d;
+                if (d > tol) {
+                    return {
+                        ok: false,
+                        maxDelta,
+                        mismatch: { frame: f, particle: i, reason: `value gap ${d} at channel ${k} (${ev} vs ${av})` },
+                    };
+                }
+            }
+        }
+    }
+    return { ok: true, maxDelta, mismatch: null };
+}
+/**
+ * Read one frame's particle state back out of a {@link RecordedRun} as a view onto the packed buffer —
+ * a `subarray` of length `counts[frame] * stride`, laid out `[x, y, z, heat, size]`. Zero-copy; do not
+ * mutate. Out-of-range frames return an empty view.
+ */
+export function frameAt(run, frame) {
+    if (frame < 0 || frame >= run.frames)
+        return new Float32Array(0);
+    const slot = run.maxCount * run.stride;
+    const start = frame * slot;
+    return run.particles.subarray(start, start + (run.counts[frame] ?? 0) * run.stride);
+}
+//# sourceMappingURL=record.js.map

package/dist/record/record.js.map

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

package/dist/record/rng.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A small, dependency-free seeded PRNG for the record/replay seam.
+ *
+ * The engine takes its randomness through an injectable `rng: () => number` (FieldOptions.rng / #371),
+ * so a deterministic generator is the single thing a recorder needs to make a run reproducible. This is
+ * `mulberry32` — a well-known 32-bit generator: tiny, fast, and bit-identical across JS engines (pure
+ * integer math, no `Math.random`), so a recording seeded here on one machine replays identically on
+ * another. The same seed always produces the same stream.
+ *
+ * This is NOT a cryptographic generator; it exists purely for reproducible simulation, never for
+ * security. Pure: a given `seed` fully determines the sequence.
+ */
+/** Create a seeded `() => number` (uniform in [0, 1)) from a 32-bit integer seed. */
+export declare function seededRng(seed: number): () => number;
+//# sourceMappingURL=rng.d.ts.map

package/dist/record/rng.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rng.d.ts","sourceRoot":"","sources":["../../src/record/rng.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CAUpD"}

package/dist/record/rng.js

@@ -0,0 +1,25 @@
+/**
+ * A small, dependency-free seeded PRNG for the record/replay seam.
+ *
+ * The engine takes its randomness through an injectable `rng: () => number` (FieldOptions.rng / #371),
+ * so a deterministic generator is the single thing a recorder needs to make a run reproducible. This is
+ * `mulberry32` — a well-known 32-bit generator: tiny, fast, and bit-identical across JS engines (pure
+ * integer math, no `Math.random`), so a recording seeded here on one machine replays identically on
+ * another. The same seed always produces the same stream.
+ *
+ * This is NOT a cryptographic generator; it exists purely for reproducible simulation, never for
+ * security. Pure: a given `seed` fully determines the sequence.
+ */
+/** Create a seeded `() => number` (uniform in [0, 1)) from a 32-bit integer seed. */
+export function seededRng(seed) {
+    // coerce to a 32-bit unsigned integer so any number (or 0) gives a valid, stable starting state.
+    let a = seed >>> 0;
+    return function next() {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+//# sourceMappingURL=rng.js.map

package/dist/record/rng.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rng.js","sourceRoot":"","sources":["../../src/record/rng.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,qFAAqF;AACrF,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,iGAAiG;IACjG,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,CAAC;IACnB,OAAO,SAAS,IAAI;QAClB,CAAC,IAAI,CAAC,CAAC;QACP,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACzC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/C,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC;IAC/C,CAAC,CAAC;AACJ,CAAC"}

package/dist/version.d.ts

@@ -4,5 +4,5 @@
  * with `packages/core/package.json` by `version.test.ts` (the build fails if they drift), so the
  * release bump is the single source of truth.
  */
-export declare const FIELD_VERSION = "0.8.0";
+export declare const FIELD_VERSION = "0.9.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -4,5 +4,5 @@
  * with `packages/core/package.json` by `version.test.ts` (the build fails if they drift), so the
  * release bump is the single source of truth.
  */
-export const FIELD_VERSION = '0.8.0';
+export const FIELD_VERSION = '0.9.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundamental-engine/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A reciprocal DOM-physics field — elements bend the field; the field's density bends them back.",
   "type": "module",
   "license": "MIT",