@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/renderer/texture/encode/texture_encode_shader.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The compute shader that encodes into `format`.
+ *
+ * Refuses by name rather than approximating: a target this cannot write yet is named as such, and a
+ * format that was never a target is named as that. Nothing is encoded as a neighbour of what was
+ * asked for.
+ *
+ * @param {GPUTextureFormat} format
+ * @returns {ComputeShader}
+ * @throws {Error} naming the format, for one that is not implemented or not a target
+ */
+export function texture_encode_shader(format: GPUTextureFormat): ComputeShader;
+/**
+ * Whether the block encoder can write `format` today.
+ *
+ * @param {GPUTextureFormat} format
+ * @returns {boolean}
+ */
+export function texture_encode_implements(format: GPUTextureFormat): boolean;
+/**
+ * Every format the block encoder is meant to write, implemented or not.
+ *
+ * The list the refusal below reads, so that a target that is planned and a name that was never a
+ * target get different answers: one says "not yet", the other "not at all".
+ *
+ * @readonly
+ * @type {GPUTextureFormat[]}
+ */
+export const TEXTURE_ENCODE_TARGETS: GPUTextureFormat[];
+//# sourceMappingURL=texture_encode_shader.d.ts.map

package/src/shade/renderer/texture/encode/texture_encode_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture_encode_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/texture_encode_shader.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;GAUG;AACH,+EAqBC;AAED;;;;;GAKG;AACH,qEAFa,OAAO,CAInB;AAhGD;;;;;;;;GAQG;AACH,qCAFU,kBAAkB,CAkB1B"}

package/src/shade/renderer/texture/encode/texture_encode_shader.js

