@aura3d/rendering 3.0.1 → 4.0.0

package/dist/vfx/shaders/lowresComposite.glsl.d.ts

@@ -0,0 +1,9 @@
+export interface LowResCompositeDefines {
+    /** Depth-aware bilateral upsample (scene depth available); else bilinear. */
+    readonly bilateral: boolean;
+}
+export declare const LOWRES_COMPOSITE_SHADER_MARKER = "a3d_prd07_lowres_composite";
+export declare function lowResCompositeVertexSource(): string;
+export declare function lowResCompositeFragmentSource(defines: LowResCompositeDefines): string;
+export declare function lowResCompositeProgramKey(defines: LowResCompositeDefines): string;
+//# sourceMappingURL=lowresComposite.glsl.d.ts.map

package/dist/vfx/shaders/lowresComposite.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowresComposite.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/lowresComposite.glsl.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,sBAAsB;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,eAAO,MAAM,8BAA8B,+BAA+B,CAAC;AAE3E,wBAAgB,2BAA2B,IAAI,MAAM,CAUpD;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CA2CrF;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAEjF"}

package/dist/vfx/shaders/lowresComposite.glsl.js

@@ -0,0 +1,64 @@
+// PRD-07 P6-T4 — §6.2 optional half-resolution particle composite. Upsamples the
+// lowRes particle RT into the scene color target: depth-aware bilateral when
+// scene depth is bound (edge-preserving at geometry silhouettes), plain bilinear
+// otherwise.
+export const LOWRES_COMPOSITE_SHADER_MARKER = "a3d_prd07_lowres_composite";
+export function lowResCompositeVertexSource() {
+    return `#version 300 es
+// ${LOWRES_COMPOSITE_SHADER_MARKER}
+layout(location = 0) in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+  v_uv = a_pos * 0.5 + 0.5;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+}
+export function lowResCompositeFragmentSource(defines) {
+    const bilateral = `  vec2 base = (floor(v_uv * u_lowSize - 0.5) + 0.5) * u_lowTexel;
+  vec2 f = fract(v_uv * u_lowSize - 0.5);
+  float d0 = linearizeDepth(texture(u_sceneDepth, v_uv).x);
+  vec4 sum = vec4(0.0);
+  float wsum = 0.0;
+  for (int j = 0; j < 2; j++) {
+    for (int i = 0; i < 2; i++) {
+      vec2 tap = base + vec2(float(i), float(j)) * u_lowTexel;
+      float w = (i == 0 ? 1.0 - f.x : f.x) * (j == 0 ? 1.0 - f.y : f.y);
+      float di = linearizeDepth(texture(u_sceneDepth, tap).x);
+      w *= exp(-abs(d0 - di) * u_bilateralSharpness);
+      sum += texture(u_lowRes, tap) * w;
+      wsum += w;
+    }
+  }
+  fragColor = wsum > 1e-5 ? sum / wsum : texture(u_lowRes, v_uv);`;
+    const bilinear = `  fragColor = texture(u_lowRes, v_uv);`;
+    return `#version 300 es
+// ${LOWRES_COMPOSITE_SHADER_MARKER}
+${defines.bilateral ? "#define BILATERAL 1\n" : ""}precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_lowRes;
+#ifdef BILATERAL
+uniform sampler2D u_sceneDepth;
+uniform vec4 u_depthLinearize; // near, far, orthographic, unused
+uniform vec2 u_lowTexel;       // 1 / low-res target size
+uniform vec2 u_lowSize;        // low-res target size
+uniform float u_bilateralSharpness;
+#endif
+out vec4 fragColor;
+#ifdef BILATERAL
+float linearizeDepth(float d) {
+  float z = d * 2.0 - 1.0;
+  return u_depthLinearize.z > 0.5
+    ? mix(u_depthLinearize.x, u_depthLinearize.y, d)
+    : (2.0 * u_depthLinearize.x * u_depthLinearize.y) / (u_depthLinearize.y + u_depthLinearize.x - z * (u_depthLinearize.y - u_depthLinearize.x));
+}
+#endif
+void main() {
+${defines.bilateral ? bilateral : bilinear}
+}
+`;
+}
+export function lowResCompositeProgramKey(defines) {
+    return `prd07.lowresComposite.${defines.bilateral ? "bilateral" : "bilinear"}`;
+}
+//# sourceMappingURL=lowresComposite.glsl.js.map

package/dist/vfx/shaders/lowresComposite.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowresComposite.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/lowresComposite.glsl.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,6EAA6E;AAC7E,iFAAiF;AACjF,aAAa;AAOb,MAAM,CAAC,MAAM,8BAA8B,GAAG,4BAA4B,CAAC;AAE3E,MAAM,UAAU,2BAA2B;IACzC,OAAO;KACJ,8BAA8B;;;;;;;CAOlC,CAAC;AACF,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAC,OAA+B;IAC3E,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;kEAe8C,CAAC;IACjE,MAAM,QAAQ,GAAG,wCAAwC,CAAC;IAC1D,OAAO;KACJ,8BAA8B;EACjC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;EAoBhD,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;;CAEzC,CAAC;AACF,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,OAA+B;IACvE,OAAO,yBAAyB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;AACjF,CAAC"}

package/dist/vfx/shaders/mesh-particle.glsl.d.ts

@@ -0,0 +1,4 @@
+export declare const MESH_PARTICLE_SHADER_MARKER = "prd07-mesh-particle-v1";
+export declare function meshParticleVertexSource(): string;
+export declare function meshParticleFragmentSource(): string;
+//# sourceMappingURL=mesh-particle.glsl.d.ts.map

package/dist/vfx/shaders/mesh-particle.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-particle.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/mesh-particle.glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE,wBAAgB,wBAAwB,IAAI,MAAM,CAyBjD;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAuBnD"}

package/dist/vfx/shaders/mesh-particle.glsl.js

@@ -0,0 +1,55 @@
+// PRD-07 P2-T6 — mesh-particle shader (§6.2.11): Lambert + a3dSampleIrradianceSH
+// (C-02 sh9 chunk uniform block) + emissive. Per-instance mat4 + colour +
+// emissive ride `instanceAttributes`; the opaque queue draws once per batch.
+export const MESH_PARTICLE_SHADER_MARKER = "prd07-mesh-particle-v1";
+export function meshParticleVertexSource() {
+    return `#version 300 es
+// ${MESH_PARTICLE_SHADER_MARKER} vertex
+precision highp float;
+in vec3 a_position;
+in vec3 a_normal;
+in vec4 a_instance0;
+in vec4 a_instance1;
+in vec4 a_instance2;
+in vec4 a_instance3;
+in vec4 a_color;
+in vec3 a_emissive;
+uniform mat4 u_viewProjection;
+out vec3 v_normal;
+out vec4 v_color;
+out vec3 v_emissive;
+void main() {
+  mat4 inst = mat4(a_instance0, a_instance1, a_instance2, a_instance3);
+  mat3 rot = mat3(inst);
+  v_normal = rot * a_normal;
+  v_color = a_color;
+  v_emissive = a_emissive;
+  gl_Position = u_viewProjection * inst * vec4(a_position, 1.0);
+}
+`;
+}
+export function meshParticleFragmentSource() {
+    return `#version 300 es
+// ${MESH_PARTICLE_SHADER_MARKER} fragment
+precision highp float;
+in vec3 v_normal;
+in vec4 v_color;
+in vec3 v_emissive;
+uniform vec3 u_sunDirection;
+uniform vec3 u_sunColor;
+uniform vec4 u_sh9[9];   // A3DSH9 — a3dSampleIrradianceSH convention (C-02 stub: L0 only)
+layout(location = 0) out vec4 o_color;
+vec3 a3dSampleIrradianceSH(vec3 N) {
+  // C-02 stub shape: L0 band only until the prd02 sh9 chunk is real.
+  return u_sh9[0].rgb * 0.282095;
+}
+void main() {
+  vec3 N = normalize(v_normal);
+  float ndl = max(dot(N, normalize(u_sunDirection)), 0.0);
+  vec3 ambient = a3dSampleIrradianceSH(N);
+  vec3 lit = v_color.rgb * (ambient + u_sunColor * ndl) + v_emissive;
+  o_color = vec4(lit, v_color.a);
+}
+`;
+}
+//# sourceMappingURL=mesh-particle.glsl.js.map

package/dist/vfx/shaders/mesh-particle.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-particle.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/mesh-particle.glsl.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,0EAA0E;AAC1E,6EAA6E;AAE7E,MAAM,CAAC,MAAM,2BAA2B,GAAG,wBAAwB,CAAC;AAEpE,MAAM,UAAU,wBAAwB;IACtC,OAAO;KACJ,2BAA2B;;;;;;;;;;;;;;;;;;;;;;CAsB/B,CAAC;AACF,CAAC;AAED,MAAM,UAAU,0BAA0B;IACxC,OAAO;KACJ,2BAA2B;;;;;;;;;;;;;;;;;;;;CAoB/B,CAAC;AACF,CAAC"}

package/dist/vfx/shaders/particle.glsl.d.ts

@@ -0,0 +1,24 @@
+import { type ShaderChunk } from "../../contracts/program.js";
+export declare const PARTICLE_SHADER_MARKER = "aura3d.prd07.particle";
+export interface ParticleProgramDefines {
+    readonly stretch: boolean;
+    readonly frameBlend: boolean;
+    readonly softParticles: boolean;
+    readonly blendAdditive: boolean;
+    readonly blendAdditiveFallback: boolean;
+    readonly unpremultiplyOutput: boolean;
+    readonly proceduralSoftDot: boolean;
+    readonly fogAnalytic: boolean;
+    /** Atlas texels are straight (non-premultiplied) alpha — premultiply after the sRGB decode (procedural flipbook sheets). */
+    readonly straightAlpha?: boolean;
+}
+export declare function particleProgramKey(d: ParticleProgramDefines): string;
+/** Full vertex stage source for a define set (GLSL ES 3.00, `#version` included). */
+export declare function particleVertexSource(d: ParticleProgramDefines): string;
+/** Full fragment stage source for a define set. */
+export declare function particleFragmentSource(d: ParticleProgramDefines): string;
+/** C-02 chunk records for the particle program stages. */
+export declare const PARTICLE_CHUNKS: readonly ShaderChunk[];
+/** Idempotent registration — safe to call from the lane barrel on every import. */
+export declare function registerParticleChunks(): void;
+//# sourceMappingURL=particle.glsl.d.ts.map

package/dist/vfx/shaders/particle.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/particle.glsl.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEhF,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAE9D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,4HAA4H;IAC5H,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAEpE;AAqLD,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAKtE;AAED,mDAAmD;AACnD,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAIxE;AAED,0DAA0D;AAC1D,eAAO,MAAM,eAAe,EAAE,SAAS,WAAW,EAGjD,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,sBAAsB,IAAI,IAAI,CAQ7C"}

package/dist/vfx/shaders/particle.glsl.js

@@ -0,0 +1,215 @@
+// PRD-07 P1-T9 — particle billboard program (PRD-07 §8.1), GLSL ES 3.00.
+// Compiled by PRD 07 itself through RenderDevice.createShaderProgram until the
+// C-02 ProgramCache is real; program keys use computeProgramKey-stable strings.
+import { registerShaderChunk } from "../../contracts/program.js";
+export const PARTICLE_SHADER_MARKER = "aura3d.prd07.particle";
+export function particleProgramKey(d) {
+    return `prd07.particle.${d.stretch ? "S" : ""}${d.frameBlend ? "F" : ""}${d.softParticles ? "O" : ""}${d.blendAdditive ? "B" : ""}${d.blendAdditiveFallback ? "A" : ""}${d.unpremultiplyOutput ? "U" : ""}${d.proceduralSoftDot ? "P" : ""}${d.fogAnalytic ? "G" : ""}${d.straightAlpha ? "T" : ""}`;
+}
+const VERT_BODY = `
+// ${PARTICLE_SHADER_MARKER} vertex
+in vec2 a_corner;
+in vec4 a_posSize;
+in vec4 a_velStretch;
+in vec4 a_color;
+in vec4 a_rotFrameMisc;
+
+uniform mat4 u_view;
+// Projection goes through the renderer's view-projection (the matrix every
+// other lane-07 pass and the forward pass use). FrameCamera.projectionMatrix
+// is the camera object's own matrix and falls back to identity when the
+// renderer resolves a non-Camera CameraLike — particles then rendered
+// unprojected across the frame (promote runs 38196483050 / 38200947584).
+uniform mat4 u_viewProjection;
+uniform vec4 u_atlasRect;
+uniform vec2 u_grid;
+
+out vec2 v_uv0;
+out vec2 v_uv1;
+out float v_frameT;
+out vec4 v_color;
+out float v_viewZ;
+out float v_fog;
+
+void main() {
+  vec3 P = a_posSize.xyz;
+  float size = a_posSize.w;
+  float rot = a_rotFrameMisc.x;
+  // Camera right/up in world space = rows 0/1 of the view rotation.
+  vec3 camRight = vec3(u_view[0][0], u_view[1][0], u_view[2][0]);
+  vec3 camUp = vec3(u_view[0][1], u_view[1][1], u_view[2][1]);
+  // Billboard basis in view space: +x right, +y up. STRETCH re-aims the up axis
+  // at the view-space velocity direction and lengthens it by speed.
+  vec2 up2 = vec2(0.0, 1.0);
+  float stretch = 1.0;
+#if STRETCH
+  vec3 velView = (u_view * vec4(a_velStretch.xyz, 0.0)).xyz;
+  float speed2 = length(velView.xy);
+  if (speed2 > 1e-4) {
+    up2 = normalize(velView.xy);
+    stretch = 1.0 + a_velStretch.w * length(a_velStretch.xyz);
+  }
+#endif
+  vec2 right2 = vec2(-up2.y, up2.x);
+  float c = cos(rot);
+  float s = sin(rot);
+  vec2 k = vec2(c * a_corner.x - s * a_corner.y, s * a_corner.x + c * a_corner.y);
+  vec2 off = right2 * (k.x * size * 0.5) + up2 * (k.y * size * 0.5 * stretch);
+  vec3 world = P + camRight * off.x + camUp * off.y;
+  gl_Position = u_viewProjection * vec4(world, 1.0);
+  // Perspective clip w = view-space distance along -Z.
+  v_viewZ = gl_Position.w;
+  float frames = max(u_grid.x * u_grid.y, 1.0);
+  float f = clamp(a_rotFrameMisc.y, 0.0, frames - 1.0);
+  float f0 = floor(f);
+  float f1 = min(f0 + 1.0, frames - 1.0);
+  v_frameT = f - f0;
+  vec2 cell = vec2(1.0) / u_grid;
+  vec2 local = a_corner * 0.5 + 0.5;
+  v_uv0 = u_atlasRect.xy + (vec2(mod(f0, u_grid.x), u_grid.y - 1.0 - floor(f0 / u_grid.x)) + local) * cell * u_atlasRect.zw;
+  v_uv1 = u_atlasRect.xy + (vec2(mod(f1, u_grid.x), u_grid.y - 1.0 - floor(f1 / u_grid.x)) + local) * cell * u_atlasRect.zw;
+  v_color = a_color;
+  v_fog = a_rotFrameMisc.z;
+}
+`;
+const FRAG_BODY = `
+// ${PARTICLE_SHADER_MARKER} fragment
+uniform sampler2D u_atlas;
+uniform float u_nearFade;
+uniform float u_cameraNear;
+uniform float u_softDistance;
+uniform vec3 u_fogColor;
+uniform float u_fogDensity;
+// §6.2.7 — 0: linear output into the HDR scene target; 1: legacy forward
+// encode (filmic + sRGB) matching EnvironmentBackgroundPass's convention.
+uniform float u_outputColorSpace;
+#if SOFT_PARTICLES
+uniform highp sampler2D u_sceneDepth;
+uniform vec4 u_depthLinearize; // near, far, orthographic, unused
+#endif
+
+in vec2 v_uv0;
+in vec2 v_uv1;
+in float v_frameT;
+in vec4 v_color;
+in float v_viewZ;
+in float v_fog;
+
+layout(location=0) out vec4 o_color;
+layout(location=2) out vec4 o_reactive; // C-14 writesReactive
+
+vec3 a3dLinearToSrgb(vec3 linear) {
+  vec3 clamped = max(linear, vec3(0.0));
+  vec3 low = clamped * 12.92;
+  vec3 high = 1.055 * pow(clamped, vec3(1.0 / 2.4)) - 0.055;
+  return mix(low, high, step(vec3(0.0031308), clamped));
+}
+
+vec3 a3dParticleEncodeOutput(vec3 linearColor) {
+  vec3 color = max(linearColor, vec3(0.0));
+  vec3 filmic = clamp((color * (2.51 * color + 0.03)) / (color * (2.43 * color + 0.59) + 0.14), vec3(0.0), vec3(1.0));
+  vec3 srgb = a3dLinearToSrgb(filmic);
+  return mix(color, srgb, step(0.5, u_outputColorSpace));
+}
+
+#if SOFT_PARTICLES
+float a3dSceneViewZ(float depth) {
+  if (u_depthLinearize.z > 0.5) return mix(u_depthLinearize.x, u_depthLinearize.y, depth);
+  return u_depthLinearize.x * u_depthLinearize.y /
+    max(u_depthLinearize.y - depth * (u_depthLinearize.y - u_depthLinearize.x), 1e-4);
+}
+#endif
+
+void main() {
+#if PROCEDURAL_SOFT_DOT
+  vec2 q = v_uv0 * 2.0 - 1.0;
+  // Premultiplied like the atlas path (rgb is multiplied by t.rgb below, not
+  // t.a): rgb = 1 drew every sprite as a full-intensity square under additive
+  // and premultiplied-over blending instead of a disc.
+  // Soft-dot radial profile: 1 at the centre, 0.55 at r = 0.35, 0 at the rim
+  // (piecewise linear — the classic radial-gradient point sprite). The old
+  // smoothstep(1, 0.62, r^2) was solid out to r ~ 0.79 and carried ~2.8x the
+  // coverage, so every soft-dot sprite read as a hard bright disc (promote
+  // run 38208531335: 14-particles / fountain / soft-particles / lit-smoke).
+  float r = length(q);
+  float dotA = r < 0.35 ? 1.0 - (0.45 / 0.35) * r : 0.55 * clamp((1.0 - r) / 0.65, 0.0, 1.0);
+  vec4 t = vec4(vec3(dotA), dotA);
+#else
+  vec4 t = texture(u_atlas, v_uv0);
+#if FRAME_BLEND
+  t = mix(t, texture(u_atlas, v_uv1), v_frameT);
+#endif
+#if STRAIGHT_ALPHA
+  t.rgb *= t.a;   // straight-alpha sheet: premultiply in linear after the sRGB decode
+#endif
+#endif
+  float fade = v_color.a;
+  fade *= clamp((v_viewZ - u_cameraNear) / u_nearFade, 0.0, 1.0);
+#if SOFT_PARTICLES
+  float sceneZ = a3dSceneViewZ(texelFetch(u_sceneDepth, ivec2(gl_FragCoord.xy), 0).r);
+  fade *= clamp((sceneZ - v_viewZ) / max(u_softDistance, 1e-3), 0.0, 1.0);
+#endif
+  float a = t.a * fade;
+  vec3 rgb = t.rgb * v_color.rgb * fade;   // atlas is premultiplied; rgb stays premultiplied
+#if FOG_ANALYTIC
+  float fogT = 1.0 - exp(-u_fogDensity * u_fogDensity * v_viewZ * v_viewZ);
+  fogT = clamp(fogT * v_fog, 0.0, 1.0);
+#endif
+#if BLEND_ADDITIVE
+  // §8.1: fog fades emitted light; alpha unused under (ONE, ONE).
+#if FOG_ANALYTIC
+  rgb *= (1.0 - fogT);
+#endif
+  rgb = a3dParticleEncodeOutput(rgb);
+  o_color = vec4(rgb, 0.0);
+#else
+#if FOG_ANALYTIC
+  rgb = mix(rgb, u_fogColor * a, fogT);    // fog the sprite's coverage, keep premultiplication
+#endif
+#if UNPREMULTIPLY_OUTPUT
+  rgb = rgb / max(a, 1e-4);
+  rgb = min(rgb, vec3(64.0));
+#endif
+#if BLEND_ADDITIVE_FALLBACK
+  rgb *= 1.6; // §6.2.7 core boost: approximate additive accumulation under alpha-over
+#endif
+  rgb = a3dParticleEncodeOutput(rgb);
+  o_color = vec4(rgb, a);
+#endif
+  o_reactive = vec4(a);
+}
+`;
+function define(name, on) {
+    return on ? `#define ${name} 1\n` : `#define ${name} 0\n`;
+}
+/** Full vertex stage source for a define set (GLSL ES 3.00, `#version` included). */
+export function particleVertexSource(d) {
+    return `#version 300 es
+precision highp float;
+precision highp int;
+${define("STRETCH", d.stretch)}${VERT_BODY}`;
+}
+/** Full fragment stage source for a define set. */
+export function particleFragmentSource(d) {
+    return `#version 300 es
+precision highp float;
+${define("STRETCH", d.stretch)}${define("FRAME_BLEND", d.frameBlend)}${define("SOFT_PARTICLES", d.softParticles)}${define("BLEND_ADDITIVE", d.blendAdditive)}${define("BLEND_ADDITIVE_FALLBACK", d.blendAdditiveFallback)}${define("UNPREMULTIPLY_OUTPUT", d.unpremultiplyOutput)}${define("PROCEDURAL_SOFT_DOT", d.proceduralSoftDot)}${define("FOG_ANALYTIC", d.fogAnalytic)}${define("STRAIGHT_ALPHA", d.straightAlpha === true)}${FRAG_BODY}`;
+}
+/** C-02 chunk records for the particle program stages. */
+export const PARTICLE_CHUNKS = [
+    { name: "a3d_prd07_particle_vertex", owner: "prd07", stage: "vertex", glsl: VERT_BODY },
+    { name: "a3d_prd07_particle_fragment", owner: "prd07", stage: "fragment", glsl: FRAG_BODY }
+];
+/** Idempotent registration — safe to call from the lane barrel on every import. */
+export function registerParticleChunks() {
+    for (const chunk of PARTICLE_CHUNKS) {
+        try {
+            registerShaderChunk(chunk);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message.startsWith("SHADER_CHUNK_DUPLICATE")))
+                throw error;
+        }
+    }
+}
+//# sourceMappingURL=particle.glsl.js.map

