@aura3d/rendering 3.0.1 → 4.0.0

package/dist/post/shaders/common.wgsl.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PRD-03 Phase 7 — WGSL twin of `common.glsl.ts`.
+ *
+ * `linearizeDepth` is the §6.11 shared formula (view-space metres).
+ * `triangularDither(fragCoord, frame)` is the §1096 dither: a PCG2D integer
+ * hash produces two uniform samples whose sum minus 1 gives the triangular
+ * distribution, scaled by 1/255 — ±1 LSB of the 8-bit output, applied at the
+ * last write (S12).
+ *
+ * Every `post/shaders/*.wgsl.ts` module is a fragment-only WGSL module: the
+ * shared fullscreen-triangle vertex is `WEBGPU_POST_VERTEX_WGSL`
+ * (`webgpu/WebGPUPostShaders.ts`). Binding convention for all mirrors:
+ *   @group(0) @binding(0)  var<uniform>  parameter block (GLSL scalar/vec/mat
+ *                          uniforms in declaration order; GLSL bool/int/uint
+ *                          uniforms become i32/u32 — bool is not
+ *                          host-shareable in WGSL uniform address space)
+ *   @group(0) @binding(N)  var *_tex     textures in GLSL sampler order
+ *   @group(0) @binding(M)  var *_smp     one sampler per texture sampled with
+ *                          `textureSampleLevel`; texelFetch-only textures
+ *                          (textureLoad) declare no sampler
+ * Execution wiring is lane 11's (Q-11-2); these strings are validated for
+ * zero `getCompilationInfo()` errors in `tests/qr/prd03/wgsl-compile.spec.ts`.
+ */
+export declare const POST_COMMON_WGSL = "\nfn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {\n  let z = d * 2.0 - 1.0;\n  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);\n}\n\nfn pcg2d(v_in: vec2<u32>) -> vec2<u32> {\n  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);\n  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n";
+//# sourceMappingURL=common.wgsl.d.ts.map

package/dist/post/shaders/common.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/common.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,eAAO,MAAM,gBAAgB,0zBAuB5B,CAAC"}

package/dist/post/shaders/common.wgsl.js

@@ -0,0 +1,48 @@
+/**
+ * PRD-03 Phase 7 — WGSL twin of `common.glsl.ts`.
+ *
+ * `linearizeDepth` is the §6.11 shared formula (view-space metres).
+ * `triangularDither(fragCoord, frame)` is the §1096 dither: a PCG2D integer
+ * hash produces two uniform samples whose sum minus 1 gives the triangular
+ * distribution, scaled by 1/255 — ±1 LSB of the 8-bit output, applied at the
+ * last write (S12).
+ *
+ * Every `post/shaders/*.wgsl.ts` module is a fragment-only WGSL module: the
+ * shared fullscreen-triangle vertex is `WEBGPU_POST_VERTEX_WGSL`
+ * (`webgpu/WebGPUPostShaders.ts`). Binding convention for all mirrors:
+ *   @group(0) @binding(0)  var<uniform>  parameter block (GLSL scalar/vec/mat
+ *                          uniforms in declaration order; GLSL bool/int/uint
+ *                          uniforms become i32/u32 — bool is not
+ *                          host-shareable in WGSL uniform address space)
+ *   @group(0) @binding(N)  var *_tex     textures in GLSL sampler order
+ *   @group(0) @binding(M)  var *_smp     one sampler per texture sampled with
+ *                          `textureSampleLevel`; texelFetch-only textures
+ *                          (textureLoad) declare no sampler
+ * Execution wiring is lane 11's (Q-11-2); these strings are validated for
+ * zero `getCompilationInfo()` errors in `tests/qr/prd03/wgsl-compile.spec.ts`.
+ */
+export const POST_COMMON_WGSL = /* wgsl */ `
+fn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {
+  let z = d * 2.0 - 1.0;
+  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);
+}
+
+fn pcg2d(v_in: vec2<u32>) -> vec2<u32> {
+  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);
+  v.x = v.x + v.y * 1664525u;
+  v.y = v.y + v.x * 1664525u;
+  v = v ^ (v >> vec2<u32>(16u));
+  v.x = v.x + v.y * 1664525u;
+  v.y = v.y + v.x * 1664525u;
+  v = v ^ (v >> vec2<u32>(16u));
+  return v;
+}
+
+// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 → ±1 LSB of 8-bit output.
+fn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {
+  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);
+  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;
+  return (rand.x + rand.y - 1.0) / 255.0;
+}
+`;
+//# sourceMappingURL=common.wgsl.js.map

package/dist/post/shaders/common.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/common.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuB1C,CAAC"}