@@ -0,0 +1,108 @@
+import { gpu_texture_format_info } from "../../../descriptor/texture/format/gpu_texture_format_info.js";
+import { TextureFormat } from "../../../descriptor/texture/format/TextureFormat.js";
+import { shader_texture_encode_astc_4x4 } from "./shader_texture_encode_astc_4x4.js";
+import { shader_texture_encode_bc1 } from "./shader_texture_encode_bc1.js";
+import { shader_texture_encode_bc4 } from "./shader_texture_encode_bc4.js";
+import { shader_texture_encode_bc4_snorm } from "./shader_texture_encode_bc4_snorm.js";
+import { shader_texture_encode_bc5 } from "./shader_texture_encode_bc5.js";
+import { shader_texture_encode_bc5_snorm } from "./shader_texture_encode_bc5_snorm.js";
+import { shader_texture_encode_bc6h } from "./shader_texture_encode_bc6h.js";
+import { shader_texture_encode_bc7 } from "./shader_texture_encode_bc7.js";
+
+/**
+ * Every format the block encoder is meant to write, implemented or not.
+ *
+ * The list the refusal below reads, so that a target that is planned and a name that was never a
+ * target get different answers: one says "not yet", the other "not at all".
+ *
+ * @readonly
+ * @type {GPUTextureFormat[]}
+ */
+export const TEXTURE_ENCODE_TARGETS = [
+    TextureFormat.BC1_RGBA_UNORM,
+    TextureFormat.BC1_RGBA_UNORM_SRGB,
+    TextureFormat.BC4_R_UNORM,
+    TextureFormat.BC4_R_SNORM,
+    TextureFormat.BC5_RG_UNORM,
+    TextureFormat.BC5_RG_SNORM,
+    TextureFormat.BC6H_RGB_UFLOAT,
+    TextureFormat.BC7_RGBA_UNORM,
+    TextureFormat.BC7_RGBA_UNORM_SRGB,
+    TextureFormat.ASTC_4X4_UNORM,
+    TextureFormat.ASTC_4X4_UNORM_SRGB,
+    TextureFormat.ASTC_6X6_UNORM,
+    TextureFormat.ASTC_6X6_UNORM_SRGB,
+    TextureFormat.ASTC_8X8_UNORM,
+    TextureFormat.ASTC_8X8_UNORM_SRGB,
+];
+
+/**
+ * The encoder for each implemented target.
+ *
+ * **An `-srgb` format and its linear twin are one encoder**, listed twice rather than resolved by
+ * stripping the suffix: the two are the same encoded bytes and differ only in how the sampler
+ * decodes them, so the encoder does identical work and the caller's format is the tag the texture is
+ * created with. Listing both keeps the map the whole of the answer — nothing here strips a suffix
+ * and guesses. **A `snorm` format is not a tag**: its endpoints are signed and its palette runs over
+ * a different domain, so it is its own shader.
+ *
+ * @readonly
+ * @type {Map<GPUTextureFormat, ComputeShader>}
+ */
+const ENCODERS = new Map([
+    [TextureFormat.BC1_RGBA_UNORM, shader_texture_encode_bc1],
+    [TextureFormat.BC1_RGBA_UNORM_SRGB, shader_texture_encode_bc1],
+    [TextureFormat.BC4_R_UNORM, shader_texture_encode_bc4],
+    [TextureFormat.BC4_R_SNORM, shader_texture_encode_bc4_snorm],
+    [TextureFormat.BC5_RG_UNORM, shader_texture_encode_bc5],
+    [TextureFormat.BC5_RG_SNORM, shader_texture_encode_bc5_snorm],
+    [TextureFormat.BC6H_RGB_UFLOAT, shader_texture_encode_bc6h],
+    [TextureFormat.BC7_RGBA_UNORM, shader_texture_encode_bc7],
+    [TextureFormat.BC7_RGBA_UNORM_SRGB, shader_texture_encode_bc7],
+    [TextureFormat.ASTC_4X4_UNORM, shader_texture_encode_astc_4x4],
+    [TextureFormat.ASTC_4X4_UNORM_SRGB, shader_texture_encode_astc_4x4],
+]);
+
+/**
+ * The compute shader that encodes into `format`.
+ *
+ * Refuses by name rather than approximating: a target this cannot write yet is named as such, and a
+ * format that was never a target is named as that. Nothing is encoded as a neighbour of what was
+ * asked for.
+ *
+ * @param {GPUTextureFormat} format
+ * @returns {ComputeShader}
+ * @throws {Error} naming the format, for one that is not implemented or not a target
+ */
+export function texture_encode_shader(format) {
+    // throws for a name that is not a format at all, which is the first thing worth knowing
+    gpu_texture_format_info(format);
+
+    const shader = ENCODERS.get(format);
+
+    if (shader !== undefined) {
+        return shader;
+    }
+
+    if (TEXTURE_ENCODE_TARGETS.includes(format)) {
+        throw new Error(
+            `texture_encode: '${format}' is a planned target of the block encoder and is not implemented yet.`
+            + ` Nothing approximates it; the implemented targets are ${[...ENCODERS.keys()].join(', ')}`
+        );
+    }
+
+    throw new Error(
+        `texture_encode: '${format}' is not a target of the block encoder.`
+        + ` The targets are ${TEXTURE_ENCODE_TARGETS.join(', ')}`
+    );
+}
+
+/**
+ * Whether the block encoder can write `format` today.
+ *
+ * @param {GPUTextureFormat} format
+ * @returns {boolean}
+ */
+export function texture_encode_implements(format) {
+    return ENCODERS.has(format);
+}

package/src/shade/renderer/texture/format/gpu_texture_compression_support.d.ts

@@ -3,7 +3,9 @@
  *
  * WebGPU gates compression behind three optional features, all of them all-or-nothing within their
  * family. This turns "which features did we get" into "which formats may we ask the network for",
- * which is the question the asset layer actually has (§5).
+ * which is the question the asset layer actually has (§5). Which family a format belongs to is
+ * {@link gpu_texture_format_feature}'s answer, derived from the format table's own names — the same
+ * answer the software device refuses a texture by.
  *
  * Empty is an ordinary answer, not a failure: a device with no compression support loads every scene
  * through the uncompressed encoding, exactly as one did before any of this existed.

package/src/shade/renderer/texture/format/gpu_texture_compression_support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu_texture_compression_support.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/gpu_texture_compression_support.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;GAYG;AACH,oEAFa,qBAAqB,CAoBjC"}
+{"version":3,"file":"gpu_texture_compression_support.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/gpu_texture_compression_support.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,oEAFa,qBAAqB,CAgBjC"}

package/src/shade/renderer/texture/format/gpu_texture_compression_support.js

@@ -1,27 +1,14 @@
-import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
+import { gpu_texture_format_feature } from "../../../descriptor/texture/format/gpu_texture_format_feature.js";
 import { gpu_texture_format_names } from "../../../descriptor/texture/format/gpu_texture_format_info.js";
 