package/dist/vfx/shaders/particle.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/particle.glsl.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,+EAA+E;AAC/E,gFAAgF;AAEhF,OAAO,EAAE,mBAAmB,EAAoB,MAAM,yBAAyB,CAAC;AAEhF,MAAM,CAAC,MAAM,sBAAsB,GAAG,uBAAuB,CAAC;AAe9D,MAAM,UAAU,kBAAkB,CAAC,CAAyB;IAC1D,OAAO,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AACvS,CAAC;AAED,MAAM,SAAS,GAAG;KACb,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgE1B,CAAC;AAEF,MAAM,SAAS,GAAG;KACb,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyG1B,CAAC;AAEF,SAAS,MAAM,CAAC,IAAY,EAAE,EAAW;IACvC,OAAO,EAAE,CAAC,CAAC,CAAC,WAAW,IAAI,MAAM,CAAC,CAAC,CAAC,WAAW,IAAI,MAAM,CAAC;AAC5D,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,oBAAoB,CAAC,CAAyB;IAC5D,OAAO;;;EAGP,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,SAAS,EAAE,CAAC;AAC7C,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,sBAAsB,CAAC,CAAyB;IAC9D,OAAO;;EAEP,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,yBAAyB,EAAE,CAAC,CAAC,qBAAqB,CAAC,GAAG,MAAM,CAAC,sBAAsB,EAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,aAAa,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC;AAClb,CAAC;AAED,0DAA0D;AAC1D,MAAM,CAAC,MAAM,eAAe,GAA2B;IACrD,EAAE,IAAI,EAAE,2BAA2B,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;IACvF,EAAE,IAAI,EAAE,6BAA6B,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;CAC5F,CAAC;AAEF,mFAAmF;AACnF,MAAM,UAAU,sBAAsB;IACpC,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;QACpC,IAAI,CAAC;YACH,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC;gBAAE,MAAM,KAAK,CAAC;QACnG,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/vfx/shaders/ribbon.glsl.d.ts

