@downdraft/engine 0.2.0 → 0.3.0

package/dist/core/src/sab/sim-channel.js

@@ -11,7 +11,7 @@ export const SIM_PLAYER_SLOT_SIZE = 256;
 export const SimChannel = defineChannel({
     name: "game-sim",
     magic: 0x53494d42,
-    version: 1,
+    version: 2,
     mode: "slots",
     header: {
         size: 256,
@@ -53,6 +53,12 @@ export const SimChannel = defineChannel({
             physTimingCcdSolver: { type: "f32" },
             physTimingIslandConstruction: { type: "f32" },
             physTimingUserChanges: { type: "f32" },
+            // Presentation-interpolation timing, stamped by incrementTick().
+            // publishTimeMs is wall-clock epoch ms (timeOrigin + now) so it
+            // compares correctly across the worker/renderer thread boundary —
+            // performance.now() epochs differ per thread.
+            publishTimeMs: { type: "f64" },
+            publishDeltaMs: { type: "f32" },
         },
     },
     sections: [
@@ -108,10 +114,32 @@ export const SimChannel = defineChannel({
                 // modifying the core SAB schema.
             },
         },
+        // Previous-publish transforms for renderer-side interpolation. The
+        // writer snapshots pos+rot here before overwriting a slot, and fills
+        // the rest from cur at commit — so prev always equals state(t-1)
+        // and cur equals state(t). Same field layout as ENT/PLR transforms.
+        {
+            name: "entitiesPrev",
+            maxSlots: MAX_ENTITIES,
+            slotSize: 32,
+            fields: {
+                pos: { type: "f32", count: 4 },
+                rot: { type: "f32", count: 4 },
+            },
+        },
+        {
+            name: "playersPrev",
+            maxSlots: MAX_PLAYERS,
+            slotSize: 32,
+            fields: {
+                pos: { type: "f32", count: 4 },
+                rot: { type: "f32", count: 4 },
+            },
+        },
     ],
 });
 export const SIM_MAGIC = 0x53494d42;
-export const SIM_VERSION = 1;
+export const SIM_VERSION = 2;
 export const SIM_HDR = {
     MAGIC: 0,
     VERSION: 1,
@@ -153,6 +181,8 @@ export const SIM_HDR = {
     PHYS_TIMING_CCD_SOLVER: 37,
     PHYS_TIMING_ISLAND_CONSTRUCTION: 38,
     PHYS_TIMING_USER_CHANGES: 39,
+    PUBLISH_TIME_MS: 40, // f64 — occupies u32 words 40–41
+    PUBLISH_DELTA_MS: 42,
 };
 export const ENT = {
     POS_X: 0, POS_Y: 1, POS_Z: 2, SCALE: 3,
@@ -198,6 +228,13 @@ export const PLR_FLAG = {
     NOCLIP: 1 << 8,
     GROUNDED: 1 << 9,
 };
+// Field offsets inside the entitiesPrev/playersPrev sections. pos holds
+// [x, y, z, w] where w is entity scale / player heading; rot is the
+// quaternion. Matches ENT.POS_*/ENT.ROT_* and PLR.POS_*/PLR.ROT_* layout.
+export const PREV = {
+    POS_X: 0, POS_Y: 1, POS_Z: 2, POS_W: 3,
+    ROT_X: 4, ROT_Y: 5, ROT_Z: 6, ROT_W: 7,
+};
 export function allocateSimBuffer() {
     return SimChannel.allocate();
 }
@@ -209,10 +246,14 @@ export class SimBufferReader {
     reader;
     entitySlots;
     playerSlots;
+    entityPrevSlots;
+    playerPrevSlots;
     constructor(sab) {
         this.reader = SimChannel.reader(sab);
         this.entitySlots = this.reader.sections.entities;
         this.playerSlots = this.reader.sections.players;
+        this.entityPrevSlots = this.reader.sections.entitiesPrev;
+        this.playerPrevSlots = this.reader.sections.playersPrev;
     }
     isValid() {
         return this.reader.isValid();
@@ -222,6 +263,17 @@ export class SimBufferReader {
     }
     getTick() { return this.reader.header.u32[SimChannel.offsets.header.tick]; }
     getSequence() { return this.reader.getSequence(); }
+    /** True while the sim worker is mid-publish (sequence word is odd). */
+    isWriteInProgress() { return this.reader.isWriteInProgress(); }
+    /**
+     * Run `fn` against a consistent snapshot of the sim state — retries
+     * while the sim worker is mid-publish or publishes during the read
+     * (seqlock). Wrap per-frame read loops (entity iteration, player slot
+     * reads) in this to avoid torn reads across a sim commit.
+     */
+    readConsistent(fn, maxRetries) {
+        return this.reader.readConsistent(fn, maxRetries);
+    }
     getEntityCount() { return this.reader.header.u32[SimChannel.offsets.header.entityCount]; }
     getPlayerCount() { return this.reader.header.u32[SimChannel.offsets.header.playerCount]; }
     getTimeOfDay() { return this.reader.header.f32[SimChannel.offsets.header.timeOfDay]; }
@@ -288,55 +340,105 @@ export class SimBufferReader {
             yield { idx: i, f32: sv.f32, u32: sv.u32 };
         }
     }
+    // ── Presentation interpolation ──
+    // prev = state(t-1) transform, cur = state(t); the renderer lerps by
+    // getInterpolationAlpha(). Wall-clock epoch ms (timeOrigin + now) —
+    // comparable across the worker/renderer thread boundary.
+    getPublishTimeMs() {
+        const o = SimChannel.offsets.header;
+        return this.reader.header.f64[o.publishTimeMs >> 1];
+    }
+    getPublishDeltaMs() {
+        const o = SimChannel.offsets.header;
+        return this.reader.header.f32[o.publishDeltaMs];
+    }
+    /**
+     * Interpolation alpha in [0,1] for the current frame. 0 = exactly at
+     * the last publish, 1 = a full publish interval past it (use cur).
+     * Clamped — no extrapolation.
+     */
+    getInterpolationAlpha(nowMs) {
+        const delta = this.getPublishDeltaMs();
+        if (delta <= 0)
+            return 1;
+        const now = nowMs ?? (performance.timeOrigin ?? 0) + performance.now();
+        const a = (now - this.getPublishTimeMs()) / delta;
+        return a <= 0 ? 0 : a >= 1 ? 1 : a;
+    }
+    /** Previous-publish transform for an entity slot (prev pos+rot, PREV.*). */
+    getEntityPrevSlot(idx) {
+        const sv = this.entityPrevSlots.slot(idx);
+        return { f32: sv.f32, u32: sv.u32 };
+    }
+    /** Previous-publish transform for a player slot (prev pos+rot, PREV.*). */
+    getPlayerPrevSlot(idx) {
+        const sv = this.playerPrevSlots.slot(idx);
+        return { f32: sv.f32, u32: sv.u32 };
+    }
 }
 // --- Sim Buffer Writer (sim worker side) ---
 export class SimBufferWriter {
     writer;
     entitySlots;
     playerSlots;
+    entityPrevSlots;
+    playerPrevSlots;
     // Dirty flags: 1 = entity/player slot has changed since last writeToBuffer.
     // writeToBuffer skips slots where the flag is 0. Cleared after each writeToBuffer.
     dirtyEntities;
     dirtyPlayers;
+    // Snapshot flags: 1 = the slot's prev-transform was already captured this
+    // publish (on first write access). Cleared at each incrementTick commit.
+    snapEntities;
+    snapPlayers;
     constructor(sab) {
         this.writer = SimChannel.writer(sab);
         this.entitySlots = this.writer.sections.entities;
         this.playerSlots = this.writer.sections.players;
+        this.entityPrevSlots = this.writer.sections.entitiesPrev;
+        this.playerPrevSlots = this.writer.sections.playersPrev;
         this.dirtyEntities = new Uint8Array(MAX_ENTITIES);
         this.dirtyPlayers = new Uint8Array(MAX_PLAYERS);
+        this.snapEntities = new Uint8Array(MAX_ENTITIES);
+        this.snapPlayers = new Uint8Array(MAX_PLAYERS);
     }
     init() {
         const w = this.writer;
         const h = SimChannel.offsets.header;
+        w.beginWrite();
         w.header.u32[h.maxEntities] = MAX_ENTITIES;
         w.header.u32[h.maxPlayers] = MAX_PLAYERS;
         w.header.u32[h.entityCount] = 0;
         w.header.u32[h.playerCount] = 0;
         w.header.u32[h.activePlayers] = 0;
+        w.endWrite();
     }
-    setEntityCount(n) { this.writer.header.u32[SimChannel.offsets.header.entityCount] = n; }
-    setPlayerCount(n) { this.writer.header.u32[SimChannel.offsets.header.playerCount] = n; }
-    setTimeOfDay(t) { this.writer.header.f32[SimChannel.offsets.header.timeOfDay] = t; }
+    setEntityCount(n) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.entityCount] = n; }
+    setPlayerCount(n) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.playerCount] = n; }
+    setTimeOfDay(t) { this.writer.beginWrite(); this.writer.header.f32[SimChannel.offsets.header.timeOfDay] = t; }
     setWeather(type, intensity) {
+        this.writer.beginWrite();
         this.writer.header.u32[SimChannel.offsets.header.weatherType] = type;
         this.writer.header.f32[SimChannel.offsets.header.weatherIntensity] = intensity;
     }
     setWind(speed, dirX, dirZ) {
+        this.writer.beginWrite();
         this.writer.header.f32[SimChannel.offsets.header.windSpeed] = speed;
         this.writer.header.f32[SimChannel.offsets.header.windDirX] = dirX;
         this.writer.header.f32[SimChannel.offsets.header.windDirZ] = dirZ;
     }