package/dist/post/shaders/composite.glsl.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PRD-03 §6.1 S10 / §8.12 — the linear-HDR composite.
+ *
+ * One pass over the exposed HDR frame before C-05 `OutputPass`:
+ *   c = texture(u_hdr, uv) * u_exposure * u_autoExposure
+ *   + chromatic aberration (3-tap, radial `|uv-0.5|²` profile)
+ *   + bloom · u_bloomIntensity
+ *   + linear grade: Bradford white balance → lift/gamma/gain →
+ *     shadows/midtones/highlights weights (1−s)², 2s(1−s), s² with
+ *     s = saturate(log2(luma/0.18)/8 + 0.5)
+ *
+ * Output stays RGBA16F; the single tone-map + sRGB encode happens in the
+ * OutputPass boundary (`createLegacyOutputPass`), which receives
+ * `exposure: 1` because exposure is already applied here.
+ */
+export declare const COMPOSITE_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_hdr;\nuniform sampler2D u_bloom;\nuniform float u_exposure;\nuniform float u_autoExposure;\nuniform float u_bloomIntensity;\nuniform float u_caIntensity;\nuniform vec3 u_whiteBalance;      // Bradford-cone LMS gain, resolved per temperature/tint\nuniform vec3 u_lift;\nuniform vec3 u_gamma;\nuniform vec3 u_gain;\nuniform vec3 u_shadows;\nuniform vec3 u_midtones;\nuniform vec3 u_highlights;\nuniform int u_hasBloom;\nin vec2 v_uv;\nout vec4 outColor;\n\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvoid main() {\n  vec2 centre = v_uv - 0.5;\n  vec2 dir = centre * dot(centre, centre) * u_caIntensity;\n  vec3 c;\n  if (u_caIntensity != 0.0) {\n    c = vec3(\n      texture(u_hdr, v_uv - dir).r,\n      texture(u_hdr, v_uv).g,\n      texture(u_hdr, v_uv + dir).b);\n  } else {\n    c = texture(u_hdr, v_uv).rgb;\n  }\n  c *= u_exposure * u_autoExposure;\n  if (u_hasBloom != 0) {\n    c += texture(u_bloom, v_uv).rgb * u_bloomIntensity;\n  }\n\n  // Linear grade \u2014 Bradford CAT already folded into u_whiteBalance on CPU.\n  c *= u_whiteBalance;\n  // lift / gamma / gain (ASC-CDL style), per channel.\n  vec3 safeGamma = max(u_gamma, vec3(1e-3));\n  c = pow(max(c * u_gain + u_lift, vec3(0.0)), vec3(1.0) / safeGamma);\n  // Shadows/midtones/highlights from the luma pivot at 0.18.\n  float s = clamp(log2(max(luma(c), 1e-6) / 0.18) / 8.0 + 0.5, 0.0, 1.0);\n  c *= u_shadows * (1.0 - s) * (1.0 - s)\n     + u_midtones * 2.0 * s * (1.0 - s)\n     + u_highlights * s * s;\n\n  outColor = vec4(c, texture(u_hdr, v_uv).a);\n}\n";
+/**
+ * Transitional standalone CA pass (Phase 3): the §8.12 radial 3-tap,
+ * `uv ± dir·intensity` with `dir = centre·|centre|²·u_caIntensity`, executed
+ * on the HDR target while S10 composite keeps its own copy for the final
+ * chain. Same formula — when S10 runs real, this program goes away and the
+ * composite's `u_caIntensity` carries it.
+ */
+export declare const CA_PASS_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_hdr;\nuniform float u_caIntensity;\nin vec2 v_uv;\nout vec4 outColor;\n\nvoid main() {\n  vec2 centre = v_uv - 0.5;\n  vec2 dir = centre * dot(centre, centre) * u_caIntensity;\n  if (u_caIntensity != 0.0) {\n    outColor = vec4(\n      texture(u_hdr, v_uv - dir).r,\n      texture(u_hdr, v_uv).g,\n      texture(u_hdr, v_uv + dir).b,\n      texture(u_hdr, v_uv).a);\n  } else {\n    outColor = texture(u_hdr, v_uv);\n  }\n}\n";
+//# sourceMappingURL=composite.glsl.d.ts.map

package/dist/post/shaders/composite.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/composite.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,cAAc,qlDAmD1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,2eAoBxB,CAAC"}

package/dist/post/shaders/composite.glsl.js

