@aura3d/rendering 3.0.1 → 4.0.2

package/dist/program/chunks/common.glsl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `common` chunk (PRD-01 §8.2) — math constants + `AuraFrame` block declaration.
+ * The block GLSL is generated by `uniformBlockGlsl` from the frozen
+ * `AURA_FRAME_BLOCK` field list so the layout can never drift from the packer.
+ */
+export declare const COMMON_CHUNK_GLSL: string;
+//# sourceMappingURL=common.glsl.d.ts.map

package/dist/program/chunks/common.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/common.glsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,eAAO,MAAM,iBAAiB,QAgB7B,CAAC"}

package/dist/program/chunks/common.glsl.js

@@ -0,0 +1,25 @@
+/**
+ * `common` chunk (PRD-01 §8.2) — math constants + `AuraFrame` block declaration.
+ * The block GLSL is generated by `uniformBlockGlsl` from the frozen
+ * `AURA_FRAME_BLOCK` field list so the layout can never drift from the packer.
+ */
+import { AURA_FRAME_BLOCK } from "../../contracts/frameUniforms.js";
+import { uniformBlockGlsl } from "../../resources/UniformBlock.js";
+export const COMMON_CHUNK_GLSL = /* glsl */ `
+#define PI 3.141592653589793
+#define RECIPROCAL_PI 0.3183098861837907
+#define EPSILON 1e-6
+float pow2(float x) { return x * x; }
+// r185 common.glsl.js helpers registered chunks rely on (lane 04 Q-01-5:
+// pow2(vec3), pow3/pow4, max3/max4; the C-03 lobes require these via brdf).
+vec3 pow2(vec3 x) { return x * x; }
+float pow3(float x) { return x * x * x; }
+float pow4(float x) { float x2 = x * x; return x2 * x2; }
+float max3(vec3 v) { return max(max(v.x, v.y), v.z); }
+float max4(vec4 v) { return max(max(v.x, v.y), max(v.z, v.w)); }
+vec3 BRDF_Lambert(vec3 diffuseColor) { return RECIPROCAL_PI * diffuseColor; }
+float saturate(float x) { return clamp(x, 0.0, 1.0); }
+vec3 saturate(vec3 v) { return clamp(v, vec3(0.0), vec3(1.0)); }
+${uniformBlockGlsl("AuraFrame", AURA_FRAME_BLOCK)}
+`;
+//# sourceMappingURL=common.glsl.js.map

package/dist/program/chunks/common.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/common.glsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEhE,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;EAe1C,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,CAAC;CAChD,CAAC"}