@@ -0,0 +1,9 @@
+export declare const RIBBON_SHADER_MARKER = "prd07-ribbon-v1";
+export declare function ribbonVertexSource(): string;
+export declare function ribbonFragmentSource(defines: {
+    readonly softParticles?: boolean;
+}): string;
+export declare function ribbonProgramKey(defines: {
+    readonly softParticles?: boolean;
+}): string;
+//# sourceMappingURL=ribbon.glsl.d.ts.map

package/dist/vfx/shaders/ribbon.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ribbon.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/ribbon.glsl.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,oBAAoB,CAAC;AAEtD,wBAAgB,kBAAkB,IAAI,MAAM,CAmB3C;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CA8B1F;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAEtF"}

package/dist/vfx/shaders/ribbon.glsl.js

@@ -0,0 +1,60 @@
+// PRD-07 P2-T4 — ribbon strip shaders (§6.2.9). The CPU pass expands point
+// rings into strips, so the shader is a plain lit/unlit textured strip with
+// per-vertex color and the ported alpha curve already baked in. Soft-depth and
+// the output encode follow the particle shader's §6.2.7 conventions.
+export const RIBBON_SHADER_MARKER = "prd07-ribbon-v1";
+export function ribbonVertexSource() {
+    return `#version 300 es
+// ${RIBBON_SHADER_MARKER} vertex
+precision highp float;
+in vec3 a_position;
+in vec3 a_normal;
+in vec2 a_uv;
+in vec4 a_color;
+uniform mat4 u_viewProjection;
+out vec2 v_uv;
+out vec4 v_color;
+out vec3 v_world;
+void main() {
+  v_uv = a_uv;
+  v_color = a_color;
+  v_world = a_position;
+  gl_Position = u_viewProjection * vec4(a_position, 1.0);
+}
+`;
+}
+export function ribbonFragmentSource(defines) {
+    return `#version 300 es
+// ${RIBBON_SHADER_MARKER} fragment
+precision highp float;
+in vec2 v_uv;
+in vec4 v_color;
+in vec3 v_world;
+uniform sampler2D u_sceneDepth;
+uniform vec4 u_depthLinearize; // near, far, orthographic
+uniform float u_outputColorSpace;
+layout(location = 0) out vec4 o_color;
+void main() {
+  float alpha = v_color.a;
+#ifdef SOFT_PARTICLES
+  // scene-depth fade — same linearize convention as particle.glsl (§6.2.7)
+  vec2 ndc = gl_FragCoord.xy / vec2(textureSize(u_sceneDepth, 0));
+  float d = texture(u_sceneDepth, ndc).r;
+  float sceneZ = u_depthLinearize.z > 0.5
+    ? mix(u_depthLinearize.x, u_depthLinearize.y, d)
+    : (u_depthLinearize.x * u_depthLinearize.y) / max(u_depthLinearize.y - d * (u_depthLinearize.y - u_depthLinearize.x), 1e-4);
+  float fragZ = gl_FragCoord.z / gl_FragCoord.w;
+  alpha *= clamp((sceneZ - fragZ) / 0.5, 0.0, 1.0);
+#endif
+  vec3 rgb = max(v_color.rgb * alpha, vec3(0.0));   // pow(x<0) is undefined (NaN on NVIDIA)
+  if (u_outputColorSpace > 0.5) {
+    rgb = pow(rgb, vec3(1.0 / 2.2));
+  }
+  o_color = vec4(rgb, alpha);
+}
+`;
+}
+export function ribbonProgramKey(defines) {
+    return `ribbon.${defines.softParticles ? "S" : "x"}`;
+}
+//# sourceMappingURL=ribbon.glsl.js.map