@@ -0,0 +1,96 @@
+/**
+ * PRD-03 §6.1 S10 / §8.12 — the linear-HDR composite.
+ *
+ * One pass over the exposed HDR frame before C-05 `OutputPass`:
+ *   c = texture(u_hdr, uv) * u_exposure * u_autoExposure
+ *   + chromatic aberration (3-tap, radial `|uv-0.5|²` profile)
+ *   + bloom · u_bloomIntensity
+ *   + linear grade: Bradford white balance → lift/gamma/gain →
+ *     shadows/midtones/highlights weights (1−s)², 2s(1−s), s² with
+ *     s = saturate(log2(luma/0.18)/8 + 0.5)
+ *
+ * Output stays RGBA16F; the single tone-map + sRGB encode happens in the
+ * OutputPass boundary (`createLegacyOutputPass`), which receives
+ * `exposure: 1` because exposure is already applied here.
+ */
+export const COMPOSITE_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_hdr;
+uniform sampler2D u_bloom;
+uniform float u_exposure;
+uniform float u_autoExposure;
+uniform float u_bloomIntensity;
+uniform float u_caIntensity;
+uniform vec3 u_whiteBalance;      // Bradford-cone LMS gain, resolved per temperature/tint
+uniform vec3 u_lift;
+uniform vec3 u_gamma;
+uniform vec3 u_gain;
+uniform vec3 u_shadows;
+uniform vec3 u_midtones;
+uniform vec3 u_highlights;
+uniform int u_hasBloom;
+in vec2 v_uv;
+out vec4 outColor;
+
+float luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+void main() {
+  vec2 centre = v_uv - 0.5;
+  vec2 dir = centre * dot(centre, centre) * u_caIntensity;
+  vec3 c;
+  if (u_caIntensity != 0.0) {
+    c = vec3(
+      texture(u_hdr, v_uv - dir).r,
+      texture(u_hdr, v_uv).g,
+      texture(u_hdr, v_uv + dir).b);
+  } else {
+    c = texture(u_hdr, v_uv).rgb;
+  }
+  c *= u_exposure * u_autoExposure;
+  if (u_hasBloom != 0) {
+    c += texture(u_bloom, v_uv).rgb * u_bloomIntensity;
+  }
+
+  // Linear grade — Bradford CAT already folded into u_whiteBalance on CPU.
+  c *= u_whiteBalance;
+  // lift / gamma / gain (ASC-CDL style), per channel.
+  vec3 safeGamma = max(u_gamma, vec3(1e-3));
+  c = pow(max(c * u_gain + u_lift, vec3(0.0)), vec3(1.0) / safeGamma);
+  // Shadows/midtones/highlights from the luma pivot at 0.18.
+  float s = clamp(log2(max(luma(c), 1e-6) / 0.18) / 8.0 + 0.5, 0.0, 1.0);
+  c *= u_shadows * (1.0 - s) * (1.0 - s)
+     + u_midtones * 2.0 * s * (1.0 - s)
+     + u_highlights * s * s;
+
+  outColor = vec4(c, texture(u_hdr, v_uv).a);
+}
+`;
+/**
+ * Transitional standalone CA pass (Phase 3): the §8.12 radial 3-tap,
+ * `uv ± dir·intensity` with `dir = centre·|centre|²·u_caIntensity`, executed
+ * on the HDR target while S10 composite keeps its own copy for the final
+ * chain. Same formula — when S10 runs real, this program goes away and the
+ * composite's `u_caIntensity` carries it.
+ */
+export const CA_PASS_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_hdr;
+uniform float u_caIntensity;
+in vec2 v_uv;
+out vec4 outColor;
+
+void main() {
+  vec2 centre = v_uv - 0.5;
+  vec2 dir = centre * dot(centre, centre) * u_caIntensity;
+  if (u_caIntensity != 0.0) {
+    outColor = vec4(
+      texture(u_hdr, v_uv - dir).r,
+      texture(u_hdr, v_uv).g,
+      texture(u_hdr, v_uv + dir).b,
+      texture(u_hdr, v_uv).a);
+  } else {
+    outColor = texture(u_hdr, v_uv);
+  }
+}
+`;
+//# sourceMappingURL=composite.glsl.js.map

package/dist/post/shaders/composite.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/composite.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDxC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBtC,CAAC"}

package/dist/post/shaders/composite.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PRD-03 §6.1 S10 / §8.12 Phase 7 — linear-HDR composite WGSL twins.
+ * `c = hdr * exposure * autoExposure` + radial chromatic aberration + bloom
+ * + linear grade (Bradford white balance → lift/gamma/gain →
+ * shadows/midtones/highlights weights). CA_PASS is the transitional
+ * standalone §8.12 radial 3-tap.
+ */
+export declare const COMPOSITE_WGSL = "struct CompositeParams {\n  exposure: f32,\n  auto_exposure: f32,\n  bloom_intensity: f32,\n  ca_intensity: f32,\n  white_balance: vec3<f32>,  // Bradford-cone LMS gain, resolved per temperature/tint\n  has_bloom: i32,\n  lift: vec3<f32>,\n  _pad0: f32,\n  gamma: vec3<f32>,\n  _pad1: f32,\n  gain: vec3<f32>,\n  _pad2: f32,\n  shadows: vec3<f32>,\n  _pad3: f32,\n  midtones: vec3<f32>,\n  _pad4: f32,\n  highlights: vec3<f32>,\n  _pad5: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: CompositeParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_hdr_smp: sampler;\n@group(0) @binding(3) var u_bloom_tex: texture_2d<f32>;\n@group(0) @binding(4) var u_bloom_smp: sampler;\n\nfn composite_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\n@fragment\nfn fs_composite(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let centre = uv - vec2<f32>(0.5);\n  let dir = centre * dot(centre, centre) * u_params.ca_intensity;\n  var c: vec3<f32>;\n  if (u_params.ca_intensity != 0.0) {\n    c = vec3<f32>(\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv - dir, 0.0).r,\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).g,\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + dir, 0.0).b);\n  } else {\n    c = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).rgb;\n  }\n  c = c * u_params.exposure * u_params.auto_exposure;\n  if (u_params.has_bloom != 0) {\n    c = c + textureSampleLevel(u_bloom_tex, u_bloom_smp, uv, 0.0).rgb * u_params.bloom_intensity;\n  }\n\n  // Linear grade \u2014 Bradford CAT already folded into u_whiteBalance on CPU.\n  c = c * u_params.white_balance;\n  // lift / gamma / gain (ASC-CDL style), per channel.\n  let safe_gamma = max(u_params.gamma, vec3<f32>(1e-3));\n  c = pow(max(c * u_params.gain + u_params.lift, vec3<f32>(0.0)), vec3<f32>(1.0) / safe_gamma);\n  // Shadows/midtones/highlights from the luma pivot at 0.18.\n  let s = clamp(log2(max(composite_luma(c), 1e-6) / 0.18) / 8.0 + 0.5, 0.0, 1.0);\n  c = c * (u_params.shadows * (1.0 - s) * (1.0 - s)\n    + u_params.midtones * 2.0 * s * (1.0 - s)\n    + u_params.highlights * s * s);\n\n  return vec4<f32>(c, textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).a);\n}\n";
+export declare const CA_PASS_WGSL = "struct CaPassParams {\n  ca_intensity: f32,\n  _pad: vec3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: CaPassParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_hdr_smp: sampler;\n\n@fragment\nfn fs_ca_pass(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let centre = uv - vec2<f32>(0.5);\n  let dir = centre * dot(centre, centre) * u_params.ca_intensity;\n  if (u_params.ca_intensity != 0.0) {\n    return vec4<f32>(\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv - dir, 0.0).r,\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).g,\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + dir, 0.0).b,\n      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).a);\n  }\n  return textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0);\n}\n";
+//# sourceMappingURL=composite.wgsl.d.ts.map

