@woosh/meep-engine 3.31.0 → 3.32.0

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#415@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#416@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#415@#clear_field"(fluid: FluidComponent): void;
+    static "__#416@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#415@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#416@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#415@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#416@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/shade/RENDERER_CONTRACT.md

@@ -398,14 +398,18 @@ class PathExtension extends RenderExtension {
         }
 
         const scene = frame.get(SceneColor);
+        const view = frame.get(ViewTextures);
 
-        scene.color = this.#renderer.graph_draw({
+        const drawn = this.#renderer.graph_draw({
             graph: frame.graph,
             batch: this.#batch,
             color: scene.color,
-            depth: frame.get(ViewTextures).depth,
+            depth: view.depth,
             camera: frame.view.camera.buffer
         });
+
+        scene.color = drawn.color;
+        view.depth = drawn.depth;
     }
 }
 
@@ -590,6 +594,15 @@ which is what effects want. Set it and the pass writes depth instead: a solid su
 build behind it has no depth ordering otherwise, and no CPU sort can give it one, because a painter's
 order over triangles is wrong wherever two of them interpenetrate.
 
+`graph_draw` hands back `{ color, depth }`, and an extension publishes both, as in §6. The depth is a
+new handle when the pass wrote it. Anything reading the scene depth after you — depth of field,
+motion blur, the NSS upscaler, the next extension — has to be given that handle; a development build
+refuses the frame when it is not. Left `false`, the depth comes back as it went in.
+
+That is also what decides the phase for solid content. At `AfterLighting` transparency has not run
+yet, and it tests against the depth you published, so glass in front of the batch covers it. At
+`AfterTransparency` the glass is already resolved into the colour, and the batch is drawn over it.
+
 Residency is keyed on **the geometry**, not on batch membership, so a mesh that blinks off for a
 frame or is removed and re-added keeps its buffers.
 

package/src/shade/device/IMMEDIATE_DATA_PLAN_2026_08_28.md

@@ -562,3 +562,8 @@ harness. Keeping the door open costs nothing; walking through it preemptively co
   call sites are the strongest case for immediates, but the standing TODO there is a separate bug —
   the 2025-09-13 note says the obvious fix produced garbage and was never chased down. Immediates
   route around it for the ≤64-byte cases without explaining it.
+  Answered 2026-09-26: fixed independently. The garbage was frame-graph aliasing — a `queue.writeBuffer`
+  into a pooled buffer lands ahead of the whole submission, and a pass earlier in it had written that
+  buffer for another resource. The import now writes with `writeValueBuffer`, in order, and creates no
+  buffer per frame; `graph_import_typed_buffer.spec.js` pins both. Immediates would still drop the
+  buffer altogether for the ≤64-byte cases.

package/src/shade/device/ShadeGPUCommandContext.d.ts