package/dist/vfx/shaders/ribbon.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ribbon.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/ribbon.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,4EAA4E;AAC5E,+EAA+E;AAC/E,qEAAqE;AAErE,MAAM,CAAC,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAEtD,MAAM,UAAU,kBAAkB;IAChC,OAAO;KACJ,oBAAoB;;;;;;;;;;;;;;;;CAgBxB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,OAA6C;IAChF,OAAO;KACJ,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,OAA6C;IAC5E,OAAO,UAAU,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AACvD,CAAC"}

package/dist/vfx/shaders/volume.glsl.d.ts

@@ -0,0 +1,5 @@
+export declare const PRD07_VOLUME_CHUNK_NAME = "a3d_prd07_volume";
+export declare const PRD07_VOLUME_CHUNK_GLSL = "\n// a3d_prd07_volume \u2014 \u00A78.2\nuniform vec3 u_volumeExtent;       // volume around the camera (world units)\nuniform vec3 u_fallVelocity;       // per-particle fall dir\u00B7speed\nuniform vec3 u_sway;               // sway amplitude per axis\nuniform float u_swayFreq;\nuniform float u_seed;\nuniform vec3 u_cameraPosition;\nuniform float u_volumeTime;\n\nvec3 a3dHash31(float x) {\n  vec3 p = fract(vec3(x) * vec3(0.1031, 0.1030, 0.0973));\n  p += vec3(dot(p, p.yzx + 33.33));\n  return fract((p.xxy + p.yzz) * p.zyx);\n}\n\n// \u00A78.2: hash position + fall + sway, wrapped around the camera.\nvec3 a3dProceduralVolumePos(int id, float t) {\n  vec3 h = a3dHash31(float(id) * 0.6180339 + u_seed);             // [0,1)^3\n  vec3 p = h * u_volumeExtent + u_fallVelocity * t + u_sway * sin(t * u_swayFreq + h.x * 6.2831);\n  return u_cameraPosition + mod(p - u_cameraPosition + u_volumeExtent * 0.5, u_volumeExtent) - u_volumeExtent * 0.5;\n}\n\n// Fade at volume edges to hide the wrap seam (\u00A78.2).\nfloat a3dProceduralVolumeEdgeFade(vec3 pos, vec3 extent) {\n  vec3 edge = abs(pos - u_cameraPosition);\n  vec3 f = clamp((extent * 0.5 - edge) / max(extent * 0.15, vec3(1e-4)), 0.0, 1.0);\n  return min(f.x, min(f.y, f.z));\n}\n";
+/** Idempotent registration — safe to call from the lane barrel. */
+export declare function registerPrd07VolumeChunk(): void;
+//# sourceMappingURL=volume.glsl.d.ts.map