package/dist/post/shaders/composite.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/composite.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,cAAc,8sEA4D1B,CAAC;AAEF,eAAO,MAAM,YAAY,0yBAsBxB,CAAC"}

package/dist/post/shaders/composite.wgsl.js

@@ -0,0 +1,92 @@
+/**
+ * PRD-03 §6.1 S10 / §8.12 Phase 7 — linear-HDR composite WGSL twins.
+ * `c = hdr * exposure * autoExposure` + radial chromatic aberration + bloom
+ * + linear grade (Bradford white balance → lift/gamma/gain →
+ * shadows/midtones/highlights weights). CA_PASS is the transitional
+ * standalone §8.12 radial 3-tap.
+ */
+export const COMPOSITE_WGSL = /* wgsl */ `struct CompositeParams {
+  exposure: f32,
+  auto_exposure: f32,
+  bloom_intensity: f32,
+  ca_intensity: f32,
+  white_balance: vec3<f32>,  // Bradford-cone LMS gain, resolved per temperature/tint
+  has_bloom: i32,
+  lift: vec3<f32>,
+  _pad0: f32,
+  gamma: vec3<f32>,
+  _pad1: f32,
+  gain: vec3<f32>,
+  _pad2: f32,
+  shadows: vec3<f32>,
+  _pad3: f32,
+  midtones: vec3<f32>,
+  _pad4: f32,
+  highlights: vec3<f32>,
+  _pad5: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: CompositeParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_hdr_smp: sampler;
+@group(0) @binding(3) var u_bloom_tex: texture_2d<f32>;
+@group(0) @binding(4) var u_bloom_smp: sampler;
+
+fn composite_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+
+@fragment
+fn fs_composite(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let centre = uv - vec2<f32>(0.5);
+  let dir = centre * dot(centre, centre) * u_params.ca_intensity;
+  var c: vec3<f32>;
+  if (u_params.ca_intensity != 0.0) {
+    c = vec3<f32>(
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv - dir, 0.0).r,
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).g,
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + dir, 0.0).b);
+  } else {
+    c = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).rgb;
+  }
+  c = c * u_params.exposure * u_params.auto_exposure;
+  if (u_params.has_bloom != 0) {
+    c = c + textureSampleLevel(u_bloom_tex, u_bloom_smp, uv, 0.0).rgb * u_params.bloom_intensity;
+  }
+
+  // Linear grade — Bradford CAT already folded into u_whiteBalance on CPU.
+  c = c * u_params.white_balance;
+  // lift / gamma / gain (ASC-CDL style), per channel.
+  let safe_gamma = max(u_params.gamma, vec3<f32>(1e-3));
+  c = pow(max(c * u_params.gain + u_params.lift, vec3<f32>(0.0)), vec3<f32>(1.0) / safe_gamma);
+  // Shadows/midtones/highlights from the luma pivot at 0.18.
+  let s = clamp(log2(max(composite_luma(c), 1e-6) / 0.18) / 8.0 + 0.5, 0.0, 1.0);
+  c = c * (u_params.shadows * (1.0 - s) * (1.0 - s)
+    + u_params.midtones * 2.0 * s * (1.0 - s)
+    + u_params.highlights * s * s);
+
+  return vec4<f32>(c, textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).a);
+}
+`;
+export const CA_PASS_WGSL = /* wgsl */ `struct CaPassParams {
+  ca_intensity: f32,
+  _pad: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: CaPassParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_hdr_smp: sampler;
+
+@fragment
+fn fs_ca_pass(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let centre = uv - vec2<f32>(0.5);
+  let dir = centre * dot(centre, centre) * u_params.ca_intensity;
+  if (u_params.ca_intensity != 0.0) {
+    return vec4<f32>(
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv - dir, 0.0).r,
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).g,
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + dir, 0.0).b,
+      textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0).a);
+  }
+  return textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0);
+}
+`;
+//# sourceMappingURL=composite.wgsl.js.map

package/dist/post/shaders/composite.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/composite.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DxC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBtC,CAAC"}