-/**
- * Which compressed formats a feature name brings with it.
- *
- * Derived from the format table's own names rather than listed, because the three families partition
- * it cleanly by prefix and a hand-written list is one more thing to forget a format from.
- *
- * @type {[GPUFeatureName, RegExp][]}
- */
-const FAMILIES = [
-    [WebGPUExtensionType.TextureCompressionBC, /^bc[0-9]/],
-    // ETC2 and EAC arrive together, under one feature
-    [WebGPUExtensionType.TextureCompressionETC2, /^(etc2|eac)-/],
-    [WebGPUExtensionType.TextureCompressionASTC, /^astc-/],
-];
-
 /**
  * Every compressed {@link GPUTextureFormat} this device can sample.
  *
  * WebGPU gates compression behind three optional features, all of them all-or-nothing within their
  * family. This turns "which features did we get" into "which formats may we ask the network for",
- * which is the question the asset layer actually has (§5).
+ * which is the question the asset layer actually has (§5). Which family a format belongs to is
+ * {@link gpu_texture_format_feature}'s answer, derived from the format table's own names — the same
+ * answer the software device refuses a texture by.
  *
  * Empty is an ordinary answer, not a failure: a device with no compression support loads every scene
  * through the uncompressed encoding, exactly as one did before any of this existed.
@@ -34,15 +21,11 @@ export function gpu_texture_compression_support(device) {
 
     const supported = new Set();
 
-    for (const [feature, pattern] of FAMILIES) {
-        if (!features.has(feature)) {
-            continue;
-        }
+    for (const format of gpu_texture_format_names()) {
+        const feature = gpu_texture_format_feature(format);
 
-        for (const format of gpu_texture_format_names()) {
-            if (pattern.test(format)) {
-                supported.add(format);
-            }
+        if (feature !== undefined && features.has(feature)) {
+            supported.add(format);
         }
     }
 

package/src/shade/renderer/texture/format/texture_format_from_shade_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_format_from_shade_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/texture_format_from_shade_image.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qFA2CC"}
+{"version":3,"file":"texture_format_from_shade_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/texture_format_from_shade_image.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qFAkEC"}

package/src/shade/renderer/texture/format/texture_format_from_shade_image.js

@@ -1,5 +1,6 @@
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { isImageBitmap } from "../../../../core/dom/isImageBitmap.js";
+import { gpu_texture_format_srgb } from "../../../descriptor/texture/format/gpu_texture_format_srgb.js";
 import { ColorSpace } from "../ColorSpace.js";
 import { infer_format_from_parameters } from "./infer_format_from_parameters.js";
 
@@ -33,8 +34,31 @@ export function texture_format_from_shade_image(image) {
     }
 
     if (source.isShadeTexelData === true) {
-        // already in a GPU format; it says which
-        return source.format;
+        /*
+         Already in a GPU format; it says which — but not whether sampling it decodes sRGB, which is
+         the image's business and not the payload's. `bc7-rgba-unorm` and `bc7-rgba-unorm-srgb` are
+         the same bytes, so a transcoder targeting one does exactly the work of the other and has no
+         reason to prefer either; what settles it is what the texture *means*, which is `color_space`
+         and is assigned after construction. Returning the payload's name verbatim ignored that and
+         put all 25 of Sponza's albedo maps on a linear format, sampling sRGB-encoded values as
+         though they were linear — brighter, flatter, and cold, because the decode that stretches
+         the gap between channels was the part being skipped.
+        */
+        if (image.color_space !== ColorSpace.SRGB) {
+            return source.format;
+        }
+
+        const srgb = gpu_texture_format_srgb(source.format);
+
+        if (srgb === undefined) {
+            throw new Error(
+                `image ${image.id} is sRGB but its payload is '${source.format}', which has no sRGB`
+                + ` counterpart, so the decode cannot be expressed. Transcode it to a format that`
+                + ` has one, or set color_space to something other than SRGB.`
+            );
+        }
+
+        return srgb;
     }
 
     if (source.isSampler2D === true) {

package/src/shade/renderer/texture/source/texel_data_from_ktx2.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Read a KTX2 file into the texel payload the engine uploads.
+ *
+ * The engine's door to {@link ktx2_read}. The reader answers to the file — what format its levels
+ * are in, and that each is the size that format implies — and returns a plain {@link TexelPayload};
+ * this is where that record becomes a {@link ShadeTexelData}, and where the engine's own constraints
+ * on it are applied. Two are worth naming, and both are refusals of well-formed files that the reader
+ * therefore does not make:
+ *
+ * - **A payload is one level or the whole chain.** Two levels of a four-level pyramid is a legal KTX2
+ *   file, but the mip generator cannot start from level 2 and "how many levels does this texture
+ *   have" would have two answers. `ShadeTexelData` refuses it.
+ * - **A payload is one image.** The reader returns array textures and cube maps with their layers
+ *   and faces packed into each level; `ShadeTexelData` reads its third extent as a volume that halves
+ *   per level, so it has nowhere to put a layer. Refused here, by name, until the engine type grows
+ *   one — at which point this is the only place that changes.
+ *
+ * Beside the type it produces rather than beside the format it reads, because it changes when
+ * `ShadeTexelData` does and not when the KTX2 specification does.
+ *
+ * @param {ArrayBuffer|Uint8Array} bytes the whole file
+ * @param {TextureFormat|TextureFormat[]} [transcode_target] what a Basis payload should become — see
+ * {@link ktx2_read}, which owns the rules
+ * @returns {ShadeTexelData}
+ * @throws {Error} everything {@link ktx2_read} throws, a partial mip chain, and an array or cube map
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function texel_data_from_ktx2(bytes: ArrayBuffer | Uint8Array, transcode_target?: TextureFormat | TextureFormat[]): ShadeTexelData;
+import { ShadeTexelData } from "./ShadeTexelData.js";
+//# sourceMappingURL=texel_data_from_ktx2.d.ts.map

package/src/shade/renderer/texture/source/texel_data_from_ktx2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texel_data_from_ktx2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/source/texel_data_from_ktx2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4CATW,WAAW,GAAC,UAAU,qBACtB,gBAAc,eAAe,GAE3B,cAAc,CAqB1B;+BA9C8B,qBAAqB"}

package/src/shade/renderer/texture/source/texel_data_from_ktx2.js

@@ -0,0 +1,48 @@
+import { ktx2_read } from "../../../../format/texture/ktx2/ktx2_read.js";
+import { ShadeTexelData } from "./ShadeTexelData.js";
+
+/**
+ * Read a KTX2 file into the texel payload the engine uploads.
+ *
+ * The engine's door to {@link ktx2_read}. The reader answers to the file — what format its levels
+ * are in, and that each is the size that format implies — and returns a plain {@link TexelPayload};
+ * this is where that record becomes a {@link ShadeTexelData}, and where the engine's own constraints
+ * on it are applied. Two are worth naming, and both are refusals of well-formed files that the reader
+ * therefore does not make:
+ *
+ * - **A payload is one level or the whole chain.** Two levels of a four-level pyramid is a legal KTX2
+ *   file, but the mip generator cannot start from level 2 and "how many levels does this texture
+ *   have" would have two answers. `ShadeTexelData` refuses it.
+ * - **A payload is one image.** The reader returns array textures and cube maps with their layers
+ *   and faces packed into each level; `ShadeTexelData` reads its third extent as a volume that halves
+ *   per level, so it has nowhere to put a layer. Refused here, by name, until the engine type grows
+ *   one — at which point this is the only place that changes.
+ *
+ * Beside the type it produces rather than beside the format it reads, because it changes when
+ * `ShadeTexelData` does and not when the KTX2 specification does.
+ *
+ * @param {ArrayBuffer|Uint8Array} bytes the whole file
+ * @param {TextureFormat|TextureFormat[]} [transcode_target] what a Basis payload should become — see
+ * {@link ktx2_read}, which owns the rules
+ * @returns {ShadeTexelData}
+ * @throws {Error} everything {@link ktx2_read} throws, a partial mip chain, and an array or cube map
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function texel_data_from_ktx2(bytes, transcode_target = undefined) {
+    const payload = ktx2_read(bytes, transcode_target);
+
+    if (payload.layers > 1 || payload.faces > 1) {
+        throw new Error(
+            `KTX2: the file is ${payload.faces > 1 ? "a cube map" : `an array of ${payload.layers} layers`},`
+            + ` and ShadeTexelData models a single 2D or 3D image — its depth is a volume that halves`
+            + ` per level, so a layer has nowhere to go. The reader returned them; the engine cannot`
+            + ` take them yet.`
+        );
+    }
+
+    return new ShadeTexelData(
+        payload.format, payload.width, payload.height, payload.depth, payload.levels
+    );
+}

package/src/shade/renderer/texture/texture_write_level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_write_level.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/texture_write_level.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iFAJW,MAAM,SACN,YAAY,GACV,IAAI,CAwChB"}
+{"version":3,"file":"texture_write_level.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/texture_write_level.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iFAJW,MAAM,SACN,YAAY,GACV,IAAI,CAiDhB"}

package/src/shade/renderer/texture/texture_write_level.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import {
     gpu_texture_format_level_bytes,
+    gpu_texture_format_physical_size,
     gpu_texture_format_row_bytes,
     gpu_texture_format_row_count
 } from "../../descriptor/texture/format/gpu_texture_format_info.js";
@@ -59,6 +60,15 @@ export function texture_write_level(queue, texture, level, bytes) {
         `byte length for level ${level} of a ${extent.join('x')} '${format}' texture`
     );
 
+    /*
+     The copy is sized in whole blocks. A block format's 2x2 and 1x1 tail levels are each one block,
+     and the device refuses a copy whose extent is not a multiple of the block — so the extent
+     written is the level's physical size, which for a 1x1-block format is the same thing. Found on
+     hardware: every BC chain's tail had been refused with `copySize.width (2) is not a multiple of
+     compressed texture format block width (4)`, silently, since validation errors do not throw.
+    */
+    const physical = gpu_texture_format_physical_size(format, extent[0], extent[1]);
+
     queue.writeTexture(
         {
             texture,
@@ -72,6 +82,6 @@ export function texture_write_level(queue, texture, level, bytes) {
             // required once the copy is more than one layer deep, and harmless before that
             rowsPerImage: rows_per_image,
         },
-        extent
+        [physical[0], physical[1], extent[2]]
     );
 }

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AA4BA;IAyHI;;;;OAIG;IACH,qDAqBC;IA/GD;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IA6BD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IAiND;;;;;;;OAOG;IACH;;;MAyEC;;CAEJ"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AA4BA;IAkII;;;;OAIG;IACH,qDAqBC;IAxHD;;OAEG;IACH,8BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,4BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA4ND;;;;;;;OAOG;IACH;;;MAyEC;;CAEJ"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -82,6 +82,15 @@ export class GPUViewVolumetrics {
      */
     #froxel_far = Infinity;
 
+    /**
+     * The froxel depth curve uploaded last frame. The TAA history is addressed on the curve it was
+     * accumulated with, so when the curve changes the history is wrong at every slice and must be
+     * dropped. Comparing the built parameters catches every input to the curve at once -- camera
+     * near, camera far, the froxel-far override -- rather than watching each separately.
+     * @type {Float32Array}
+     */
+    #froxel_curve_previous = new Float32Array(3);
+
     /**
      * @returns {number}
      */
@@ -368,6 +377,17 @@ export class GPUViewVolumetrics {
             froxel_depth_scale
         );
 
+        // Recomputed deterministically, so a steady camera compares bitwise equal and never resets.
+        {
+            const curve = volumetrics_froxel_cluster_parameters;
+            const previous = this.#froxel_curve_previous;
+
+            if (curve[0] !== previous[0] || curve[1] !== previous[1] || curve[2] !== previous[2]) {
+                previous.set(curve);
+                this.#reset_history = true;
+            }
+        }
+
         // The projection is infinite-far reverse-Z, so the camera frustum's far plane is zeroed and
         // can't be sliced into froxel slabs. Rebuild a finite far plane at the logical far for the
         // participating-media coverage test — exactly as the light-cluster assignment does.

package/src/shade/renderer/volumetrics/NOTES.md

@@ -927,3 +927,31 @@ which is what supplies each transformed plane's distance term, and
 `transpose` was missing from the WGSL emulator's language core, which is why `frustum_transform_m4`
 had never been exercised there; it is implemented now for the square matrix sizes, on the same
 footing as `determinant`.
+
+## Volumetric TAA review — 2026-09-02
+
+`taa/shader_volumetrics_taa.js`, reviewed for correctness. Each finding is its own commit, pinned
+by a spec that was red against the old code except where noted. The reprojection and the resolve
+were lifted into pure chunks first so the emulator could execute them.
+
+| item | finding | pin |
+|---|---|---|
+| history fetch | the 3x3x3 Blackman-Harris resample weighted the ±1 neighbours 8.4% each even at a zero offset, so every frame blurred the accumulation and the 0.95 feedback compounded it to ~1.8 froxels of sigma per axis, Z included. Now trilinear through the same sampler the lighting pass uses. | none, by request; validity gate |
+| reprojection | went through the previous camera's jittered VP while the reconstruction used the un-jittered CPU frustum, so a static camera missed its own texel by last frame's jitter. Now the projection diagonal on view-space xy. | a jittered previous camera must round-trip a static froxel exactly |
+| validity | a froxel behind the previous camera has negative w, the divide mirrors NDC back into frame, and the uv check passed. Now depth > 0 as well. | camera backing up past a near froxel |
+| box | the variance band excluded the centre sample whenever gamma < 1, breaking the clip's precondition; both failure paths output the raw sample. Now unioned with the centre. | 26 dark neighbours, a bright centre, the motion-end gamma |
+| resolve | damped the HISTORY to zero on clip, Karis's rule backwards: every clipped voxel output the raw 1-spp sample. Now a fixed 0.95 feedback with the incoming weight damped toward a quarter as the clamp distance reaches one. | impulse moves the resolve by ≤ W_CURRENT·Δ; clipped history kept; wall pull ≤ wide pull |
+| host | camera near/far changes rebuilt the froxel curve without a history reset. Now any change to the built curve resets. | software device, host-written `history_reset` across frames |
+
+Observed, not fixed:
+
+* The last slice (63) does not round-trip to its own texel centre. Its centre depth on the curve
+  exceeds the logical far, the reconstruction clamps it to far, and far maps back to slice 63.0
+  rather than 63.5, so trilinear reads a 50/50 of slices 62 and 63 even when static. The lighting
+  pass truncates that slab at far as well, so its stored content is not centred at 63.5 either.
+  The reprojection spec excludes the last slice from the exact round trip.
+* Box collapse. When all 27 neighbourhood samples miss a thin feature the spatial variance is
+  exactly zero, the box has zero width, and the clip erases everything the history accumulated;
+  it then climbs at 5% a frame and never reaches the mean — about a third of it at 10% coverage.
+  The damping does not touch this either way. It needs a box that knows temporal variance or a
+  width floor, and there is no drop-in for that with high confidence.

package/src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_volumetric_history_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAFY,SAAS,CAwEnB;0BA7EwB,oCAAoC"}
+{"version":3,"file":"chunk_volumetric_history_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAFY,SAAS,CA6EnB;0BAlFwB,oCAAoC"}

package/src/shade/renderer/volumetrics/taa/chunk_volumetric_history_bounding_box.js

@@ -69,8 +69,13 @@ fn volumetric_history_bounding_box(
     
     let std_dev = get_std_dev4(mean, avg_sq) * variance_gamma;
 
-    *out_min = mean - std_dev;
-    *out_max = mean + std_dev;
+    // The box must contain the centre sample: color_clip_to_aabb4 walks from the history toward
+    // it and stops at the box, which is only a clip if the target is inside. The variance band
+    // alone does not guarantee that -- with gamma below 1, one bright 1-spp sample among 26 dark
+    // neighbours sits several sigma above the mean -- and a box that excludes its own target
+    // hands the clip either the raw sample or a wall the damping reads as a full clamp.
+    *out_min = min(mean - std_dev, center_sample);
+    *out_max = max(mean + std_dev, center_sample);
 }
     `,
     [

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where this frame's froxel was in last frame's froxel grid, for the volumetric TAA.
+ *
+ * Reconstructs the froxel centre in world space through the current camera's metadata frustum,
+ * then projects it through the previous camera. Returns `(prev_uvw, prev_depth)`: the first three
+ * are the history texture coordinate, the last is planar view depth in the previous camera, which
+ * `volumetrics_taa_history_valid` needs because a point behind that camera still projects to a uv
+ * in range -- the divide by a negative `w` mirrors it into the frame.
+ *
+ * A pure function of its arguments so `chunk_volumetrics_taa_reproject.spec.js` can drive it in
+ * the WGSL emulator against geometry-derived expectations; it was inline in the TAA body before.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_taa_reproject: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_volumetrics_taa_reproject.d.ts.map

package/src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_taa_reproject.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/taa/chunk_volumetrics_taa_reproject.js"],"names":[],"mappings":"AAuFA;;;;;;;;;;;;;GAaG;AACH,8CAFU,SAAS,CAoEjB;0BAjKwB,oCAAoC"}