package/dist/vfx/shaders/volume.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/volume.glsl.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAE1D,eAAO,MAAM,uBAAuB,+tCA6BnC,CAAC;AAEF,mEAAmE;AACnE,wBAAgB,wBAAwB,IAAI,IAAI,CAW/C"}

package/dist/vfx/shaders/volume.glsl.js

@@ -0,0 +1,52 @@
+// PRD-07 P5-T2 — §8.2 procedural volume source (rain/snow/marine snow/dust),
+// GLSL ES 3.00. Registered as chunk "a3d_prd07_volume"; the CPU mirror in
+// ProceduralVolumeEmitter.ts (a3dProceduralVolumePosCpu) keeps constants and
+// hashing identical so CPU-side culling matches the shader.
+import { registerShaderChunk } from "../../contracts/program.js";
+export const PRD07_VOLUME_CHUNK_NAME = "a3d_prd07_volume";
+export const PRD07_VOLUME_CHUNK_GLSL = `
+// ${PRD07_VOLUME_CHUNK_NAME} — §8.2
+uniform vec3 u_volumeExtent;       // volume around the camera (world units)
+uniform vec3 u_fallVelocity;       // per-particle fall dir·speed
+uniform vec3 u_sway;               // sway amplitude per axis
+uniform float u_swayFreq;
+uniform float u_seed;
+uniform vec3 u_cameraPosition;
+uniform float u_volumeTime;
+
+vec3 a3dHash31(float x) {
+  vec3 p = fract(vec3(x) * vec3(0.1031, 0.1030, 0.0973));
+  p += vec3(dot(p, p.yzx + 33.33));
+  return fract((p.xxy + p.yzz) * p.zyx);
+}
+
+// §8.2: hash position + fall + sway, wrapped around the camera.
+vec3 a3dProceduralVolumePos(int id, float t) {
+  vec3 h = a3dHash31(float(id) * 0.6180339 + u_seed);             // [0,1)^3
+  vec3 p = h * u_volumeExtent + u_fallVelocity * t + u_sway * sin(t * u_swayFreq + h.x * 6.2831);
+  return u_cameraPosition + mod(p - u_cameraPosition + u_volumeExtent * 0.5, u_volumeExtent) - u_volumeExtent * 0.5;
+}
+
+// Fade at volume edges to hide the wrap seam (§8.2).
+float a3dProceduralVolumeEdgeFade(vec3 pos, vec3 extent) {
+  vec3 edge = abs(pos - u_cameraPosition);
+  vec3 f = clamp((extent * 0.5 - edge) / max(extent * 0.15, vec3(1e-4)), 0.0, 1.0);
+  return min(f.x, min(f.y, f.z));
+}
+`;
+/** Idempotent registration — safe to call from the lane barrel. */
+export function registerPrd07VolumeChunk() {
+    try {
+        registerShaderChunk({
+            name: PRD07_VOLUME_CHUNK_NAME,
+            owner: "prd07",
+            stage: "vertex",
+            glsl: PRD07_VOLUME_CHUNK_GLSL
+        });
+    }
+    catch (error) {
+        if (!(error instanceof Error && error.message.startsWith("SHADER_CHUNK_DUPLICATE")))
+            throw error;
+    }
+}
+//# sourceMappingURL=volume.glsl.js.map