package/dist/post/shaders/depthDownsample.glsl.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PRD-03 §8.3 — S1 depth prep for the v2 post chain (WebGL2).
+ *
+ * Three small programs, all `texelFetch`-based (no filtering on depth):
+ *
+ *   Pass A `DEPTH_LINEARIZE_GLSL` — full-res R32F view-space metres via the
+ *   §6.11 shared `linearizeDepth` (perspective; ortho handled by `u_ortho`).
+ *   Pass B `DEPTH_MINMAX_HALF_GLSL` — half-res RG32F = (min, max) of the 2×2
+ *   linearized quad. GTAO (S2), DOF (S6), SSR (S3) and god rays (S4) sample
+ *   this; `.r` (nearer) is the conservative occluder choice.
+ *   Pass C `CAMERA_VELOCITY_GLSL` — only when TAA or motion blur is active
+ *   and no C-14 MRT velocity attachment exists: camera-only velocity
+ *   `v = (ndcCurr − ndcPrev) · 0.5` in RG16F, same units and sign as C-14
+ *   (Phase 4 wires it; the shader ships with the depth prep because it reads
+ *   the same linear depth).
+ */
+export declare const DEPTH_LINEARIZE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_depth;\nuniform float u_near;\nuniform float u_far;\nuniform bool u_ortho;\nout vec4 o_color;\n\n\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nvoid main() {\n  float d = texelFetch(u_depth, ivec2(gl_FragCoord.xy), 0).r;\n  o_color = vec4(linearizeDepth(d, u_near, u_far, u_ortho), 0.0, 0.0, 1.0);\n}\n";
+export declare const DEPTH_MINMAX_HALF_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_linearDepth;   // R32F output of pass A\nout vec4 o_color;\n\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy) * 2;\n  float d00 = texelFetch(u_linearDepth, p, 0).r;\n  float d10 = texelFetch(u_linearDepth, p + ivec2(1, 0), 0).r;\n  float d01 = texelFetch(u_linearDepth, p + ivec2(0, 1), 0).r;\n  float d11 = texelFetch(u_linearDepth, p + ivec2(1, 1), 0).r;\n  o_color = vec4(min(min(d00, d10), min(d01, d11)),\n                 max(max(d00, d10), max(d01, d11)), 0.0, 1.0);\n}\n";
+export declare const CAMERA_VELOCITY_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_depth;\nuniform float u_near;\nuniform float u_far;\nuniform bool u_ortho;\nuniform mat4 u_prevViewProjection;\nuniform mat4 u_invUnjitteredViewProjection;\nout vec4 o_color;\n\n\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nvoid main() {\n  vec2 uv = gl_FragCoord.xy / vec2(textureSize(u_depth, 0));\n  float d = texelFetch(u_depth, ivec2(gl_FragCoord.xy), 0).r;\n  float linZ = linearizeDepth(d, u_near, u_far, u_ortho);\n  vec2 ndcCurr = uv * 2.0 - 1.0;\n  // Reconstruct the unjittered world/view position of this pixel, then\n  // reproject it through last frame's camera.\n  vec4 viewPrevH = u_invUnjitteredViewProjection * vec4(ndcCurr, d * 2.0 - 1.0, 1.0);\n  vec4 clipPrev = u_prevViewProjection * vec4(viewPrevH.xyz / viewPrevH.w, 1.0);\n  vec2 ndcPrev = clipPrev.xy / clipPrev.w;\n  // Same units and sign convention as the C-14 velocity MRT: UV-space\n  // half-magnitude per frame.\n  vec2 v = (ndcCurr - ndcPrev) * 0.5;\n  // Sky/static far plane writes zero motion.\n  v = linZ >= u_far * 0.999 ? vec2(0.0) : v;\n  o_color = vec4(v, 0.0, 1.0);\n}\n";
+//# sourceMappingURL=depthDownsample.glsl.d.ts.map

package/dist/post/shaders/depthDownsample.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthDownsample.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/depthDownsample.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,eAAO,MAAM,oBAAoB,mgCAahC,CAAC;AAEF,eAAO,MAAM,sBAAsB,0iBAalC,CAAC;AAEF,eAAO,MAAM,oBAAoB,4vDA4BhC,CAAC"}

package/dist/post/shaders/depthDownsample.glsl.js

@@ -0,0 +1,78 @@
+/**
+ * PRD-03 §8.3 — S1 depth prep for the v2 post chain (WebGL2).
+ *
+ * Three small programs, all `texelFetch`-based (no filtering on depth):
+ *
+ *   Pass A `DEPTH_LINEARIZE_GLSL` — full-res R32F view-space metres via the
+ *   §6.11 shared `linearizeDepth` (perspective; ortho handled by `u_ortho`).
+ *   Pass B `DEPTH_MINMAX_HALF_GLSL` — half-res RG32F = (min, max) of the 2×2
+ *   linearized quad. GTAO (S2), DOF (S6), SSR (S3) and god rays (S4) sample
+ *   this; `.r` (nearer) is the conservative occluder choice.
+ *   Pass C `CAMERA_VELOCITY_GLSL` — only when TAA or motion blur is active
+ *   and no C-14 MRT velocity attachment exists: camera-only velocity
+ *   `v = (ndcCurr − ndcPrev) · 0.5` in RG16F, same units and sign as C-14
+ *   (Phase 4 wires it; the shader ships with the depth prep because it reads
+ *   the same linear depth).
+ */
+import { POST_COMMON_GLSL } from "./common.glsl.js";
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const DEPTH_LINEARIZE_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_depth;
+uniform float u_near;
+uniform float u_far;
+uniform bool u_ortho;
+out vec4 o_color;
+
+${POST_COMMON_GLSL}
+
+void main() {
+  float d = texelFetch(u_depth, ivec2(gl_FragCoord.xy), 0).r;
+  o_color = vec4(linearizeDepth(d, u_near, u_far, u_ortho), 0.0, 0.0, 1.0);
+}
+`;
+export const DEPTH_MINMAX_HALF_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_linearDepth;   // R32F output of pass A
+out vec4 o_color;
+
+void main() {
+  ivec2 p = ivec2(gl_FragCoord.xy) * 2;
+  float d00 = texelFetch(u_linearDepth, p, 0).r;
+  float d10 = texelFetch(u_linearDepth, p + ivec2(1, 0), 0).r;
+  float d01 = texelFetch(u_linearDepth, p + ivec2(0, 1), 0).r;
+  float d11 = texelFetch(u_linearDepth, p + ivec2(1, 1), 0).r;
+  o_color = vec4(min(min(d00, d10), min(d01, d11)),
+                 max(max(d00, d10), max(d01, d11)), 0.0, 1.0);
+}
+`;
+export const CAMERA_VELOCITY_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_depth;
+uniform float u_near;
+uniform float u_far;
+uniform bool u_ortho;
+uniform mat4 u_prevViewProjection;
+uniform mat4 u_invUnjitteredViewProjection;
+out vec4 o_color;
+
+${POST_COMMON_GLSL}
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / vec2(textureSize(u_depth, 0));
+  float d = texelFetch(u_depth, ivec2(gl_FragCoord.xy), 0).r;
+  float linZ = linearizeDepth(d, u_near, u_far, u_ortho);
+  vec2 ndcCurr = uv * 2.0 - 1.0;
+  // Reconstruct the unjittered world/view position of this pixel, then
+  // reproject it through last frame's camera.
+  vec4 viewPrevH = u_invUnjitteredViewProjection * vec4(ndcCurr, d * 2.0 - 1.0, 1.0);
+  vec4 clipPrev = u_prevViewProjection * vec4(viewPrevH.xyz / viewPrevH.w, 1.0);
+  vec2 ndcPrev = clipPrev.xy / clipPrev.w;
+  // Same units and sign convention as the C-14 velocity MRT: UV-space
+  // half-magnitude per frame.
+  vec2 v = (ndcCurr - ndcPrev) * 0.5;
+  // Sky/static far plane writes zero motion.
+  v = linZ >= u_far * 0.999 ? vec2(0.0) : v;
+  o_color = vec4(v, 0.0, 1.0);
+}
+`;
+//# sourceMappingURL=depthDownsample.glsl.js.map

package/dist/post/shaders/depthDownsample.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthDownsample.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/depthDownsample.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;EAOtD,gBAAgB;;;;;;CAMjB,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;CAazD,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;EAStD,gBAAgB;;;;;;;;;;;;;;;;;;;CAmBjB,CAAC"}

package/dist/post/shaders/depthDownsample.wgsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * PRD-03 §8.3 Phase 7 — S1 depth prep WGSL twins (WebGPU).
+ *
+ * `linearizeDepth` note: the GLSL twin receives `u_ortho` as a bool uniform;
+ * WGSL uniform blocks cannot hold bools (not host-shareable), so the twin
+ * carries `ortho: i32` and the probe is `ortho != 0` — the driver writes 0/1.
+ *
+ * `CAMERA_VELOCITY_WGSL` — the one semantic difference from GLSL:
+ * `gl_FragCoord`-derived `uv` is y-UP in GL (origin bottom-left) but
+ * `frag_coord`/`textureDimensions` space is y-DOWN (row 0 = top). Sampling
+ * stays self-consistent, but the `uv * 2 - 1` → NDC conversion needs a y
+ * flip so `ndcCurr` still lines up with clip space (y-up NDC).
+ */
+export declare const DEPTH_LINEARIZE_WGSL = "struct DepthLinearizeParams {\n  near: f32,\n  far: f32,\n  ortho: i32,\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: DepthLinearizeParams;\n@group(0) @binding(1) var u_depth_tex: texture_2d<f32>;\n\n\nfn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {\n  let z = d * 2.0 - 1.0;\n  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);\n}\n\n\n@fragment\nfn fs_depth_linearize(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let d = textureLoad(u_depth_tex, vec2<i32>(frag_coord.xy), 0).r;\n  return vec4<f32>(linearize_depth(d, u_params.near, u_params.far, u_params.ortho != 0), 0.0, 0.0, 1.0);\n}\n";
+export declare const DEPTH_MINMAX_HALF_WGSL = "@group(0) @binding(1) var u_linear_depth_tex: texture_2d<f32>;\n\n@fragment\nfn fs_depth_minmax_half(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let p = vec2<i32>(frag_coord.xy) * 2;\n  let d00 = textureLoad(u_linear_depth_tex, p, 0).r;\n  let d10 = textureLoad(u_linear_depth_tex, p + vec2<i32>(1, 0), 0).r;\n  let d01 = textureLoad(u_linear_depth_tex, p + vec2<i32>(0, 1), 0).r;\n  let d11 = textureLoad(u_linear_depth_tex, p + vec2<i32>(1, 1), 0).r;\n  return vec4<f32>(min(min(d00, d10), min(d01, d11)),\n                   max(max(d00, d10), max(d01, d11)), 0.0, 1.0);\n}\n";
+export declare const CAMERA_VELOCITY_WGSL = "struct CameraVelocityParams {\n  near: f32,\n  far: f32,\n  ortho: i32,\n  _pad: f32,\n  prev_view_projection: mat4x4<f32>,\n  inv_unjittered_view_projection: mat4x4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: CameraVelocityParams;\n@group(0) @binding(1) var u_depth_tex: texture_2d<f32>;\n\n\nfn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {\n  let z = d * 2.0 - 1.0;\n  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);\n}\n\n\n@fragment\nfn fs_camera_velocity(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let size = vec2<f32>(textureDimensions(u_depth_tex));\n  let uv = frag_coord.xy / size;\n  let d = textureLoad(u_depth_tex, vec2<i32>(frag_coord.xy), 0).r;\n  let lin_z = linearize_depth(d, u_params.near, u_params.far, u_params.ortho != 0);\n  // frag_coord space is y-down (row 0 = top) but clip space is y-up \u2014 flip\n  // before mapping to NDC so the reprojection math matches the GLSL twin.\n  let ndc_curr = vec2<f32>(uv.x, 1.0 - uv.y) * 2.0 - vec2<f32>(1.0);\n  // Reconstruct the unjittered world/view position of this pixel, then\n  // reproject it through last frame's camera.\n  let view_prev_h = u_params.inv_unjittered_view_projection * vec4<f32>(ndc_curr, d * 2.0 - 1.0, 1.0);\n  let clip_prev = u_params.prev_view_projection * vec4<f32>(view_prev_h.xyz / view_prev_h.w, 1.0);\n  let ndc_prev = clip_prev.xy / clip_prev.w;\n  // Same units and sign convention as the C-14 velocity MRT: UV-space\n  // half-magnitude per frame.\n  var v = (ndc_curr - ndc_prev) * 0.5;\n  // Sky/static far plane writes zero motion.\n  v = select(v, vec2<f32>(0.0), lin_z >= u_params.far * 0.999);\n  return vec4<f32>(v, 0.0, 1.0);\n}\n";
+//# sourceMappingURL=depthDownsample.wgsl.d.ts.map

package/dist/post/shaders/depthDownsample.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthDownsample.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/depthDownsample.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH,eAAO,MAAM,oBAAoB,6qBAiBhC,CAAC;AAEF,eAAO,MAAM,sBAAsB,omBAYlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,ksDAmChC,CAAC"}

package/dist/post/shaders/depthDownsample.wgsl.js

@@ -0,0 +1,87 @@
+/**
+ * PRD-03 §8.3 Phase 7 — S1 depth prep WGSL twins (WebGPU).
+ *
+ * `linearizeDepth` note: the GLSL twin receives `u_ortho` as a bool uniform;
+ * WGSL uniform blocks cannot hold bools (not host-shareable), so the twin
+ * carries `ortho: i32` and the probe is `ortho != 0` — the driver writes 0/1.
+ *
+ * `CAMERA_VELOCITY_WGSL` — the one semantic difference from GLSL:
+ * `gl_FragCoord`-derived `uv` is y-UP in GL (origin bottom-left) but
+ * `frag_coord`/`textureDimensions` space is y-DOWN (row 0 = top). Sampling
+ * stays self-consistent, but the `uv * 2 - 1` → NDC conversion needs a y
+ * flip so `ndcCurr` still lines up with clip space (y-up NDC).
+ */
+const COMMON = /* wgsl */ `
+fn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {
+  let z = d * 2.0 - 1.0;
+  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);
+}
+`;
+export const DEPTH_LINEARIZE_WGSL = /* wgsl */ `struct DepthLinearizeParams {
+  near: f32,
+  far: f32,
+  ortho: i32,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: DepthLinearizeParams;
+@group(0) @binding(1) var u_depth_tex: texture_2d<f32>;
+
+${COMMON}
+
+@fragment
+fn fs_depth_linearize(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let d = textureLoad(u_depth_tex, vec2<i32>(frag_coord.xy), 0).r;
+  return vec4<f32>(linearize_depth(d, u_params.near, u_params.far, u_params.ortho != 0), 0.0, 0.0, 1.0);
+}
+`;
+export const DEPTH_MINMAX_HALF_WGSL = /* wgsl */ `@group(0) @binding(1) var u_linear_depth_tex: texture_2d<f32>;
+
+@fragment
+fn fs_depth_minmax_half(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let p = vec2<i32>(frag_coord.xy) * 2;
+  let d00 = textureLoad(u_linear_depth_tex, p, 0).r;
+  let d10 = textureLoad(u_linear_depth_tex, p + vec2<i32>(1, 0), 0).r;
+  let d01 = textureLoad(u_linear_depth_tex, p + vec2<i32>(0, 1), 0).r;
+  let d11 = textureLoad(u_linear_depth_tex, p + vec2<i32>(1, 1), 0).r;
+  return vec4<f32>(min(min(d00, d10), min(d01, d11)),
+                   max(max(d00, d10), max(d01, d11)), 0.0, 1.0);
+}
+`;
+export const CAMERA_VELOCITY_WGSL = /* wgsl */ `struct CameraVelocityParams {
+  near: f32,
+  far: f32,
+  ortho: i32,
+  _pad: f32,
+  prev_view_projection: mat4x4<f32>,
+  inv_unjittered_view_projection: mat4x4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: CameraVelocityParams;
+@group(0) @binding(1) var u_depth_tex: texture_2d<f32>;
+
+${COMMON}
+
+@fragment
+fn fs_camera_velocity(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let size = vec2<f32>(textureDimensions(u_depth_tex));
+  let uv = frag_coord.xy / size;
+  let d = textureLoad(u_depth_tex, vec2<i32>(frag_coord.xy), 0).r;
+  let lin_z = linearize_depth(d, u_params.near, u_params.far, u_params.ortho != 0);
+  // frag_coord space is y-down (row 0 = top) but clip space is y-up — flip
+  // before mapping to NDC so the reprojection math matches the GLSL twin.
+  let ndc_curr = vec2<f32>(uv.x, 1.0 - uv.y) * 2.0 - vec2<f32>(1.0);
+  // Reconstruct the unjittered world/view position of this pixel, then
+  // reproject it through last frame's camera.
+  let view_prev_h = u_params.inv_unjittered_view_projection * vec4<f32>(ndc_curr, d * 2.0 - 1.0, 1.0);
+  let clip_prev = u_params.prev_view_projection * vec4<f32>(view_prev_h.xyz / view_prev_h.w, 1.0);
+  let ndc_prev = clip_prev.xy / clip_prev.w;
+  // Same units and sign convention as the C-14 velocity MRT: UV-space
+  // half-magnitude per frame.
+  var v = (ndc_curr - ndc_prev) * 0.5;
+  // Sky/static far plane writes zero motion.
+  v = select(v, vec2<f32>(0.0), lin_z >= u_params.far * 0.999);
+  return vec4<f32>(v, 0.0, 1.0);
+}
+`;
+//# sourceMappingURL=depthDownsample.wgsl.js.map

package/dist/post/shaders/depthDownsample.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthDownsample.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/depthDownsample.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;CAKzB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;EAU7C,MAAM;;;;;;;CAOP,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;CAYhD,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;EAY7C,MAAM;;;;;;;;;;;;;;;;;;;;;;;CAuBP,CAAC"}

package/dist/post/shaders/displayGrade.glsl.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PRD-03 §6.7 S10b — the display-grade fetch, fused into S11/S12.
+ *
+ * Runs after the OutputPass boundary on display-referred RGBA8: one
+ * trilinear `texture(u_lut3d, disp)` fetch applies contrast / saturation /
+ * vibrance / the user `.cube`, then vignette (roundness-aspect corrected).
+ * Output alpha carries `luma(disp)` so the S11 FXAA pass reads luminance
+ * from `.a` instead of recomputing it per tap.
+ */
+export declare const DISPLAY_GRADE_GLSL = "#version 300 es\nprecision highp float;\n// GLSL ES 3.00 has no default precision for sampler3D (CI: \"'sampler3D' : No precision specified\").\nprecision highp sampler3D;\nuniform sampler2D u_source;\nuniform sampler3D u_lut3d;\nuniform int u_hasLut;\nuniform float u_vignetteIntensity;\nuniform float u_vignetteSmoothness;\nuniform float u_vignetteRoundness;\nuniform vec3 u_vignetteColor;\nuniform vec2 u_resolution;\nin vec2 v_uv;\nout vec4 outColor;\n\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvoid main() {\n  vec3 disp = texture(u_source, v_uv).rgb;\n  if (u_hasLut != 0) {\n    disp = texture(u_lut3d, clamp(disp, 0.0, 1.0)).rgb;\n  }\n  if (u_vignetteIntensity > 0.0) {\n    // \u00A78.12: roundness-aspect corrected len, mix toward vignetteColor.\n    vec2 p = (v_uv - 0.5) * 2.0;\n    p.x *= (u_resolution.x / u_resolution.y) * u_vignetteRoundness;\n    float len = length(p) * u_vignetteIntensity;\n    disp *= mix(vec3(1.0), u_vignetteColor, pow(clamp(len, 0.0, 1.0), u_vignetteSmoothness));\n  }\n  outColor = vec4(disp, luma(disp));\n}\n";
+/**
+ * Display-grade bake: one draw per slice into the 65³ RGBA8 TEXTURE_3D with
+ * `framebufferTextureLayer`. Applies contrast (pivot 0.5), saturation,
+ * vibrance and the optional user `.cube` sample, in the display domain —
+ * the same math the analytic grade would apply per pixel.
+ */
+export declare const LUT_BAKE_GLSL = "#version 300 es\nprecision highp float;\n// GLSL ES 3.00 has no default precision for sampler3D (CI: \"'sampler3D' : No precision specified\").\nprecision highp sampler3D;\nuniform sampler3D u_userLut;\nuniform int u_hasUserLut;\nuniform float u_lutIntensity;\nuniform float u_contrast;\nuniform float u_saturation;\nuniform float u_vibrance;\nuniform float u_slice;          // b texel, [0,1]\nin vec2 v_uv;\nout vec4 outColor;\n\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvoid main() {\n  vec3 disp = vec3(v_uv, u_slice);\n  // Contrast, pivot 0.5 \u2014 same shape as the legacy present grade.\n  vec3 graded = clamp(disp * u_contrast + vec3(0.5 - 0.5 * u_contrast), 0.0, 1.0);\n  // Vibrance: boost scales with distance from luma, folded into saturation\n  // (verbatim from the legacy present grade).\n  float l = luma(graded);\n  float distanceFromLuma = min(1.0, abs(graded.r - l) + abs(graded.g - l) + abs(graded.b - l));\n  float sat = u_saturation + (u_vibrance == 0.0 ? 0.0 : u_vibrance * (1.0 - distanceFromLuma));\n  graded = clamp(vec3(l) + (graded - vec3(l)) * sat, 0.0, 1.0);\n  if (u_hasUserLut != 0) {\n    graded = mix(graded, texture(u_userLut, graded).rgb, clamp(u_lutIntensity, 0.0, 1.0));\n  }\n  outColor = vec4(graded, 1.0);\n}\n";
+//# sourceMappingURL=displayGrade.glsl.d.ts.map

package/dist/post/shaders/displayGrade.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayGrade.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/displayGrade.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,kBAAkB,+jCA+B9B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wwCA+BzB,CAAC"}