-    setVisibility(v) { this.writer.header.f32[SimChannel.offsets.header.visibility] = v; }
-    setAmbientTemp(t) { this.writer.header.f32[SimChannel.offsets.header.ambientTemp] = t; }
-    setActivePlayers(mask) { this.writer.header.u32[SimChannel.offsets.header.activePlayers] = mask; }
-    setGamemode(mode) { this.writer.header.u32[SimChannel.offsets.header.gamemode] = mode; }
-    setPhysicsInitialized(v) { this.writer.header.u32[SimChannel.offsets.header.physicsInitialized] = v; }
-    setPhysicsFailed(v) { this.writer.header.u32[SimChannel.offsets.header.physicsFailed] = v; }
-    setPhysicsBodyCount(v) { this.writer.header.u32[SimChannel.offsets.header.physicsBodyCount] = v; }
-    setPhysicsTickCount(v) { this.writer.header.u32[SimChannel.offsets.header.physicsTickCount] = v; }
-    setChunkCount(v) { this.writer.header.u32[SimChannel.offsets.header.chunkCount] = v; }
-    setPhysicsProfilerEnabled(v) { this.writer.header.u32[SimChannel.offsets.header.physicsProfilerEnabled] = v; }
+    setVisibility(v) { this.writer.beginWrite(); this.writer.header.f32[SimChannel.offsets.header.visibility] = v; }
+    setAmbientTemp(t) { this.writer.beginWrite(); this.writer.header.f32[SimChannel.offsets.header.ambientTemp] = t; }
+    setActivePlayers(mask) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.activePlayers] = mask; }
+    setGamemode(mode) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.gamemode] = mode; }
+    setPhysicsInitialized(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.physicsInitialized] = v; }
+    setPhysicsFailed(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.physicsFailed] = v; }
+    setPhysicsBodyCount(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.physicsBodyCount] = v; }
+    setPhysicsTickCount(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.physicsTickCount] = v; }
+    setChunkCount(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.chunkCount] = v; }
+    setPhysicsProfilerEnabled(v) { this.writer.beginWrite(); this.writer.header.u32[SimChannel.offsets.header.physicsProfilerEnabled] = v; }
     setPhysicsTiming(data) {
+        this.writer.beginWrite();
         const h = this.writer.header.f32;
         const o = SimChannel.offsets.header;
         h[o.physTimingStep] = data.step;
@@ -356,10 +458,56 @@ export class SimBufferWriter {
         h[o.physTimingIslandConstruction] = data.islandConstruction;
         h[o.physTimingUserChanges] = data.userChanges;
     }
+    /**
+     * Copy the slot's current transform (pos+rot, first 8 f32s) into its
+     * prev slot — once per publish, on first write access, so prev always
+     * holds the last committed transform for interpolation.
+     */
+    snapshotEntityPrev(idx) {
+        if (this.snapEntities[idx])
+            return;
+        this.snapEntities[idx] = 1;
+        this.entityPrevSlots.slot(idx).f32.set(this.entitySlots.slot(idx).f32.subarray(0, 8));
+    }
+    snapshotPlayerPrev(idx) {
+        if (this.snapPlayers[idx])
+            return;
+        this.snapPlayers[idx] = 1;
+        this.playerPrevSlots.slot(idx).f32.set(this.playerSlots.slot(idx).f32.subarray(0, 8));
+    }
     incrementTick() {
         const h = SimChannel.offsets.header;
-        Atomics.add(this.writer.header.u32, h.tick, 1);
-        this.writer.bumpSequence();
+        const w = this.writer;
+        // Prev-sync: slots not written this publish keep their old cur, so
+        // prev must equal cur (identity lerp). Slots that were written were
+        // already snapshotted on first access. Runs inside the open write
+        // window, before the commit — readers never see a mixed prev/cur.
+        const entCount = Math.min(w.header.u32[h.entityCount], MAX_ENTITIES);
+        for (let i = 0; i < entCount; i++) {
+            if (!this.snapEntities[i]) {
+                this.entityPrevSlots.slot(i).f32.set(this.entitySlots.slot(i).f32.subarray(0, 8));
+            }
+        }
+        this.snapEntities.fill(0);
+        const plrCount = Math.min(w.header.u32[h.playerCount], MAX_PLAYERS);
+        for (let i = 0; i < plrCount; i++) {
+            if (!this.snapPlayers[i]) {
+                this.playerPrevSlots.slot(i).f32.set(this.playerSlots.slot(i).f32.subarray(0, 8));
+            }
+        }
+        this.snapPlayers.fill(0);
+        // Wall-clock epoch ms — performance.timeOrigin is defined per thread
+        // and makes the stamp comparable on the renderer side.
+        const now = (performance.timeOrigin ?? 0) + performance.now();
+        const tIdx = h.publishTimeMs >> 1; // u32 index 40 → f64 index 20
+        const last = w.header.f64[tIdx];
+        w.header.f64[tIdx] = now;
+        w.header.f32[h.publishDeltaMs] = last > 0 ? now - last : 0;
+        Atomics.add(w.header.u32, h.tick, 1);
+        // Closes the beginWrite() window opened by the first mutation of this
+        // publish (odd→even) — or steps +2 when nothing wrote this tick, so
+        // the sequence still advances once per publish for change detection.
+        w.bumpSequence();
     }
     markEntityDirty(slot) {
         this.dirtyEntities[slot] = 1;
@@ -383,15 +531,23 @@ export class SimBufferWriter {
         this.dirtyPlayers.fill(1);
     }
     getEntityF32(idx) {
+        this.writer.beginWrite();
+        this.snapshotEntityPrev(idx);
         return this.entitySlots.slot(idx).f32;
     }
     getEntityU32(idx) {
+        this.writer.beginWrite();
+        this.snapshotEntityPrev(idx);
         return this.entitySlots.slot(idx).u32;
     }
     getPlayerF32(idx) {
+        this.writer.beginWrite();
+        this.snapshotPlayerPrev(idx);
         return this.playerSlots.slot(idx).f32;
     }
     getPlayerU32(idx) {
+        this.writer.beginWrite();
+        this.snapshotPlayerPrev(idx);
         return this.playerSlots.slot(idx).u32;
     }
 }

package/dist/core/src/sab/slot-buffer.js

@@ -79,6 +79,31 @@ export class SlotReader {
     hasChanged(lastSeen) {
         return this.getSequence() !== lastSeen;
     }
+    /**
+     * True while the writer holds an open write window (sequence is odd).
+     * Readers can use this to cheaply defer sync work past a publish.
+     */
+    isWriteInProgress() {
+        return (Atomics.load(this.seqArr, 0) & 1) !== 0;
+    }
+    /**
+     * Run `fn` against a consistent snapshot of the channel. The sequence
+     * word is a seqlock: odd while the writer is publishing, even when the
+     * data is stable. The read is retried while the word is odd or changes
+     * mid-read; after maxRetries it returns whatever the last attempt read
+     * rather than starving the reader (writers publish every tick).
+     */
+    readConsistent(fn, maxRetries = 64) {
+        for (let i = 0; i < maxRetries; i++) {
+            const s1 = Atomics.load(this.seqArr, 0);
+            if ((s1 & 1) === 0) {
+                const out = fn();
+                if (Atomics.load(this.seqArr, 0) === s1)
+                    return out;
+            }
+        }
+        return fn();
+    }
     snapshot() {
         const data = {};
         data["sequence"] = this.getSequence();
@@ -116,6 +141,8 @@ export class SlotWriter {
     sections;
     seqArr;
     layout;
+    /** True while a beginWrite() window is open (sequence is odd). */
+    writeOpen = false;
     constructor(sab, layout) {
         this.layout = layout;
         this.header = createHeaderViews(sab, layout.header.size);
@@ -131,9 +158,35 @@ export class SlotWriter {
         this.header.u32[this.layout.header.magicIndex] = this.layout.magic;
         this.header.u32[this.layout.header.versionIndex] = this.layout.version;
     }
-    bumpSequence() {
+    /**
+     * Open a write window — marks the sequence word odd so readers know a
+     * publish is in progress. Idempotent: nested/extra calls are free, so
+     * mutating accessors can call it unconditionally on every write path.
+     */
+    beginWrite() {
+        if (this.writeOpen)
+            return;
+        this.writeOpen = true;
         Atomics.add(this.seqArr, 0, 1);
     }
+    /** Close the write window opened by beginWrite() — sequence back to even. */
+    endWrite() {
+        if (!this.writeOpen)
+            return;
+        this.writeOpen = false;
+        Atomics.add(this.seqArr, 0, 1);
+    }
+    /**
+     * Publish a commit. Legacy callers use this without a beginWrite()
+     * window: it then steps +2 (even→even) so the sequence always lands on
+     * a stable value while still advancing once per publish. Inside a
+     * beginWrite() window it closes the window (+1, odd→even).
+     */
+    bumpSequence() {
+        const step = this.writeOpen ? 1 : 2;
+        this.writeOpen = false;
+        Atomics.add(this.seqArr, 0, step);
+    }
     getSequence() {
         return Atomics.load(this.seqArr, 0);
     }

package/dist/core/src/telemetry/gpu-resource-tracker.js

@@ -131,6 +131,28 @@ export class GPUResourceTracker {
      * inform. Enable via constructor for leak-hunting sessions.
      */
     captureCallsites;
+    /**
+     * Resources dropped without destroy() are released through the native
+     * FinalizationRegistry (platform-native/gpu/registry.ts) — the wrapped
+     * destroy() never runs, so without this second registry their tracked
+     * entries (and reported VRAM) would grow forever. The held value is the
+     * tracked id; the resource object itself is the unregister token.
+     */
+    gcRegistry = new FinalizationRegistry((id) => {
+        const r = this.resources.get(id);
+        if (!r)
+            return;
+        this.resources.delete(id);
+        if (r.type === "texture") {
+            this.textureBytes -= r.size;
+            this.textureCount--;
+        }
+        else {
+            this.bufferBytes -= r.size;
+            this.bufferCount--;
+        }
+        this.dirty = true;
+    });
     constructor(opts = {}) {
         this.captureCallsites = opts.captureCallsites ?? false;
     }
@@ -160,6 +182,7 @@ export class GPUResourceTracker {
             tracker.textureBytes += bytes;
             tracker.textureCount++;
             tracker.dirty = true;
+            tracker.gcRegistry.register(tex, id, tex);
             // Wrap destroy to remove from tracking
             const origDestroy = tex.destroy.bind(tex);
             tex.destroy = function () {
@@ -170,6 +193,7 @@ export class GPUResourceTracker {
                     tracker.textureCount--;
                     tracker.dirty = true;
                 }
+                tracker.gcRegistry.unregister(tex);
                 origDestroy();
             };
             return tex;
@@ -189,6 +213,7 @@ export class GPUResourceTracker {
             tracker.bufferBytes += bytes;
             tracker.bufferCount++;
             tracker.dirty = true;
+            tracker.gcRegistry.register(buf, id, buf);
             // Wrap destroy to remove from tracking
             const origDestroy = buf.destroy.bind(buf);
             buf.destroy = function () {
@@ -199,6 +224,7 @@ export class GPUResourceTracker {
                     tracker.bufferCount--;
                     tracker.dirty = true;
                 }
+                tracker.gcRegistry.unregister(buf);
                 origDestroy();
             };
             return buf;

package/dist/core/src/util/index.js

@@ -2,3 +2,4 @@
 export { BroadPhaseGrid } from "./broad-phase-grid.js";
 export { condenseText, decodeFeatureLogLine, encodeFeatureLogJSON, encodeFeatureLogLine, encodeFeatureLogLines, encodeFeatures, FEATURE_LOG_SCHEMA_VERSION, featureCode, formatBytesShort } from "./feature-log.js";
 export { addLogSink, ConsoleLogger, createLogger, getLogTheme, getRecentLogs, setThreadTag } from "./logger.js";
+export { untrackedTimeout } from "./session-timer.js";

package/dist/core/src/util/session-timer.js

@@ -0,0 +1,22 @@
+// ============================================================================
+// session-timer.ts — scheduling that survives session teardown
+//
+// Under the native dev shell the SessionTracker wraps global setTimeout:
+// callbacks armed while the session is dead (teardown in flight) self-disarm
+// via WeakRef and never run — correct for session-owned work, fatal for
+// bound/grace-period timers whose whole job is to fire DURING teardown
+// (shutdown-RPC bounds, retire fallbacks, response timeouts). Those must
+// route through the tracker's untrackedTimeout. Outside the dev shell
+// __ddSession is absent and this is a plain setTimeout.
+// ============================================================================
+/**
+ * setTimeout that is exempt from dev-session tracking. The returned id pairs
+ * with plain clearTimeout (the wrapped clear delegates to the platform clear).
+ */
+export function untrackedTimeout(fn, ms) {
+    const tracker = globalThis.__ddSession;
+    if (typeof tracker?.untrackedTimeout === "function") {
+        return tracker.untrackedTimeout(fn, ms);
+    }
+    return setTimeout(fn, ms);
+}

package/dist/core/src/worker/base-worker-host.js

@@ -23,6 +23,7 @@
 // ============================================================================
 import { usingRealSAB } from "../sab/sab-polyfill.js";
 import { createLogger } from "../util/logger.js";
+import { untrackedTimeout } from "../util/session-timer.js";
 import { wrap } from "./rpc.js";
 const log = createLogger();
 export class BaseWorkerHost {
@@ -155,7 +156,7 @@ export class BaseWorkerHost {
                     await Promise.race([
                         this.proxy.proxy.shutdown(),
                         new Promise((_, rej) => {
-                            timer = setTimeout(() => rej(new Error("shutdown RPC timed out")), 2_000);
+                            timer = untrackedTimeout(() => rej(new Error("shutdown RPC timed out")), 2_000);
                         }),
                     ]);
                 }

package/dist/core/src/worker/buffer-sync.js

@@ -360,10 +360,11 @@ export class BufferSyncWorker {
                     len = Math.min(r.length, count * r.lengthMultiplier);
                 }
                 // Chunked transfer: if the region is large, split into chunks
-                // and send with setTimeout between them so the main thread
-                // can process rAF/render between chunks. This prevents 100-900ms
-                // main-thread blocks where SAB is unavailable
-                // and postMessage structured clone is ~10MB/s).
+                // sent as separate postMessages so the main thread interleaves
+                // receive+apply tasks with rAF/render instead of blocking on one
+                // giant structured clone. This prevents 100-900ms main-thread
+                // blocks where SAB is unavailable (and postMessage structured
+                // clone is ~10MB/s).
                 const CHUNK_SIZE = 64 * 1024; // 64KB per chunk — small enough to avoid >50ms blocks
                 if (len > CHUNK_SIZE) {
                     const numChunks = Math.ceil(len / CHUNK_SIZE);
@@ -401,10 +402,16 @@ export class BufferSyncWorker {
             // main thread to render between them.
             const allCopies = Object.values(regions).flat();
             if (allCopies.length > 1 && totalBytes > 256 * 1024) {
-                // Large transfer: send chunks with setTimeout between them so the
-                // main thread can render between chunks. Each message carries batch
-                // metadata — the receiver buffers parts and applies them atomically
-                // once all arrive, so the buffer never renders partially-updated.
+                // Large transfer: send chunks as separate postMessages so the main
+                // thread interleaves receive+apply tasks with rAF/render. Each
+                // message carries batch metadata — the receiver buffers parts and
+                // applies them atomically once all arrive, so the buffer never
+                // renders partially-updated. A setTimeout(0) between posts yields
+                // the worker's macrotask queue once per chunk — letting urgent
+                // worker-side messages (RPC responses, other sync traffic) insert
+                // between chunks rather than queueing behind the whole batch — but
+                // adds no fixed delay: measured delivery was ~16ms/chunk with a
+                // 16ms gap (~1s for a 4MB region) vs sub-ms/chunk now.
                 // Precompute chunk→buffer ownership once (was O(chunks×regions) before).
                 const chunkOwner = [];
                 for (const [name, regionList] of Object.entries(regions)) {
@@ -423,7 +430,7 @@ export class BufferSyncWorker {
                     chunkIdx++;
                     self.postMessage({ __bufferSync: true, regions: batchRegions, batch: { id: batchId, index: chunkIdx - 1, total } }, [copy.data]);
                     if (chunkIdx < total) {
-                        setTimeout(sendNextChunk, 16); // 16ms delay lets main thread render between chunks
+                        setTimeout(sendNextChunk, 0); // yield the macrotask queue between chunk posts
                     }
                 };
                 sendNextChunk();

package/dist/core/src/worker/rpc.js

@@ -4,6 +4,7 @@
 // Works in both Web Workers and Node.js worker_threads.
 // ============================================================================
 import { createLogger } from "../util/logger.js";
+import { untrackedTimeout } from "../util/session-timer.js";
 const log = createLogger();
 // In Node.js/Bun worker_threads, `parentPort` is non-null only inside a
 // worker connected to a parent — its presence IS the worker check. (The old
@@ -63,6 +64,9 @@ function isRpcResponse(msg) {
 function isEventMessage(msg) {
     return msg && msg.__event === true;
 }
+function isEventBatchMessage(msg) {
+    return msg && msg.__eventBatch === true;
+}
 export function expose(api, options) {
     const h = options?.host ?? getWorkerHost();
     h.onHostMessage(async (msg) => {
@@ -90,6 +94,37 @@ export function exposeEvents(host) {
         },
     };
 }
+/**
+ * Event emitter that coalesces emit() calls into a single `__eventBatch`
+ * postMessage per macrotask. A sim emitting per-tick or per-entity events
+ * otherwise produces one structured clone + one main-thread task per event,
+ * and the task burst competes with rAF. Events emitted during a tick batch
+ * (the worker never yields to timers mid-tick) all land in one message;
+ * events emitted between ticks flush on the next macrotask, so latency for
+ * isolated events is unchanged.
+ */
+export function exposeBatchedEvents(host) {
+    const h = host ?? getWorkerHost();
+    let queue = [];
+    let flushScheduled = false;
+    const flush = () => {
+        flushScheduled = false;
+        if (queue.length === 0)
+            return;
+        h.postToHost({ __eventBatch: true, events: queue });
+        queue = [];
+    };
+    return {
+        emit: (kind, data) => {
+            queue.push({ kind, data });
+            if (!flushScheduled) {
+                flushScheduled = true;
+                setTimeout(flush, 0);
+            }
+        },
+        flush,
+    };
+}
 const DEFAULT_TIMEOUT_MS = 30_000;
 export function wrap(worker, options) {
     const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -114,13 +149,16 @@ export function wrap(worker, options) {
                 p.resolve(msg.result);
             return;
         }
-        if (isEventMessage(msg)) {
-            for (const cb of eventListeners.values()) {
-                try {
-                    cb(msg.kind, msg.data);
-                }
-                catch (err) {
-                    log.error("worker-proxy", `Event listener error: ${err}`);
+        if (isEventMessage(msg) || isEventBatchMessage(msg)) {
+            const events = isEventBatchMessage(msg) ? msg.events : [msg];
+            for (const ev of events) {
+                for (const cb of eventListeners.values()) {
+                    try {
+                        cb(ev.kind, ev.data);
+                    }
+                    catch (err) {
+                        log.error("worker-proxy", `Event listener error: ${err}`);
+                    }
                 }
             }
         }
@@ -172,7 +210,7 @@ export function wrap(worker, options) {
                     const id = ++reqId;
                     const entry = { resolve, reject };
                     if (timeoutMs > 0) {
-                        entry.timer = setTimeout(() => {
+                        entry.timer = untrackedTimeout(() => {
                             if (pending.delete(id)) {
                                 reject(new Error(`RPC '${method}' timed out after ${timeoutMs}ms`));
                             }

package/dist/core/src/worker/sim-worker-base.js

@@ -38,7 +38,7 @@ import "../sab/sab-polyfill.js";
 import { usingRealSAB } from "../sab/sab-polyfill.js";
 import { mulberry32 } from "../math/rng.js";
 import { createLogger } from "../util/logger.js";
-import { expose, exposeEvents } from "./rpc.js";
+import { expose, exposeBatchedEvents } from "./rpc.js";
 const log = createLogger();
 /**
  * Detect deterministic/test mode inside a worker. `DOWNDRAFT_DETERMINISTIC`
@@ -158,7 +158,7 @@ export function createSimWorker(opts) {
     let tickInFlight = null;
     // Serializes withLoopStopped critical sections.
     let stopChain = Promise.resolve();
-    const events = exposeEvents();
+    const events = exposeBatchedEvents();
     // Deterministic RNG — reseedable via control.setSeed(); the stable `rng`
     // closure is what ctx.rng and the Math.random shim draw from.
     let rngImpl = mulberry32(opts.seed ?? 0x9e3779b9);
@@ -423,6 +423,9 @@ export function createSimWorker(opts) {
             syncWorker = null; // release sync worker reference
             saveStore = null;
             await opts.onShutdown?.();
+            // Drain any events queued during onShutdown so they aren't lost to
+            // a flush timer the terminating worker never runs.
+            events.flush();
         },
         async setSpeed(speed) {
             speedMultiplier = Math.min(opts.maxSpeed ?? Infinity, Math.max(opts.minSpeed ?? 0, speed));

package/dist/core/src/worker/task-pool.js

@@ -78,6 +78,11 @@ export class TaskPool {
             for (let i = 0; i < this.workerCount; i++) {
                 const worker = this.createWorker();
                 worker.onerror = (e) => {
+                    // Session teardown tags tracked workers __ddExpectTerminate and
+                    // fires synthetic error events to settle waiters — not faults
+                    // (see session-tracker.ts terminateTrackedWorker).
+                    if (worker.__ddExpectTerminate || this.destroyed)
+                        return;
                     if (this.onWorkerError)
                         this.onWorkerError(i, e);
                     else