package/dist/vfx/shaders/volume.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/volume.glsl.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,0EAA0E;AAC1E,6EAA6E;AAC7E,4DAA4D;AAE5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,MAAM,CAAC,MAAM,uBAAuB,GAAG,kBAAkB,CAAC;AAE1D,MAAM,CAAC,MAAM,uBAAuB,GAAG;KAClC,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B3B,CAAC;AAEF,mEAAmE;AACnE,MAAM,UAAU,wBAAwB;IACtC,IAAI,CAAC;QACH,mBAAmB,CAAC;YAClB,IAAI,EAAE,uBAAuB;YAC7B,KAAK,EAAE,OAAO;YACd,KAAK,EAAE,QAAQ;YACf,IAAI,EAAE,uBAAuB;SAC9B,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC;YAAE,MAAM,KAAK,CAAC;IACnG,CAAC;AACH,CAAC"}

package/dist/webgl2/ContextLifecycle.d.ts

@@ -0,0 +1,43 @@
+import type { WebGL2DeviceHost } from "./DeviceHost.js";
+export interface WebGL2TextureUnit0Snapshot {
+    readonly activeTexture: GLenum;
+    readonly texture2d: WebGLTexture | null;
+    readonly sampler: WebGLSampler | null;
+}
+export interface WebGL2TextureUnitBindingSnapshot {
+    readonly texture2d: WebGLTexture | null;
+    readonly sampler: WebGLSampler | null;
+}
+export declare class WebGL2ContextLifecycle {
+    readonly host: WebGL2DeviceHost;
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    constructor(host: WebGL2DeviceHost, canvas: HTMLCanvasElement | OffscreenCanvas);
+    readonly contextLostListener?: EventListener;
+    readonly contextRestoredListener?: EventListener;
+    readonly deviceLostListeners: Set<() => void>;
+    readonly deviceRestoredListeners: Set<() => void>;
+    /** Phase 5: hooks resolved before `deviceRestoredListeners` notify (§6.9). */
+    readonly restoredHooks: Set<() => Promise<void> | void>;
+    frameActive: boolean;
+    lastError: string | null;
+    viewportHeight: number;
+    viewportWidth: number;
+    onDeviceLost(listener: () => void): () => void;
+    onDeviceRestored(listener: () => void): () => void;
+    /** Register a restore hook; it must resolve before restored listeners fire. */
+    onRestoredHook(hook: () => Promise<void> | void): () => void;
+    private notifyRestoredListeners;
+    isDeviceLost(): boolean;
+    beginFrame(width: number, height: number): void;
+    clear(color: readonly [number, number, number, number]): void;
+    clearRenderTarget(color: readonly [number, number, number, number], attachment?: number): void;
+    endFrame(): void;
+    captureTextureUnit0(): WebGL2TextureUnit0Snapshot;
+    restoreTextureUnit0(snapshot: WebGL2TextureUnit0Snapshot): void;
+    captureTextureUnitBinding(unit: number): WebGL2TextureUnitBindingSnapshot;
+    restoreTextureUnitBinding(unit: number, snapshot: WebGL2TextureUnitBindingSnapshot): void;
+    assertAlive(): void;
+    assertFrame(): void;
+    readError(): string | null;
+}
+//# sourceMappingURL=ContextLifecycle.d.ts.map