package/dist/program/chunks/depth.glsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `depth` chunk (PRD-01 §8.7) — depth/distance pass fragment bodies.
+ * `pass:"depth"` writes hardware depth (alpha-masked when ALPHA_MASK);
+ * `pass:"distance"` (three's distanceRGBA convention) writes the radial
+ * distance from `u_distanceLight`, packed for RGBA8 shadow storage.
+ */
+export declare const DEPTH_CHUNK_GLSL = "\n#if defined(USE_BASE_COLOR_MAP) && defined(ALPHA_MASK)\nuniform sampler2D u_baseColorMap;  // u_alphaCutoff comes from the alpha chunk\n#endif\n";
+export declare const DISTANCE_CHUNK_PARS_GLSL = "\nuniform vec4 u_distanceLight;   // xyz light position, w far\nfloat a3dPackDistance(float dist, float far) {\n  return clamp(dist / max(far, 0.0001), 0.0, 1.0);\n}\n";
+//# sourceMappingURL=depth.glsl.d.ts.map

package/dist/program/chunks/depth.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/depth.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,gBAAgB,uJAI5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,4KAKpC,CAAC"}

package/dist/program/chunks/depth.glsl.js

@@ -0,0 +1,18 @@
+/**
+ * `depth` chunk (PRD-01 §8.7) — depth/distance pass fragment bodies.
+ * `pass:"depth"` writes hardware depth (alpha-masked when ALPHA_MASK);
+ * `pass:"distance"` (three's distanceRGBA convention) writes the radial
+ * distance from `u_distanceLight`, packed for RGBA8 shadow storage.
+ */
+export const DEPTH_CHUNK_GLSL = /* glsl */ `
+#if defined(USE_BASE_COLOR_MAP) && defined(ALPHA_MASK)
+uniform sampler2D u_baseColorMap;  // u_alphaCutoff comes from the alpha chunk
+#endif
+`;
+export const DISTANCE_CHUNK_PARS_GLSL = /* glsl */ `
+uniform vec4 u_distanceLight;   // xyz light position, w far
+float a3dPackDistance(float dist, float far) {
+  return clamp(dist / max(far, 0.0001), 0.0, 1.0);
+}
+`;
+//# sourceMappingURL=depth.glsl.js.map

package/dist/program/chunks/depth.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/depth.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;CAI1C,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;CAKlD,CAAC"}

package/dist/program/chunks/drawId.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PRD 11 Phase 6 groundwork — WGSL twin of `a3d_prd11_draw_id`
+ * (`batching/shaders/drawId.glsl.ts`). Same six-texel draw-data layout as
+ * `DrawDataTexture`; WGSL has no `gl_DrawID` builtin, so the twin models the
+ * uniform-loop path (`a3dDrawId.u_drawId`) — the multi-draw selection under
+ * WebGPU is a Phase-6+ device decision (indirect draws), not a chunk detail.
+ */
+export declare const PRD11_DRAWID_WGSL = "\nstruct A3dPrd11DrawIdUniform {\n  u_drawId: i32,\n};\n@group(3) @binding(0) var<uniform> a3dDrawId: A3dPrd11DrawIdUniform;\n@group(3) @binding(1) var u_a3dDrawData: texture_2d<f32>;\n\nfn a3dDrawTexel(draw: i32, row: i32) -> vec4<f32> {\n  return textureLoad(u_a3dDrawData, vec2<i32>(draw * 6 + row, 0), 0);\n}\nfn a3dDrawModelMatrix(draw: i32) -> mat4x4<f32> {\n  return mat4x4<f32>(a3dDrawTexel(draw, 0), a3dDrawTexel(draw, 1), a3dDrawTexel(draw, 2), a3dDrawTexel(draw, 3));\n}\nfn a3dDrawBaseColor(draw: i32) -> vec4<f32> {\n  return a3dDrawTexel(draw, 4);\n}\nfn a3dDrawMeta(draw: i32) -> vec4<f32> {\n  return a3dDrawTexel(draw, 5);\n}\n";
+//# sourceMappingURL=drawId.wgsl.d.ts.map

package/dist/program/chunks/drawId.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawId.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/drawId.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,iBAAiB,yoBAmB7B,CAAC"}

package/dist/program/chunks/drawId.wgsl.js

@@ -0,0 +1,29 @@
+/**
+ * PRD 11 Phase 6 groundwork — WGSL twin of `a3d_prd11_draw_id`
+ * (`batching/shaders/drawId.glsl.ts`). Same six-texel draw-data layout as
+ * `DrawDataTexture`; WGSL has no `gl_DrawID` builtin, so the twin models the
+ * uniform-loop path (`a3dDrawId.u_drawId`) — the multi-draw selection under
+ * WebGPU is a Phase-6+ device decision (indirect draws), not a chunk detail.
+ */
+import { DRAW_DATA_TEXELS_PER_DRAW } from "../../batching/DrawDataTexture.js";
+export const PRD11_DRAWID_WGSL = /* wgsl */ `
+struct A3dPrd11DrawIdUniform {
+  u_drawId: i32,
+};
+@group(3) @binding(0) var<uniform> a3dDrawId: A3dPrd11DrawIdUniform;
+@group(3) @binding(1) var u_a3dDrawData: texture_2d<f32>;
+
+fn a3dDrawTexel(draw: i32, row: i32) -> vec4<f32> {
+  return textureLoad(u_a3dDrawData, vec2<i32>(draw * ${DRAW_DATA_TEXELS_PER_DRAW} + row, 0), 0);
+}
+fn a3dDrawModelMatrix(draw: i32) -> mat4x4<f32> {
+  return mat4x4<f32>(a3dDrawTexel(draw, 0), a3dDrawTexel(draw, 1), a3dDrawTexel(draw, 2), a3dDrawTexel(draw, 3));
+}
+fn a3dDrawBaseColor(draw: i32) -> vec4<f32> {
+  return a3dDrawTexel(draw, 4);
+}
+fn a3dDrawMeta(draw: i32) -> vec4<f32> {
+  return a3dDrawTexel(draw, 5);
+}
+`;
+//# sourceMappingURL=drawId.wgsl.js.map

package/dist/program/chunks/drawId.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawId.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/drawId.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;uDAQW,yBAAyB;;;;;;;;;;;CAW/E,CAAC"}

package/dist/program/chunks/fog_default.glsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `fog_default` chunk — default `fragment:fog` body helpers.
+ * Legacy linear/exp2 fog plus a simple height falloff; the `"volumetric"`
+ * variant and wetness are lane 07's C-21 hook — the default emits the linear
+ * form under FOG_LINEAR and exp2 under FOG_EXP2 (height falls back to exp2).
+ */
+export declare const FOG_DEFAULT_CHUNK_GLSL = "\n#if defined(FOG_LINEAR) || defined(FOG_EXP2) || defined(FOG_HEIGHT)\nuniform vec3 u_fogColor;\nuniform vec2 u_fogRange;    // near, far\nuniform float u_fogDensity;\nuniform float u_fogHeightFalloff;\nfloat a3dFogFactor(float depth, float height) {\n#ifdef FOG_LINEAR\n  return clamp((depth - u_fogRange.x) / max(u_fogRange.y - u_fogRange.x, 0.0001), 0.0, 1.0);\n#else\n  float density = u_fogDensity;\n#ifdef FOG_HEIGHT\n  density *= exp(-max(height, 0.0) * u_fogHeightFalloff);\n#endif\n  float d = density * depth;\n  return clamp(1.0 - exp(-d * d), 0.0, 1.0);\n#endif\n}\nvec3 a3dApplyFog(vec3 color, float depth, float height) {\n  float f = a3dFogFactor(depth, height);\n  return mix(color, u_fogColor, f);\n}\n#endif\n";
+//# sourceMappingURL=fog_default.glsl.d.ts.map

package/dist/program/chunks/fog_default.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog_default.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/fog_default.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,sBAAsB,4tBAuBlC,CAAC"}

package/dist/program/chunks/fog_default.glsl.js

@@ -0,0 +1,31 @@
+/**
+ * `fog_default` chunk — default `fragment:fog` body helpers.
+ * Legacy linear/exp2 fog plus a simple height falloff; the `"volumetric"`
+ * variant and wetness are lane 07's C-21 hook — the default emits the linear
+ * form under FOG_LINEAR and exp2 under FOG_EXP2 (height falls back to exp2).
+ */
+export const FOG_DEFAULT_CHUNK_GLSL = /* glsl */ `
+#if defined(FOG_LINEAR) || defined(FOG_EXP2) || defined(FOG_HEIGHT)
+uniform vec3 u_fogColor;
+uniform vec2 u_fogRange;    // near, far
+uniform float u_fogDensity;
+uniform float u_fogHeightFalloff;
+float a3dFogFactor(float depth, float height) {
+#ifdef FOG_LINEAR
+  return clamp((depth - u_fogRange.x) / max(u_fogRange.y - u_fogRange.x, 0.0001), 0.0, 1.0);
+#else
+  float density = u_fogDensity;
+#ifdef FOG_HEIGHT
+  density *= exp(-max(height, 0.0) * u_fogHeightFalloff);
+#endif
+  float d = density * depth;
+  return clamp(1.0 - exp(-d * d), 0.0, 1.0);
+#endif
+}
+vec3 a3dApplyFog(vec3 color, float depth, float height) {
+  float f = a3dFogFactor(depth, height);
+  return mix(color, u_fogColor, f);
+}
+#endif
+`;
+//# sourceMappingURL=fog_default.glsl.js.map

package/dist/program/chunks/fog_default.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog_default.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/fog_default.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBhD,CAAC"}

package/dist/program/chunks/indirect_default.glsl.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `indirect_default` chunk — default `fragment:indirect` body helpers.
+ *
+ * Ambient irradiance is `u_environmentColor * u_environmentIntensity` applied
+ * as `irradiance · BRDF_Lambert(diffuseColor)` — the PRD-01 §6.6 1/π ambient
+ * (no hemisphere factor). One environment sampler is declared by feature:
+ *   - `ENVMAP_TYPE_EQUIRECT`: the renderer's 2D `environmentMapTexture`
+ *     (`u_environmentMap`);
+ *   - `ENVMAP_TYPE_CUBE_UV` (`environment: "pmrem-cube"`): the renderer's
+ *     prefiltered `environmentCubeMapTexture` (`u_environmentCubeMap`). This is
+ *     the lane-01 default for cube/PMREM environments; lane 02's C-09 probe
+ *     chunk (`a3d_prd02_lighting_ibl`, SH irradiance) can replace it through
+ *     a `fragment:indirect` contribution.
+ * Both define `A3D_ENV_SAMPLE` and provide `a3dSampleEnvironment(dir, lod)`,
+ * which the default indirect body and the C-03 lobe IBL calls use.
+ *
+ * Both match the flag-off sampling of the same textures (ForwardPass binds
+ * them in `applyGeneratedEnvironmentMapUniforms`, #1140):
+ *   - equirect: v = 0 at +Y, plus `u_environmentMapRotation` turns on u;
+ *   - cube: Y-axis rotation by `u_environmentMapRotation` turns;
+ *   - decode: `u_environmentMapEncoding` 0 srgb (hardware-decoded at upload),
+ *     1 rgbe, 2 linear.
+ * `lod` is on a normalized 0..8 roughness scale (`roughness * 8.0`, the same
+ * scale the lane-04 lobe calls use); it is remapped onto the bound texture's
+ * real mip range (`u_environmentMapMaxLod`). Diffuse irradiance samples the
+ * roughest mip, as the flag-off path does.
+ */
+export declare const INDIRECT_DEFAULT_CHUNK_GLSL = "\nuniform vec3 u_environmentColor;\nuniform float u_environmentIntensity;\n#ifdef A3D_ENV_SAMPLE\nuniform float u_environmentMapIntensity;\nuniform float u_environmentMapRotation;\nuniform float u_environmentMapMaxLod;\nuniform float u_environmentMapEncoding;\nvec3 a3dDecodeEnvironment(vec4 texel) {\n  if (u_environmentMapEncoding > 0.5 && u_environmentMapEncoding < 1.5) {\n    float exponent = texel.a * 255.0;\n    float scale = exponent <= 0.0 ? 0.0 : exp2(exponent - 128.0) * (255.0 / 256.0);\n    return max(texel.rgb * scale, vec3(0.0));\n  }\n  return max(texel.rgb, vec3(0.0));\n}\nfloat a3dEnvironmentMip(float lod) {\n  return clamp(lod, 0.0, 8.0) * (u_environmentMapMaxLod / 8.0);\n}\n#endif\n#if defined(ENVMAP_TYPE_CUBE_UV)\nuniform samplerCube u_environmentCubeMap;\nvec3 a3dEnvironmentCubeDirection(vec3 direction) {\n  float angle = u_environmentMapRotation * 2.0 * PI;\n  float c = cos(angle);\n  float s = sin(angle);\n  vec3 d = normalize(direction);\n  return normalize(vec3(c * d.x - s * d.z, d.y, s * d.x + c * d.z));\n}\nvec3 a3dSampleEnvironment(vec3 direction, float lod) {\n  return a3dDecodeEnvironment(textureLod(u_environmentCubeMap, a3dEnvironmentCubeDirection(direction), a3dEnvironmentMip(lod))) * u_environmentMapIntensity;\n}\n#elif defined(ENVMAP_TYPE_EQUIRECT)\nuniform sampler2D u_environmentMap;\nvec2 a3dEquirectUv(vec3 direction) {\n  vec3 d = normalize(direction);\n  float u = atan(d.z, d.x) / (2.0 * PI) + 0.5 + u_environmentMapRotation;\n  float v = acos(clamp(d.y, -1.0, 1.0)) / PI;\n  return vec2(fract(u), clamp(v, 0.0, 1.0));\n}\nvec3 a3dSampleEnvironment(vec3 direction, float lod) {\n  return a3dDecodeEnvironment(textureLod(u_environmentMap, a3dEquirectUv(direction), a3dEnvironmentMip(lod))) * u_environmentMapIntensity;\n}\n#endif\n\n// Ambient-only path (\u00A76.6): irradiance \u00B7 BRDF_Lambert(diffuseColor) \u2014 the 1/pi ambient.\nvec3 a3dAmbientDiffuse(vec3 diffuseContribution) {\n  vec3 irradiance = u_environmentColor * u_environmentIntensity;\n  return irradiance * BRDF_Lambert(diffuseContribution);\n}\n\n#ifdef LIGHT_HEMISPHERE\n// Procedural sky/horizon/ground environment (EnvironmentLightingOptions.proceduralMap),\n// the flag-off shader's analytic IBL. Without it, generated programs dropped the\n// whole term: scenes lit by a scene-category / parity-preset procedural map lost\n// their fill (shadowed and back-facing surfaces went black). Same blends as the\n// frozen library; distinct uniform names so the sampled map's\n// u_environmentMapIntensity stays independent.\nuniform vec3 u_a3dProceduralSkyColor;\nuniform vec3 u_a3dProceduralHorizonColor;\nuniform vec3 u_a3dProceduralGroundColor;\nuniform vec3 u_a3dProceduralSpecularColor;\nuniform float u_a3dProceduralIntensity;\nuniform float u_a3dProceduralSpecularIntensity;\nvec3 a3dProceduralDiffuseRadiance(vec3 n) {\n  float skyBlend = clamp(n.y * 0.5 + 0.5, 0.0, 1.0);\n  vec3 c = mix(u_a3dProceduralGroundColor, u_a3dProceduralSkyColor, skyBlend);\n  c = mix(c, u_a3dProceduralHorizonColor, clamp(1.0 - abs(n.y), 0.0, 1.0) * 0.55);\n  return c * u_a3dProceduralIntensity;\n}\nvec3 a3dProceduralSpecularRadiance(vec3 r, float roughness) {\n  float rough = clamp(roughness, 0.0, 1.0);\n  float band = pow(clamp(r.y * 0.5 + 0.5, 0.0, 1.0), mix(18.0, 2.0, rough));\n  float response = max(band, mix(0.04, 0.38, rough));\n  float horizonStripe = pow(clamp(1.0 - abs(r.y), 0.0, 1.0), mix(14.0, 3.0, rough));\n  float sideStripe = pow(clamp(abs(r.x), 0.0, 1.0), mix(10.0, 3.0, rough)) * smoothstep(0.0, 0.72, 1.0 - abs(r.y));\n  float overheadStripe = pow(clamp(r.y * 0.5 + 0.5, 0.0, 1.0), mix(22.0, 4.0, rough));\n  vec3 c = u_a3dProceduralSpecularColor * response\n    + u_a3dProceduralHorizonColor * horizonStripe * 0.42\n    + u_a3dProceduralSkyColor * overheadStripe * 0.28\n    + u_a3dProceduralGroundColor * sideStripe * 0.22;\n  return c * u_a3dProceduralSpecularIntensity;\n}\n#endif\n";
+//# sourceMappingURL=indirect_default.glsl.d.ts.map

package/dist/program/chunks/indirect_default.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indirect_default.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/indirect_default.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,2BAA2B,41HAoFvC,CAAC"}

package/dist/program/chunks/indirect_default.glsl.js

@@ -0,0 +1,113 @@
+/**
+ * `indirect_default` chunk — default `fragment:indirect` body helpers.
+ *
+ * Ambient irradiance is `u_environmentColor * u_environmentIntensity` applied
+ * as `irradiance · BRDF_Lambert(diffuseColor)` — the PRD-01 §6.6 1/π ambient
+ * (no hemisphere factor). One environment sampler is declared by feature:
+ *   - `ENVMAP_TYPE_EQUIRECT`: the renderer's 2D `environmentMapTexture`
+ *     (`u_environmentMap`);
+ *   - `ENVMAP_TYPE_CUBE_UV` (`environment: "pmrem-cube"`): the renderer's
+ *     prefiltered `environmentCubeMapTexture` (`u_environmentCubeMap`). This is
+ *     the lane-01 default for cube/PMREM environments; lane 02's C-09 probe
+ *     chunk (`a3d_prd02_lighting_ibl`, SH irradiance) can replace it through
+ *     a `fragment:indirect` contribution.
+ * Both define `A3D_ENV_SAMPLE` and provide `a3dSampleEnvironment(dir, lod)`,
+ * which the default indirect body and the C-03 lobe IBL calls use.
+ *
+ * Both match the flag-off sampling of the same textures (ForwardPass binds
+ * them in `applyGeneratedEnvironmentMapUniforms`, #1140):
+ *   - equirect: v = 0 at +Y, plus `u_environmentMapRotation` turns on u;
+ *   - cube: Y-axis rotation by `u_environmentMapRotation` turns;
+ *   - decode: `u_environmentMapEncoding` 0 srgb (hardware-decoded at upload),
+ *     1 rgbe, 2 linear.
+ * `lod` is on a normalized 0..8 roughness scale (`roughness * 8.0`, the same
+ * scale the lane-04 lobe calls use); it is remapped onto the bound texture's
+ * real mip range (`u_environmentMapMaxLod`). Diffuse irradiance samples the
+ * roughest mip, as the flag-off path does.
+ */
+export const INDIRECT_DEFAULT_CHUNK_GLSL = /* glsl */ `
+uniform vec3 u_environmentColor;
+uniform float u_environmentIntensity;
+#ifdef A3D_ENV_SAMPLE
+uniform float u_environmentMapIntensity;
+uniform float u_environmentMapRotation;
+uniform float u_environmentMapMaxLod;
+uniform float u_environmentMapEncoding;
+vec3 a3dDecodeEnvironment(vec4 texel) {
+  if (u_environmentMapEncoding > 0.5 && u_environmentMapEncoding < 1.5) {
+    float exponent = texel.a * 255.0;
+    float scale = exponent <= 0.0 ? 0.0 : exp2(exponent - 128.0) * (255.0 / 256.0);
+    return max(texel.rgb * scale, vec3(0.0));
+  }
+  return max(texel.rgb, vec3(0.0));
+}
+float a3dEnvironmentMip(float lod) {
+  return clamp(lod, 0.0, 8.0) * (u_environmentMapMaxLod / 8.0);
+}
+#endif
+#if defined(ENVMAP_TYPE_CUBE_UV)
+uniform samplerCube u_environmentCubeMap;
+vec3 a3dEnvironmentCubeDirection(vec3 direction) {
+  float angle = u_environmentMapRotation * 2.0 * PI;
+  float c = cos(angle);
+  float s = sin(angle);
+  vec3 d = normalize(direction);
+  return normalize(vec3(c * d.x - s * d.z, d.y, s * d.x + c * d.z));
+}
+vec3 a3dSampleEnvironment(vec3 direction, float lod) {
+  return a3dDecodeEnvironment(textureLod(u_environmentCubeMap, a3dEnvironmentCubeDirection(direction), a3dEnvironmentMip(lod))) * u_environmentMapIntensity;
+}
+#elif defined(ENVMAP_TYPE_EQUIRECT)
+uniform sampler2D u_environmentMap;
+vec2 a3dEquirectUv(vec3 direction) {
+  vec3 d = normalize(direction);
+  float u = atan(d.z, d.x) / (2.0 * PI) + 0.5 + u_environmentMapRotation;
+  float v = acos(clamp(d.y, -1.0, 1.0)) / PI;
+  return vec2(fract(u), clamp(v, 0.0, 1.0));
+}
+vec3 a3dSampleEnvironment(vec3 direction, float lod) {
+  return a3dDecodeEnvironment(textureLod(u_environmentMap, a3dEquirectUv(direction), a3dEnvironmentMip(lod))) * u_environmentMapIntensity;
+}
+#endif
+
+// Ambient-only path (§6.6): irradiance · BRDF_Lambert(diffuseColor) — the 1/pi ambient.
+vec3 a3dAmbientDiffuse(vec3 diffuseContribution) {
+  vec3 irradiance = u_environmentColor * u_environmentIntensity;
+  return irradiance * BRDF_Lambert(diffuseContribution);
+}
+
+#ifdef LIGHT_HEMISPHERE
+// Procedural sky/horizon/ground environment (EnvironmentLightingOptions.proceduralMap),
+// the flag-off shader's analytic IBL. Without it, generated programs dropped the
+// whole term: scenes lit by a scene-category / parity-preset procedural map lost
+// their fill (shadowed and back-facing surfaces went black). Same blends as the
+// frozen library; distinct uniform names so the sampled map's
+// u_environmentMapIntensity stays independent.
+uniform vec3 u_a3dProceduralSkyColor;
+uniform vec3 u_a3dProceduralHorizonColor;
+uniform vec3 u_a3dProceduralGroundColor;
+uniform vec3 u_a3dProceduralSpecularColor;
+uniform float u_a3dProceduralIntensity;
+uniform float u_a3dProceduralSpecularIntensity;
+vec3 a3dProceduralDiffuseRadiance(vec3 n) {
+  float skyBlend = clamp(n.y * 0.5 + 0.5, 0.0, 1.0);
+  vec3 c = mix(u_a3dProceduralGroundColor, u_a3dProceduralSkyColor, skyBlend);
+  c = mix(c, u_a3dProceduralHorizonColor, clamp(1.0 - abs(n.y), 0.0, 1.0) * 0.55);
+  return c * u_a3dProceduralIntensity;
+}
+vec3 a3dProceduralSpecularRadiance(vec3 r, float roughness) {
+  float rough = clamp(roughness, 0.0, 1.0);
+  float band = pow(clamp(r.y * 0.5 + 0.5, 0.0, 1.0), mix(18.0, 2.0, rough));
+  float response = max(band, mix(0.04, 0.38, rough));
+  float horizonStripe = pow(clamp(1.0 - abs(r.y), 0.0, 1.0), mix(14.0, 3.0, rough));
+  float sideStripe = pow(clamp(abs(r.x), 0.0, 1.0), mix(10.0, 3.0, rough)) * smoothstep(0.0, 0.72, 1.0 - abs(r.y));
+  float overheadStripe = pow(clamp(r.y * 0.5 + 0.5, 0.0, 1.0), mix(22.0, 4.0, rough));
+  vec3 c = u_a3dProceduralSpecularColor * response
+    + u_a3dProceduralHorizonColor * horizonStripe * 0.42
+    + u_a3dProceduralSkyColor * overheadStripe * 0.28
+    + u_a3dProceduralGroundColor * sideStripe * 0.22;
+  return c * u_a3dProceduralSpecularIntensity;
+}
+#endif
+`;
+//# sourceMappingURL=indirect_default.glsl.js.map

package/dist/program/chunks/indirect_default.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indirect_default.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/indirect_default.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFrD,CAAC"}

package/dist/program/chunks/instanceEmissive.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PRD 11 Phase 6 groundwork — WGSL twins of
+ * `a3d_prd11_instance_emissive_{vtx,frag}` (`batching/shaders/
+ * instanceEmissive.glsl.ts`). The instanced attribute arrives through the
+ * vertex buffer layout the Phase-6 device builds; these twins carry the
+ * varying declaration + helper both stages share.
+ */
+export declare const PRD11_INSTANCE_EMISSIVE_VTX_WGSL = "\n// vertex stage \u2014 @location input arrives via the instance-rate vertex buffer\n// (location 14, reserved for a_instanceEmissive by the bind layout builder)\nfn a3dInstanceEmissiveIn(input: vec3<f32>) -> vec3<f32> {\n  return input;\n}\n";
+export declare const PRD11_INSTANCE_EMISSIVE_FRAG_WGSL = "\n// fragment stage \u2014 consumed through the interpolated varying\nstruct A3dPrd11InstanceEmissiveFrag {\n  @location(14) v_a3dInstanceEmissive: vec3<f32>,\n};\n";
+//# sourceMappingURL=instanceEmissive.wgsl.d.ts.map

package/dist/program/chunks/instanceEmissive.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceEmissive.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/instanceEmissive.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,gCAAgC,wPAM5C,CAAC;AAEF,eAAO,MAAM,iCAAiC,yKAK7C,CAAC"}

package/dist/program/chunks/instanceEmissive.wgsl.js

@@ -0,0 +1,21 @@
+/**
+ * PRD 11 Phase 6 groundwork — WGSL twins of
+ * `a3d_prd11_instance_emissive_{vtx,frag}` (`batching/shaders/
+ * instanceEmissive.glsl.ts`). The instanced attribute arrives through the
+ * vertex buffer layout the Phase-6 device builds; these twins carry the
+ * varying declaration + helper both stages share.
+ */
+export const PRD11_INSTANCE_EMISSIVE_VTX_WGSL = /* wgsl */ `
+// vertex stage — @location input arrives via the instance-rate vertex buffer
+// (location 14, reserved for a_instanceEmissive by the bind layout builder)
+fn a3dInstanceEmissiveIn(input: vec3<f32>) -> vec3<f32> {
+  return input;
+}
+`;
+export const PRD11_INSTANCE_EMISSIVE_FRAG_WGSL = /* wgsl */ `
+// fragment stage — consumed through the interpolated varying
+struct A3dPrd11InstanceEmissiveFrag {
+  @location(14) v_a3dInstanceEmissive: vec3<f32>,
+};
+`;
+//# sourceMappingURL=instanceEmissive.wgsl.js.map

package/dist/program/chunks/instanceEmissive.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceEmissive.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/instanceEmissive.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,CAAC,MAAM,gCAAgC,GAAG,UAAU,CAAC;;;;;;CAM1D,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG,UAAU,CAAC;;;;;CAK3D,CAAC"}

package/dist/program/chunks/instancing.glsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `instancing` chunk (PRD-01 §8.5) — attribute-matrix instancing.
+ * Order is `world · instance · geometry` per C-07: `size ⊙ fit` folds into
+ * `u_geometryMatrix` and never scales instance translation.
+ */
+export declare const INSTANCING_VERTEX_PARS_GLSL = "\n#ifdef USE_INSTANCING\nlayout(location = 8) in vec4 a_instanceMatrix0;\nlayout(location = 9) in vec4 a_instanceMatrix1;\nlayout(location = 10) in vec4 a_instanceMatrix2;\nlayout(location = 11) in vec4 a_instanceMatrix3;\n#ifdef USE_INSTANCING_COLOR\nlayout(location = 12) in vec4 a_instanceColor;\n#endif\n#endif\n";
+export declare const INSTANCING_VERTEX_BODY_GLSL = "\n  mat4 instanceMatrix = mat4(1.0);\n#ifdef USE_INSTANCING\n  instanceMatrix = mat4(a_instanceMatrix0, a_instanceMatrix1, a_instanceMatrix2, a_instanceMatrix3);\n#endif\n  vec4 a3dLocal = u_geometryMatrix * vec4(transformed, 1.0);\n  vec4 a3dWorld = u_modelMatrix * instanceMatrix * a3dLocal;\n";
+//# sourceMappingURL=instancing.glsl.d.ts.map

package/dist/program/chunks/instancing.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instancing.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/instancing.glsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,2BAA2B,iUAUvC,CAAC;AAEF,eAAO,MAAM,2BAA2B,4SAOvC,CAAC"}

package/dist/program/chunks/instancing.glsl.js

@@ -0,0 +1,25 @@
+/**
+ * `instancing` chunk (PRD-01 §8.5) — attribute-matrix instancing.
+ * Order is `world · instance · geometry` per C-07: `size ⊙ fit` folds into
+ * `u_geometryMatrix` and never scales instance translation.
+ */
+export const INSTANCING_VERTEX_PARS_GLSL = /* glsl */ `
+#ifdef USE_INSTANCING
+layout(location = 8) in vec4 a_instanceMatrix0;
+layout(location = 9) in vec4 a_instanceMatrix1;
+layout(location = 10) in vec4 a_instanceMatrix2;
+layout(location = 11) in vec4 a_instanceMatrix3;
+#ifdef USE_INSTANCING_COLOR
+layout(location = 12) in vec4 a_instanceColor;
+#endif
+#endif
+`;
+export const INSTANCING_VERTEX_BODY_GLSL = /* glsl */ `
+  mat4 instanceMatrix = mat4(1.0);
+#ifdef USE_INSTANCING
+  instanceMatrix = mat4(a_instanceMatrix0, a_instanceMatrix1, a_instanceMatrix2, a_instanceMatrix3);
+#endif
+  vec4 a3dLocal = u_geometryMatrix * vec4(transformed, 1.0);
+  vec4 a3dWorld = u_modelMatrix * instanceMatrix * a3dLocal;
+`;
+//# sourceMappingURL=instancing.glsl.js.map

package/dist/program/chunks/instancing.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instancing.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/instancing.glsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;;;;CAUrD,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC;;;;;;;CAOrD,CAAC"}

package/dist/program/chunks/lights_legacy.glsl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `lights_legacy` chunk (PRD-01 §8.4) — default `fragment:lights` body helpers.
+ *
+ * Reads today's packed `u_lightData[96]` (6 vec4s per light:
+ * colorIntensity, positionRange, directionKind, spotShadowLayer, areaRight,
+ * areaUp; kind = directionKind.w: 0 dir, 1 point, 2 spot, >2.5 rect) so the
+ * generator is complete with every other lane's stub. Attenuation is the
+ * three.js r155+ `getDistanceAttenuation(d, cutoff, decay = 2)` — the legacy
+ * `max(d², 1)` coupling is removed inside this chunk only.
+ * The clustered path keeps `u_clusterLightData`/`u_clusterLightIndices`
+ * under `#ifdef LIGHTS_CLUSTERED`. Shadow gates (`spotShadowLayer.z`) are
+ * lane 02's C-11 — the default body does not sample shadows.
+ */
+export declare const LIGHTS_LEGACY_CHUNK_GLSL = "\nuniform vec4 u_lightData[96];\nuniform float u_lightCount;\n#ifdef LIGHTS_CLUSTERED\nuniform sampler2D u_clusterLightData;\nuniform sampler2D u_clusterLightIndices;\nuniform vec2 u_clusterGridSize;\nuniform vec2 u_clusterViewportSize;\n#endif\n\n// three.js r155+ physically based falloff: (1 - (d/cutoff)^4)^2 / pow(d, decay).\nfloat a3dGetDistanceAttenuation(float distanceToLight, float cutoffDistance, float decayExponent) {\n  float distanceFalloff = 1.0 / max(pow(distanceToLight, decayExponent), 0.01);\n  if (cutoffDistance > 0.0) {\n    float falloff = clamp(1.0 - pow(distanceToLight / cutoffDistance, 4.0), 0.0, 1.0);\n    distanceFalloff *= falloff * falloff;\n  }\n  return distanceFalloff;\n}\n\n// Decode one packed light: returns radiance reaching worldPos, out L = direction to light.\nvec3 a3dLegacyLightRadiance(int baseIndex, vec3 worldPos, out vec3 L) {\n  vec4 colorIntensity = u_lightData[baseIndex];\n  vec4 positionRange = u_lightData[baseIndex + 1];\n  vec4 directionKind = u_lightData[baseIndex + 2];\n  vec4 spotShadowLayer = u_lightData[baseIndex + 3];\n  float kind = directionKind.w;\n  if (kind < 0.5) {\n    // directional: directionKind.xyz = light->world direction\n    L = -directionKind.xyz;\n    return colorIntensity.rgb * colorIntensity.a;\n  }\n  vec3 toLight = positionRange.xyz - worldPos;\n  float distanceToLight = max(length(toLight), 0.0001);\n  L = toLight / distanceToLight;\n  float attenuation = a3dGetDistanceAttenuation(distanceToLight, positionRange.w, 2.0);\n  if (kind > 1.5) {\n    // spot: cone from packed angles (x outer radians, y penumbra fraction)\n    vec3 lightToFragment = normalize(worldPos - positionRange.xyz);\n    float cone = dot(normalize(directionKind.xyz), lightToFragment);\n    float outer = cos(spotShadowLayer.x);\n    float inner = cos(spotShadowLayer.x * max(1.0 - spotShadowLayer.y, 0.001));\n    attenuation *= smoothstep(outer, inner, cone);\n  }\n  return colorIntensity.rgb * colorIntensity.a * attenuation;\n}\n\n#ifdef LIGHTS_CLUSTERED\n// Clustered lookup for >8 lights: same packing from the cluster textures.\nint a3dClusterIndex(vec2 fragCoord) {\n  ivec2 clusterTile = clamp(\n    ivec2(floor(fragCoord / max(u_clusterViewportSize / u_clusterGridSize, vec2(1.0)))),\n    ivec2(0), ivec2(u_clusterGridSize) - ivec2(1)\n  );\n  return clusterTile.y * int(u_clusterGridSize.x) + clusterTile.x;\n}\nvec3 a3dClusteredLightRadiance(int lightIndex, vec3 worldPos, out vec3 L) {\n  vec4 colorIntensity = texelFetch(u_clusterLightData, ivec2(0, lightIndex), 0);\n  vec4 positionRange = texelFetch(u_clusterLightData, ivec2(1, lightIndex), 0);\n  vec4 directionKind = texelFetch(u_clusterLightData, ivec2(2, lightIndex), 0);\n  vec4 spotShadowLayer = texelFetch(u_clusterLightData, ivec2(3, lightIndex), 0);\n  float kind = directionKind.w;\n  if (kind < 0.5) {\n    L = -directionKind.xyz;\n    return colorIntensity.rgb * colorIntensity.a;\n  }\n  vec3 toLight = positionRange.xyz - worldPos;\n  float distanceToLight = max(length(toLight), 0.0001);\n  L = toLight / distanceToLight;\n  float attenuation = a3dGetDistanceAttenuation(distanceToLight, positionRange.w, 2.0);\n  if (kind > 1.5) {\n    vec3 lightToFragment = normalize(worldPos - positionRange.xyz);\n    float cone = dot(normalize(directionKind.xyz), lightToFragment);\n    float outer = cos(spotShadowLayer.x);\n    float inner = cos(spotShadowLayer.x * max(1.0 - spotShadowLayer.y, 0.001));\n    attenuation *= smoothstep(outer, inner, cone);\n  }\n  return colorIntensity.rgb * colorIntensity.a * attenuation;\n}\n#endif\n";
+//# sourceMappingURL=lights_legacy.glsl.d.ts.map

package/dist/program/chunks/lights_legacy.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lights_legacy.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/lights_legacy.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,wBAAwB,6/GAgFpC,CAAC"}

package/dist/program/chunks/lights_legacy.glsl.js

@@ -0,0 +1,95 @@
+/**
+ * `lights_legacy` chunk (PRD-01 §8.4) — default `fragment:lights` body helpers.
+ *
+ * Reads today's packed `u_lightData[96]` (6 vec4s per light:
+ * colorIntensity, positionRange, directionKind, spotShadowLayer, areaRight,
+ * areaUp; kind = directionKind.w: 0 dir, 1 point, 2 spot, >2.5 rect) so the
+ * generator is complete with every other lane's stub. Attenuation is the
+ * three.js r155+ `getDistanceAttenuation(d, cutoff, decay = 2)` — the legacy
+ * `max(d², 1)` coupling is removed inside this chunk only.
+ * The clustered path keeps `u_clusterLightData`/`u_clusterLightIndices`
+ * under `#ifdef LIGHTS_CLUSTERED`. Shadow gates (`spotShadowLayer.z`) are
+ * lane 02's C-11 — the default body does not sample shadows.
+ */
+export const LIGHTS_LEGACY_CHUNK_GLSL = /* glsl */ `
+uniform vec4 u_lightData[96];
+uniform float u_lightCount;
+#ifdef LIGHTS_CLUSTERED
+uniform sampler2D u_clusterLightData;
+uniform sampler2D u_clusterLightIndices;
+uniform vec2 u_clusterGridSize;
+uniform vec2 u_clusterViewportSize;
+#endif
+
+// three.js r155+ physically based falloff: (1 - (d/cutoff)^4)^2 / pow(d, decay).
+float a3dGetDistanceAttenuation(float distanceToLight, float cutoffDistance, float decayExponent) {
+  float distanceFalloff = 1.0 / max(pow(distanceToLight, decayExponent), 0.01);
+  if (cutoffDistance > 0.0) {
+    float falloff = clamp(1.0 - pow(distanceToLight / cutoffDistance, 4.0), 0.0, 1.0);
+    distanceFalloff *= falloff * falloff;
+  }
+  return distanceFalloff;
+}
+
+// Decode one packed light: returns radiance reaching worldPos, out L = direction to light.
+vec3 a3dLegacyLightRadiance(int baseIndex, vec3 worldPos, out vec3 L) {
+  vec4 colorIntensity = u_lightData[baseIndex];
+  vec4 positionRange = u_lightData[baseIndex + 1];
+  vec4 directionKind = u_lightData[baseIndex + 2];
+  vec4 spotShadowLayer = u_lightData[baseIndex + 3];
+  float kind = directionKind.w;
+  if (kind < 0.5) {
+    // directional: directionKind.xyz = light->world direction
+    L = -directionKind.xyz;
+    return colorIntensity.rgb * colorIntensity.a;
+  }
+  vec3 toLight = positionRange.xyz - worldPos;
+  float distanceToLight = max(length(toLight), 0.0001);
+  L = toLight / distanceToLight;
+  float attenuation = a3dGetDistanceAttenuation(distanceToLight, positionRange.w, 2.0);
+  if (kind > 1.5) {
+    // spot: cone from packed angles (x outer radians, y penumbra fraction)
+    vec3 lightToFragment = normalize(worldPos - positionRange.xyz);
+    float cone = dot(normalize(directionKind.xyz), lightToFragment);
+    float outer = cos(spotShadowLayer.x);
+    float inner = cos(spotShadowLayer.x * max(1.0 - spotShadowLayer.y, 0.001));
+    attenuation *= smoothstep(outer, inner, cone);
+  }
+  return colorIntensity.rgb * colorIntensity.a * attenuation;
+}
+
+#ifdef LIGHTS_CLUSTERED
+// Clustered lookup for >8 lights: same packing from the cluster textures.
+int a3dClusterIndex(vec2 fragCoord) {
+  ivec2 clusterTile = clamp(
+    ivec2(floor(fragCoord / max(u_clusterViewportSize / u_clusterGridSize, vec2(1.0)))),
+    ivec2(0), ivec2(u_clusterGridSize) - ivec2(1)
+  );
+  return clusterTile.y * int(u_clusterGridSize.x) + clusterTile.x;
+}
+vec3 a3dClusteredLightRadiance(int lightIndex, vec3 worldPos, out vec3 L) {
+  vec4 colorIntensity = texelFetch(u_clusterLightData, ivec2(0, lightIndex), 0);
+  vec4 positionRange = texelFetch(u_clusterLightData, ivec2(1, lightIndex), 0);
+  vec4 directionKind = texelFetch(u_clusterLightData, ivec2(2, lightIndex), 0);
+  vec4 spotShadowLayer = texelFetch(u_clusterLightData, ivec2(3, lightIndex), 0);
+  float kind = directionKind.w;
+  if (kind < 0.5) {
+    L = -directionKind.xyz;
+    return colorIntensity.rgb * colorIntensity.a;
+  }
+  vec3 toLight = positionRange.xyz - worldPos;
+  float distanceToLight = max(length(toLight), 0.0001);
+  L = toLight / distanceToLight;
+  float attenuation = a3dGetDistanceAttenuation(distanceToLight, positionRange.w, 2.0);
+  if (kind > 1.5) {
+    vec3 lightToFragment = normalize(worldPos - positionRange.xyz);
+    float cone = dot(normalize(directionKind.xyz), lightToFragment);
+    float outer = cos(spotShadowLayer.x);
+    float inner = cos(spotShadowLayer.x * max(1.0 - spotShadowLayer.y, 0.001));
+    attenuation *= smoothstep(outer, inner, cone);
+  }
+  return colorIntensity.rgb * colorIntensity.a * attenuation;
+}
+#endif
+`;
+//# sourceMappingURL=lights_legacy.glsl.js.map

package/dist/program/chunks/lights_legacy.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lights_legacy.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/lights_legacy.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFlD,CAAC"}

package/dist/program/chunks/manifest.d.ts

@@ -0,0 +1,42 @@
+/**
+ * PRD 11 Phase 6 groundwork (§7.3, ◦): WGSL twin manifest.
+ *
+ * C-02 `ShaderChunk.wgsl` is the twin field; chunks registered without it are
+ * reported — never fatal — until G-WGPU is a "go" (§6.2). Lane-11-owned
+ * chunks register their twins in `program/chunks/*.wgsl.ts` and pass them to
+ * `registerShaderChunk` directly; this manifest additionally records them so
+ * `manifestParity` can report coverage without a lane-01 enumeration API
+ * (requested via qr-request: `allShaderChunks()` on contracts/program.ts).
+ *
+ * `manifestParity(registered?)` takes an optional explicit list of
+ * `{name, owner}` descriptors — callers that do have chunk access (tests,
+ * the naga job) pass it; without it the manifest reports only the twins it
+ * knows about.
+ */
+export interface WgslTwinEntry {
+    readonly chunkName: string;
+    readonly owner: string;
+    readonly wgsl: string;
+}
+/** Record a WGSL twin for a registered C-02 chunk. Idempotent per name. */
+export declare function registerWgslTwin(entry: WgslTwinEntry): void;
+export declare function wgslTwinFor(chunkName: string): string | undefined;
+export declare function wgslTwins(): readonly WgslTwinEntry[];
+export interface ManifestParity {
+    readonly withTwin: number;
+    readonly missing: readonly {
+        readonly name: string;
+        readonly owner: string;
+    }[];
+}
+/**
+ * Compare the known registered chunks against the twin table.
+ * `registered` is optional until C-02 exposes enumeration; when omitted the
+ * report covers the manifest's own twin table (missing = []).
+ */
+export declare function manifestParity(registered?: readonly {
+    readonly name: string;
+    readonly owner?: string;
+    readonly wgsl?: string;
+}[]): ManifestParity;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/program/chunks/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAID,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAE3D;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,wBAAgB,SAAS,IAAI,SAAS,aAAa,EAAE,CAEpD;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,cAAc,CAcjJ"}