@@ -268,6 +268,8 @@ export class ShadeGPUCommandContext {
      */
     allocateTransientValueBuffer<T>(type: WebGPUType, value: T, usage?: number | GPUBufferUsage): GPUBuffer;
     /**
+     * Like {@link writeBuffer}, with the bytes serialised from `value` as `type` lays them out.
+     *
      * @template T
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
@@ -276,12 +278,22 @@ export class ShadeGPUCommandContext {
      */
     writeValueBuffer<T_1>(buffer: GPUBuffer, buffer_offset: number, type: WebGPUType, value: T_1): void;
     /**
-     * Very similar to {@link GPUQueue.writeBuffer}, but instead of doing the operation direction on the queue - uses a staging buffer under the hood and performs the actual write operation as part of the commmand buffer
+     * Write bytes into `buffer` at this point in the command stream: after everything recorded
+     * before this call, and before everything recorded after it.
+     *
+     * That is the difference from {@link GPUQueue#writeBuffer}, which lands ahead of the whole
+     * submission — ahead of passes recorded earlier in it that may still need the old contents. Here
+     * the bytes are staged, and a copy out of the staging is recorded in their place. Small writes
+     * are staged in this context's upload blocks, which reach the GPU with one queue write each when
+     * the context finishes, so a frame of thousands of them costs no mapping at all; writes of
+     * {@link MAPPED_UPLOAD_THRESHOLD} bytes or more go through a mapped staging buffer each, which is
+     * the faster road for bytes.
+     *
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
      * @param {ArrayBuffer} data
      * @param {number} data_offset
-     * @param {number} size
+     * @param {number} size a multiple of 4, as for any buffer copy
      */
     writeBuffer(buffer: GPUBuffer, buffer_offset: number, data: ArrayBuffer, data_offset: number, size: number): void;
     /**
@@ -297,6 +309,7 @@ export type GraphicsContext = import("../renderer/GraphicsContext.js").GraphicsC
 export type ShaderResourceSetDescriptor = import("../renderer/shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
 export type WebGPUType = import("../renderer/shader/type/WebGPUType.js").WebGPUType;
 export type TextureManager = import("../renderer/texture/TextureManager.js").TextureManager;
+export type GPUUploadBlock = import("../renderer/buffer/GPUUploadBlock.js").GPUUploadBlock;
 export type GPUFrameRecorder = import("./timing/profile/GPUFrameRecorder.js").GPUFrameRecorder;
 import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
 import { ShadeGPUComputePassEncoder } from "./pass/ShadeGPUComputePassEncoder.js";

package/src/shade/device/ShadeGPUCommandContext.d.ts.map

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

package/src/shade/device/ShadeGPUCommandContext.js

@@ -10,6 +10,7 @@ import { ShadeGPURenderPassEncoder } from "./pass/ShadeGPURenderPassEncoder.js";
 import { ShadeGPUContextProfiler } from "./timing/ShadeGPUContextProfiler.js";
 import { warn_limited } from "../util/warn_limited.js";
 import { write_gpu_typed_buffer } from "../renderer/shader/type/serde/write_gpu_typed_buffer.js";
+import { MAPPED_UPLOAD_THRESHOLD } from "../renderer/buffer/GPUBufferUploadAllocator.js";
 import { BufferResourceDescriptor } from "./graph/BufferResourceDescriptor.js";
 import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
 
@@ -24,6 +25,7 @@ import { GraphicsExecutionContext } from "./graph/GraphicsExecutionContext.js";
  * @typedef {import("../renderer/shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} ShaderResourceSetDescriptor
  * @typedef {import("../renderer/shader/type/WebGPUType.js").WebGPUType} WebGPUType
  * @typedef {import("../renderer/texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../renderer/buffer/GPUUploadBlock.js").GPUUploadBlock} GPUUploadBlock
  * @typedef {import("./timing/profile/GPUFrameRecorder.js").GPUFrameRecorder} GPUFrameRecorder
  */
 
@@ -180,6 +182,17 @@ export class ShadeGPUCommandContext {
     #transient_buffers = [];
 
     /**
+     * Upload blocks this context has written its small uploads into, the one being filled last. Sent
+     * to the GPU just before the submit, one queue write per block, and given back when the context
+     * finishes.
+     *
+     * @type {GPUUploadBlock[]}
+     */
+    #upload_blocks = [];
+
+    /**
+     * Mapped staging buffers this context's large uploads went through, one each. Given back when the
+     * context finishes, and mapped again by their pool before it hands them out anew.
      *
      * @type {GPUBuffer[]}
      */
@@ -727,6 +740,8 @@ export class ShadeGPUCommandContext {
     }
 
     /**
+     * Like {@link writeBuffer}, with the bytes serialised from `value` as `type` lays them out.
+     *
      * @template T
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
@@ -737,30 +752,48 @@ export class ShadeGPUCommandContext {
 
         assert.notOk(this.#finished, 'already finished');
 
-        const gfx = this.#graphics;
-
         const size = type.aligned_size;
 
-        const stage = gfx.buffer_allocator_staging.get(size);
+        if (size >= MAPPED_UPLOAD_THRESHOLD) {
+            const stage = this.#graphics.buffer_allocator_staging.get(size);
+
+            // recorded before it is filled, so a fill that throws still gives it back
+            this.#staging_buffers.push(stage);
 
-        const mapped = stage.getMappedRange(0, size);
+            write_gpu_typed_buffer(value, type, stage.getMappedRange(0, size), 0);
 
-        write_gpu_typed_buffer(value, type, mapped, 0);
+            stage.unmap();
 
-        stage.unmap();
+            this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
 
-        this.#staging_buffers.push(stage);
+            return;
+        }
+
+        const block = this.#upload_block_with_room(size);
+        const offset = block.allocate(size);
+
+        write_gpu_typed_buffer(value, type, block.data, offset);
 
-        this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
+        this.copyBufferToBuffer(block.buffer, offset, buffer, buffer_offset, size);
     }
 
     /**
-     * Very similar to {@link GPUQueue.writeBuffer}, but instead of doing the operation direction on the queue - uses a staging buffer under the hood and performs the actual write operation as part of the commmand buffer
+     * Write bytes into `buffer` at this point in the command stream: after everything recorded
+     * before this call, and before everything recorded after it.
+     *
+     * That is the difference from {@link GPUQueue#writeBuffer}, which lands ahead of the whole
+     * submission — ahead of passes recorded earlier in it that may still need the old contents. Here
+     * the bytes are staged, and a copy out of the staging is recorded in their place. Small writes
+     * are staged in this context's upload blocks, which reach the GPU with one queue write each when
+     * the context finishes, so a frame of thousands of them costs no mapping at all; writes of
+     * {@link MAPPED_UPLOAD_THRESHOLD} bytes or more go through a mapped staging buffer each, which is
+     * the faster road for bytes.
+     *
      * @param {GPUBuffer} buffer
      * @param {number} buffer_offset
      * @param {ArrayBuffer} data
      * @param {number} data_offset
-     * @param {number} size
+     * @param {number} size a multiple of 4, as for any buffer copy
      */
     writeBuffer(buffer, buffer_offset, data, data_offset, size) {
         assert.defined(buffer, 'buffer');
@@ -769,20 +802,95 @@ export class ShadeGPUCommandContext {
         assert.isNonNegativeInteger(data_offset, 'data_offset');
         assert.isNonNegativeInteger(size, 'size');
 
-        const gfx = this.#graphics;
+        assert.notOk(this.#finished, 'already finished');
+
+        if (size % 4 !== 0) {
+            // Refused here rather than left to the copy, as a mapped staging buffer of this size
+            // always was: a copy moves whole 4-byte words, and one that cannot takes the context's
+            // whole submission down with it, later, without naming the write that did it.
+            throw new RangeError(`writeBuffer: size ${size} is not a multiple of 4`);
+        }
+
+        if (size === 0) {
+            // a copy of nothing changes nothing
+            return;
+        }
+
+        if (size >= MAPPED_UPLOAD_THRESHOLD) {
+            const stage = this.#graphics.buffer_allocator_staging.get(size);
 
-        const stage = gfx.buffer_allocator_staging.get(size);
+            // recorded before it is filled, so a fill that throws still gives it back
+            this.#staging_buffers.push(stage);
 
-        const mapped = stage.getMappedRange(0, size);
+            array_buffer_copy(data, data_offset, stage.getMappedRange(0, size), 0, size);
 
-        array_buffer_copy(data, data_offset, mapped, 0, size);
+            stage.unmap();
 
-        stage.unmap();
+            this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
 
-        this.#staging_buffers.push(stage);
+            return;
+        }
 
-        this.copyBufferToBuffer(stage, 0, buffer, buffer_offset, size);
+        const block = this.#upload_block_with_room(size);
+        const offset = block.allocate(size);
 
+        array_buffer_copy(data, data_offset, block.data, offset, size);
+
+        this.copyBufferToBuffer(block.buffer, offset, buffer, buffer_offset, size);
+    }
+
+    /**
+     * The block to take the next `size` bytes of upload from: the one being filled, or a fresh one
+     * when that is full. Every write that comes here is smaller than
+     * {@link MAPPED_UPLOAD_THRESHOLD}, so any empty block holds it.
+     *
+     * A block that cannot take the next write is not revisited: what is left in it is wasted until
+     * the context finishes, which bounds the waste at one block's tail per block and keeps every
+     * write a single contiguous copy.
+     *
+     * @param {number} size
+     * @returns {GPUUploadBlock}
+     */
+    #upload_block_with_room(size) {
+        const blocks = this.#upload_blocks;
+        const last = blocks.length - 1;
+
+        if (last >= 0 && blocks[last].fits(size)) {
+            return blocks[last];
+        }
+
+        const block = this.#graphics.buffer_allocator_upload.get();
+
+        blocks.push(block);
+
+        return block;
+    }
+
+    /**
+     * Put this context's upload blocks on the GPU: one queue write per block, of the part written.
+     *
+     * Must come immediately before the submit, and this is the whole of why a block can go back to
+     * its pool the moment its context finishes rather than when the GPU is done with it. The queue
+     * runs its operations in order, so a write issued here lands after everything submitted before
+     * this context — including the copies of any earlier context that held the same block — and
+     * before this context's own copies read it. Nothing is mapped, so nothing is waited for.
+     *
+     * A queue write lands ahead of its whole submission, which is why it goes only into a block and
+     * never into a destination: blocks come from a pool of their own that nothing aliases, while
+     * the frame graph's buffers are aliased within a submission, and a queue write into one of those
+     * would overwrite what an earlier pass in it still needs.
+     *
+     * @param {GPUQueue} queue
+     */
+    #send_uploads(queue) {
+        const blocks = this.#upload_blocks;
+        const count = blocks.length;
+
+        for (let i = 0; i < count; i++) {
+            const block = blocks[i];
+
+            queue.writeBuffer(block.buffer, 0, block.data, 0, block.used);
+        }
     }
 
     #cleanup() {
@@ -802,11 +910,29 @@ export class ShadeGPUCommandContext {
 
         }
 
-        // staging buffers
+        // Blocks go back now rather than when the GPU is done with them — see #send_uploads.
+        const buffer_allocator_upload = this.#graphics.buffer_allocator_upload;
+
+        for (const block of this.#upload_blocks) {
+            buffer_allocator_upload.release(block);
+        }
+
+        this.#upload_blocks.length = 0;
+
+        // staging buffers are mapped again by their pool, which is when they are free again
         const buffer_allocator_staging = this.#graphics.buffer_allocator_staging;
+
         for (const staging of this.#staging_buffers) {
+            if (staging.mapState === "mapped") {
+                // a write that threw while filling it, so no copy out of it was recorded; unmapped
+                // here so its pool maps it afresh rather than handing out a range already given out
+                staging.unmap();
+            }
+
             buffer_allocator_staging.release(staging);
         }
+
+        this.#staging_buffers.length = 0;
     }
 
     /**
@@ -844,19 +970,22 @@ export class ShadeGPUCommandContext {
 
          GPUCommandEncoder.finish() throws when the encoder is locked — any pass left un-end()ed
          anywhere in the frame graph — and queue.submit throws on a malformed argument. This used
-         to be a bare sequence, so either throw skipped #cleanup() and every buffer in
-         #transient_buffers and #staging_buffers stayed checked out of its allocator for good: one
-         staging buffer per writeBuffer call, which is most of the uniform traffic, every frame,
-         until the process ran out of GPU memory. onFinished never fired either, so a promise
-         already awaiting done never woke and profiling_absorbed hung with it — a recoverable
-         encoding bug turned into an unbounded leak plus a hung frame, with the original error
-         hidden behind the hang.
+         to be a bare sequence, so either throw skipped #cleanup() and every buffer the context held
+         stayed checked out of its allocator for good — then, a staging buffer per writeBuffer
+         call, which is most of the uniform traffic, every frame, until the process ran out of GPU
+         memory. onFinished never fired either, so a promise already awaiting done never woke and
+         profiling_absorbed hung with it — a recoverable encoding bug turned into an unbounded leak
+         plus a hung frame, with the original error hidden behind the hang.
 
          The error still propagates: it is the thing that names the misplaced end().
         */
         try {
             const command_buffer = encoder.finish();
 
+            // after finish(), so a command buffer that could not be made sends nothing, and
+            // immediately before the submit, which is what makes the blocks safe to hand back
+            this.#send_uploads(queue);
+
             queue.submit([command_buffer]);
         } finally {
             // cleanup allocated memory

package/src/shade/renderer/GraphicsContext.d.ts

@@ -64,10 +64,17 @@ export class GraphicsContext {
      */
     buffer_allocator_native: GPUBufferAllocatorNative;
     /**
-     * Used to upload data to the GPU
+     * Mapped `MAP_WRITE` buffers, one per upload: where a {@link ShadeGPUCommandContext} sends its
+     * large writes, for which a mapping is the faster road (see `MAPPED_UPLOAD_THRESHOLD`).
      * @type {GPUBufferStagingAllocator}
      */
     buffer_allocator_staging: GPUBufferStagingAllocator;
+    /**
+     * Upload blocks for {@link ShadeGPUCommandContext}'s small writes — every uniform a pass is
+     * handed by value among them. Sent with one queue write per block, not mapped.
+     * @type {GPUBufferUploadAllocator}
+     */
+    buffer_allocator_upload: GPUBufferUploadAllocator;
     /**
      * Used to read data back from the GPU: `MAP_READ` buffers, held by the CPU across frames, which
      * is why they cannot come from {@link buffer_allocator_main}.
@@ -142,6 +149,7 @@ import { BindGroupManager } from "./binding/BindGroupManager.js";
 import { GPUBufferAllocator } from "./buffer/GPUBufferAllocator.js";
 import { GPUBufferAllocatorNative } from "./buffer/GPUBufferAllocatorNative.js";
 import { GPUBufferStagingAllocator } from "./buffer/GPUBufferStagingAllocator.js";
+import { GPUBufferUploadAllocator } from "./buffer/GPUBufferUploadAllocator.js";
 import { GPUBufferReadbackAllocator } from "./buffer/GPUBufferReadbackAllocator.js";
 import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
 import { GPUBufferContext } from "./buffer/GPUBufferContext.js";

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAkCA;IA2JI,yBAgCC;IA1LD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;OAGG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAMC;IAED;;;OAGG;IACH,wBAEC;IAoCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAeC;IAED,4BAEC;IAED,eAyBC;IAED,gBAmBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAjWY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAZzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAehD,6BAA6B;sCACtB,4CAA4C;iCAdjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;2CADtC,wCAAwC;oCAQ/C,kCAAkC;iCATtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAmCA;IAoKI,yBAiCC;IApMD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAOC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAmDC;IAED,gBAoBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAvYY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAgBhD,6BAA6B;sCACtB,4CAA4C;iCAfjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAS/C,kCAAkC;iCAVtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -11,6 +11,7 @@ import { GPUBufferAllocatorNative } from "./buffer/GPUBufferAllocatorNative.js";
 import { create_buffer, GPUBufferContext } from "./buffer/GPUBufferContext.js";
 import { GPUBufferReadbackAllocator } from "./buffer/GPUBufferReadbackAllocator.js";
 import { GPUBufferStagingAllocator } from "./buffer/GPUBufferStagingAllocator.js";
+import { GPUBufferUploadAllocator } from "./buffer/GPUBufferUploadAllocator.js";
 import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUCollectionLimits } from "./rasterize/expand/GPUCollectionLimits.js";
 import { GPUSamplerManager } from "./GPUSamplerManager.js";
@@ -137,11 +138,19 @@ export class GraphicsContext {
     buffer_allocator_native;
 
     /**
-     * Used to upload data to the GPU
+     * Mapped `MAP_WRITE` buffers, one per upload: where a {@link ShadeGPUCommandContext} sends its
+     * large writes, for which a mapping is the faster road (see `MAPPED_UPLOAD_THRESHOLD`).
      * @type {GPUBufferStagingAllocator}
      */
     buffer_allocator_staging;
 
+    /**
+     * Upload blocks for {@link ShadeGPUCommandContext}'s small writes — every uniform a pass is
+     * handed by value among them. Sent with one queue write per block, not mapped.
+     * @type {GPUBufferUploadAllocator}
+     */
+    buffer_allocator_upload;
+
     /**
      * Used to read data back from the GPU: `MAP_READ` buffers, held by the CPU across frames, which
      * is why they cannot come from {@link buffer_allocator_main}.
@@ -174,8 +183,9 @@ export class GraphicsContext {
     increment_time() {
         this.#timer_increment++;
 
-        // advance the single frame clock for both substitutable pools in lockstep
+        // advance the single frame clock for the substitutable pools in lockstep
         this.buffer_allocator_main.increment_time();
+        this.buffer_allocator_upload.increment_time();
         this.allocator_textures.increment_time();
     }
 
@@ -197,6 +207,7 @@ export class GraphicsContext {
         this.buffer_allocator_main = new GPUBufferAllocator(device);
         this.buffer_allocator_native = new GPUBufferAllocatorNative(device);
         this.buffer_allocator_staging = new GPUBufferStagingAllocator(device);
+        this.buffer_allocator_upload = new GPUBufferUploadAllocator(device);
         this.buffer_allocator_readback = new GPUBufferReadbackAllocator(device);
 
         this.allocator_textures = new GPUTextureAllocator(device);
@@ -316,6 +327,7 @@ export class GraphicsContext {
 
         r += this.buffer_allocator_main.gpu_memory_usage;
         r += this.buffer_allocator_staging.gpu_memory_usage;
+        r += this.buffer_allocator_upload.gpu_memory_usage;
         r += this.buffer_allocator_readback.gpu_memory_usage;
 
         r += this.allocator_textures.gpu_memory_usage;
@@ -331,28 +343,54 @@ export class GraphicsContext {
     update() {
         const command_ctx = ShadeGPUCommandContext.create(this, 'GraphicsContext.update');
 
-        // The one place per frame the meshlet pool compacts, at the head of the frame: before the
-        // clone flush in geometries.update, before the VG runtime's flush, before any pass. Its
-        // per-frame bound is a bound because this is the only call (COMPACTION_PLAN_2026_09_16
-        // §4.5).
-        this.geometries.meshlets.sweep(command_ctx);
+        /**
+         * What the update raised, if anything. Held so the context is finished before it is
+         * re-raised: a context never finished keeps everything it took for good — an upload block,
+         * transient buffers — and a manager that throws every frame would leak that much every
+         * frame.
+         * @type {*}
+         */
+        let update_error = null;
+
+        try {
+            // The one place per frame the meshlet pool compacts, at the head of the frame: before the
+            // clone flush in geometries.update, before the VG runtime's flush, before any pass. Its
+            // per-frame bound is a bound because this is the only call (COMPACTION_PLAN_2026_09_16
+            // §4.5).
+            this.geometries.meshlets.sweep(command_ctx);
+
+            this.geometries.update(command_ctx);
 
-        this.geometries.update(command_ctx);
+            this.textures.update();
+            this.materials.update(command_ctx);
 
-        this.textures.update();
-        this.materials.update(command_ctx);
+            this.bind_groups.update();
 
-        this.bind_groups.update();
+            this.increment_time();
 
-        this.increment_time();
+            this.allocator_textures.update();
 
-        this.allocator_textures.update();
+            this.#collection_limits.update(command_ctx, this.buffer_allocator_main);
+        } catch (e) {
+            update_error = e;
+        }
 
-        this.#collection_limits.update(command_ctx, this.buffer_allocator_main);
+        try {
+            command_ctx.finish();
+        } catch (teardown_error) {
+            if (update_error === null) {
+                throw teardown_error;
+            }
 
-        command_ctx.finish();
+            // already unwinding: the update's own error is the one the caller needs to see
+        }
+
+        if (update_error !== null) {
+            throw update_error;
+        }
 
         this.buffer_allocator_main.update();
+        this.buffer_allocator_upload.update();
     }
 
     destroy() {
@@ -371,6 +409,7 @@ export class GraphicsContext {
         this.buffer_allocator_main.destroy();
         this.buffer_allocator_native.destroy();
         this.buffer_allocator_staging.destroy();
+        this.buffer_allocator_upload.destroy();
         this.buffer_allocator_readback.destroy();
 
         this.#collection_limits.destroy();

package/src/shade/renderer/Renderer.d.ts

@@ -210,7 +210,18 @@ export class Renderer {
      * @type {Signal<ShadeDeviceFailure>}
      */
     onDeviceFailure: any;
-    onFrameFinished: Signal;
+    /**
+     * Sent at the end of every frame {@link render} or {@link render_to_target} completes, with the
+     * number of frames completed so far. A frame that throws is not one of them: whatever it had
+     * recorded may still have been submitted, but it sends nothing and is not counted.
+     *
+     * **Submitted, not finished.** The frame's commands have been handed to the queue and the GPU
+     * may not have started them; a listener that needs the GPU to be done with the frame waits on
+     * {@link GPUQueue#onSubmittedWorkDone} instead.
+     *
+     * @type {Signal<number>}
+     */
+    onFrameFinished: any;
     /**
      *
      * @param {number} v
@@ -440,7 +451,9 @@ export class Renderer {
      * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
      * draws the current state and moves nothing; a fixed fraction of a second here instead would run
      * the simulation at that rate no matter what the caller's clock was doing.
-     * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
+     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
+     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
+     * yet neither hold this one back nor make it return false.
      */
     render(camera: PerspectiveCamera, scene: Scene, time_delta_seconds?: number): boolean;
     /**
@@ -457,11 +470,14 @@ export class Renderer {
      * @param {Scene} scene
      * @param {number} time_delta_seconds
      * @param {GPUTextureContext} target must match {@link output_resolution}
-     * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
+     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
+     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
+     * yet neither hold this one back nor make it return false.
      */
     render_to_target(camera: PerspectiveCamera, scene: Scene, time_delta_seconds: number, target: GPUTextureContext): boolean;
     #private;
 }
+export type GPUFrameRecorder = import("../device/timing/profile/GPUFrameRecorder.js").GPUFrameRecorder;
 export type GPUProfileSession = import("../device/timing/profile/GPUProfileSession.js").GPUProfileSession;
 export type PerspectiveCamera = import("./camera/PerspectiveCamera.js").PerspectiveCamera;
 export type RenderExtension = import("./extension/RenderExtension.js").RenderExtension;
@@ -477,7 +493,6 @@ import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
 import { ViewManager } from "./view/ViewManager.js";
 import { GraphicsContext } from "./GraphicsContext.js";
-import Signal from "../../core/events/signal/Signal.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
 import { FramePhase } from "./extension/FramePhase.js";

package/src/shade/renderer/Renderer.d.ts.map

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