package/dist/webgl2/ContextLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextLifecycle.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/webgl2/ContextLifecycle.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CACvC;AAED,qBAAa,sBAAsB;IACrB,QAAQ,CAAC,IAAI,EAAE,gBAAgB;IAAE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe;gBAA5E,IAAI,EAAE,gBAAgB,EAAW,MAAM,EAAE,iBAAiB,GAAG,eAAe;IA8CjG,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;IAE7C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,aAAa,CAAC;IAEjD,QAAQ,CAAC,mBAAmB,YAAiB,IAAI,EAAI;IAErD,QAAQ,CAAC,uBAAuB,YAAiB,IAAI,EAAI;IAEzD,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,YAAiB,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAAI;IAE/D,WAAW,UAAS;IAEpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAQ;IAEhC,cAAc,SAAK;IAEnB,aAAa,SAAK;IAElB,YAAY,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAK9C,gBAAgB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD,+EAA+E;IAC/E,cAAc,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,MAAM,IAAI;IAK5D,OAAO,CAAC,uBAAuB;IAU/B,YAAY,IAAI,OAAO;IAIvB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAuB/C,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAS7D,iBAAiB,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAgB9F,QAAQ,IAAI,IAAI;IAMhB,mBAAmB,IAAI,0BAA0B;IAUjD,mBAAmB,CAAC,QAAQ,EAAE,0BAA0B,GAAG,IAAI;IAO/D,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,gCAAgC;IAQzE,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,gCAAgC,GAAG,IAAI;IAMzF,WAAW,IAAI,IAAI;IASnB,WAAW,IAAI,IAAI;IAOnB,SAAS,IAAI,MAAM,GAAG,IAAI;CAI3B"}