@forgeax/engine-render 0.1.33 → 0.1.34

package/dist/cloud/density.d.ts

@@ -0,0 +1,55 @@
+import { type Result } from '@forgeax/engine-types';
+import { type CloudLayerError } from '../errors/cloud';
+import { type CloudQualityProfile, type ValidatedCloudLayer } from './parameters';
+export interface CloudDensityCache {
+    readonly sourceKey: string;
+    readonly resolution: number;
+    /** R8 normalized density values in z-major, y, x order. */
+    readonly data: Uint8Array;
+    /**
+     * Weather, body and erosion bases in three contiguous R8 planes. `data` is
+     * retained as a diagnostic projection for callers that still need the
+     * composed density; runtime sampling uses these formation planes so coverage,
+     * density and wind remain evaluation controls.
+     */
+    readonly formationData: Uint8Array;
+    readonly formationByteLength: number;
+    /** Bytes uploaded for the reusable formation planes. */
+    readonly byteLength: number;
+    readonly digest: string;
+}
+export interface CloudDensityCacheSnapshot {
+    readonly sourceKey: string;
+    readonly resolution: number;
+    readonly data: Uint8Array;
+    readonly formationData?: Uint8Array;
+    readonly digest: string;
+}
+export interface CloudDensitySample {
+    readonly density: number;
+    readonly heightFraction: number;
+    readonly noise: number;
+    readonly weather?: number;
+    readonly body?: number;
+    readonly erosion?: number;
+}
+export interface CloudFormationSample {
+    readonly weather: number;
+    readonly body: number;
+    readonly erosion: number;
+    readonly noise: number;
+}
+export declare const CLOUD_VERTICAL_CELLS = 1;
+/** Evaluate the reusable weather/body/erosion bases at one world position. */
+export declare function evaluateCloudFormation(params: ValidatedCloudLayer, position: ArrayLike<number>, timeSeconds?: number): CloudFormationSample;
+/** Analytic field used for cache generation, CPU diagnostics and recovery. */
+export declare function evaluateCloudDensity(params: ValidatedCloudLayer, position: ArrayLike<number>, timeSeconds?: number): CloudDensitySample;
+/** Build one canonical, periodic formation cache. */
+export declare function buildCloudDensityCache(params: ValidatedCloudLayer, profile?: CloudQualityProfile): CloudDensityCache;
+/** Export a detached snapshot suitable for persistence or a worker boundary. */
+export declare function snapshotCloudDensityCache(cache: CloudDensityCache): CloudDensityCacheSnapshot;
+/** Reconstruct a cache without running the procedural generator again. */
+export declare function reconstructCloudDensityCache(params: ValidatedCloudLayer, snapshot: CloudDensityCacheSnapshot): Result<CloudDensityCache, CloudLayerError>;
+/** Sample the cached field with periodic x/z addressing and wind advection. */
+export declare function sampleCloudDensity(cache: CloudDensityCache, params: ValidatedCloudLayer, position: ArrayLike<number>, timeSeconds?: number): number;
+//# sourceMappingURL=density.d.ts.map

package/dist/cloud/density.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"density.d.ts","sourceRoot":"","sources":["../../src/cloud/density.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAA+B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC;IACnC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAcD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAkQtC,8EAA8E;AAC9E,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,EAC3B,WAAW,SAAI,GACd,oBAAoB,CActB;AAED,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,EAC3B,WAAW,SAAI,GACd,kBAAkB,CAwBpB;AAiBD,qDAAqD;AACrD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,GAAE,mBAA4D,GACpE,iBAAiB,CA2CnB;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,iBAAiB,GAAG,yBAAyB,CAQ7F;AAED,0EAA0E;AAC1E,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,yBAAyB,GAClC,MAAM,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAqC5C;AAOD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,EAC3B,WAAW,SAAI,GACd,MAAM,CAiGR"}

package/dist/cloud/extract.d.ts

@@ -0,0 +1,25 @@
+import type { EntityHandle, World } from '@forgeax/engine-ecs';
+import { type Result } from '@forgeax/engine-types';
+import { type CloudLayerData } from '../components/cloud-layer';
+import { type CloudLayerError } from '../errors/cloud';
+import { type ValidatedCloudLayer } from './parameters';
+export interface CloudLayerCandidate {
+    readonly entityKey: EntityHandle;
+    readonly data: CloudLayerData;
+}
+export interface ExtractedCloudLayer {
+    readonly status: 'available';
+    readonly entityKey: EntityHandle;
+    readonly sourceKey: string;
+    readonly params: ValidatedCloudLayer;
+    readonly worldTimeSeconds: number;
+    /** First World-owned sun selected by the same extraction boundary. */
+    readonly sunDirection: readonly [number, number, number] | undefined;
+    readonly sunRadiance: readonly [number, number, number] | undefined;
+    readonly revision: number;
+}
+/** Select the one resource owner without creating a second World registry. */
+export declare function selectCloudLayerFrame(candidates: readonly CloudLayerCandidate[], worldTimeSeconds?: number, sunDirection?: readonly [number, number, number] | undefined, sunRadiance?: readonly [number, number, number] | undefined): Result<ExtractedCloudLayer | undefined, CloudLayerError>;
+/** Read the World-owned component and Time resource at the extraction boundary. */
+export declare function extractCloudLayer(world: World): Result<ExtractedCloudLayer | undefined, CloudLayerError>;
+//# sourceMappingURL=extract.d.ts.map

package/dist/cloud/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/cloud/extract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE5E,OAAO,EAAE,KAAK,eAAe,EAAgC,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAuB,KAAK,mBAAmB,EAAsB,MAAM,cAAc,CAAC;AAEjG,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACrE,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,gBAAgB,SAAI,EACpB,YAAY,GAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAqB,EACvE,WAAW,GAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAqB,GACrE,MAAM,CAAC,mBAAmB,GAAG,SAAS,EAAE,eAAe,CAAC,CAyB1D;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,GACX,MAAM,CAAC,mBAAmB,GAAG,SAAS,EAAE,eAAe,CAAC,CAgD1D"}

package/dist/cloud/feature.d.ts

@@ -0,0 +1,57 @@
+import type { RenderFeature } from '../features/types';
+import { type CloudDensityCache } from './density';
+import { type CloudLayerInspection } from './inspection';
+import { type ValidatedCloudLayer } from './parameters';
+import { type CloudShadowProjection } from './shadow';
+import { type CloudTemporalFrame } from './temporal';
+export declare const CLOUD_LAYER_FEATURE_IDENTITY = "forgeax.cloud-layer";
+export declare const CLOUD_LAYER_DENSITY_PROGRAM = "cloud-layer-density";
+export declare const CLOUD_LAYER_DENSITY_BINDINGS = "cloud-layer-density-bindings";
+export declare const CLOUD_LAYER_DENSITY_CACHE = "cloud-layer-density-cache";
+export declare const CLOUD_LAYER_DENSITY_OUTPUT = "cloud-layer-density-output";
+export declare const CLOUD_VIEW_PARAMS_BYTES = 176;
+/** Minimal copy compute; one invocation owns one packed u32 cache element. */
+export declare const CLOUD_DENSITY_COMPUTE_WGSL = "\nstruct CloudCacheParams { count: u32, }\n@group(0) @binding(0) var<storage, read> sourceDensity: array<u32>;\n@group(0) @binding(1) var<storage, read_write> cachedDensity: array<u32>;\n@group(0) @binding(2) var<uniform> params: CloudCacheParams;\n@compute @workgroup_size(64)\nfn cloud_density_cache(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x >= params.count) { return; }\n  cachedDensity[id.x] = sourceDensity[id.x];\n}\n";
+/**
+ * Cloud view transport. The View group is the renderer-owned camera/light
+ * source of truth; group(1) carries frame-local cloud parameters, depth and
+ * the bounded packed 3D cache. Camera, solar-column and cloud-interior
+ * integration all call cloud_density(), so wind only changes the sample
+ * coordinate and never the authored field.
+ */
+export declare const CLOUD_VIEW_FULLSCREEN_WGSL = "\nconst CLOUD_VERTICAL_CELLS: f32 = 1;\nconst CLOUD_VERTICAL_NOISE_CELLS: f32 = 2.0;\n\nstruct CloudCameraView {\n  worldViewProj: mat4x4<f32>,\n  lightDir: vec3<f32>,\n  lightColor: vec3<f32>,\n  cameraPos: vec3<f32>,\n  lightViewProj_A: mat4x4<f32>,\n  inverseViewProj: mat4x4<f32>,\n  lightViewProj_B: mat4x4<f32>,\n  lightViewProj_C: mat4x4<f32>,\n  lightViewProj_D: mat4x4<f32>,\n  splitPlanes: array<vec4<f32>, 4>,\n  cascadeCount: f32,\n  cascadeBlend: f32,\n  depthBias: f32,\n  normalBias: f32,\n  directionalShadowFilter: vec4<f32>,\n  spotLightViewProj: array<mat4x4<f32>, 4>,\n  temporalCurrentViewProj: mat4x4<f32>,\n  temporalPreviousViewProj: mat4x4<f32>,\n  temporalProjection: vec4<f32>,\n  temporalPreviousCameraPos: vec4<f32>,\n  ssrParams: vec4<f32>,\n};\n\nstruct CloudViewParams {\n  layer: vec4<f32>,       // baseHeight, thickness, scale, density\n  field: vec4<f32>,       // coverage, timeSeconds, maxDistance, seed\n  wind: vec4<f32>,        // xyz m/s\n  sunDirection: vec4<f32>,\n  sunRadiance: vec4<f32>,\n  integration: vec4<u32>, // cacheResolution, viewSteps, solarSteps, reserved\n  shadowOrigin: vec4<f32>,\n  shadowRight: vec4<f32>,\n  shadowUp: vec4<f32>,\n  shadowProjection: vec4<f32>, // range, valid, lowSun, texelSize\n  temporal: vec4<f32>,          // valid, reset, historyWeight, reserved\n};\n\n@group(0) @binding(0) var<uniform> view: CloudCameraView;\n@group(1) @binding(0) var sceneColor: texture_2d<f32>;\n@group(1) @binding(1) var sceneSampler: sampler;\n@group(1) @binding(2) var<uniform> cloud: CloudViewParams;\n@group(1) @binding(3) var sceneDepth: texture_depth_2d;\n@group(1) @binding(4) var depthSampler: sampler;\n@group(1) @binding(5) var previousRadiance: texture_2d<f32>;\n@group(1) @binding(6) var previousTransmittance: texture_2d<f32>;\n@group(1) @binding(7) var previousDepth: texture_2d<f32>;\n@group(1) @binding(8) var<storage, read> densityCache: array<u32>;\n\nstruct CloudViewOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\nfn cloud_hash3(cell: vec3<i32>, seed: u32) -> f32 {\n  var h = bitcast<u32>(cell.x) * 0x45d9f3bu;\n  h = (h ^ (bitcast<u32>(cell.y) * 0x119de1f3u)) * 0x45d9f3bu;\n  h = (h ^ (bitcast<u32>(cell.z) * 0x3449fu)) * 0x45d9f3bu;\n  h = h ^ seed;\n  h = (h ^ (h >> 16u)) * 0x45d9f3bu;\n  h = (h ^ (h >> 13u)) * 0x27d4eb2du;\n  return f32(h ^ (h >> 16u)) / 4294967296.0;\n}\n\nfn cloud_wrap_cell(value: i32, period: i32) -> i32 {\n  let wrapped = value % period;\n  return select(wrapped, wrapped + period, wrapped < 0);\n}\n\nfn cloud_hash3_periodic(\n  cell: vec3<i32>,\n  seed: u32,\n  periodX: i32,\n  periodY: i32,\n  periodZ: i32,\n) -> f32 {\n  return cloud_hash3(\n    vec3<i32>(\n      cloud_wrap_cell(cell.x, periodX),\n      cloud_wrap_cell(cell.y, periodY),\n      cloud_wrap_cell(cell.z, periodZ),\n    ),\n    seed,\n  );\n}\n\nfn cloud_value_noise(\n  position: vec3<f32>,\n  seed: u32,\n  periodX: i32,\n  periodY: i32,\n  periodZ: i32,\n) -> f32 {\n  let cell = vec3<i32>(floor(position));\n  let fraction = fract(position);\n  let smoothFraction = fraction * fraction * (3.0 - 2.0 * fraction);\n  let c000 = cloud_hash3_periodic(cell + vec3<i32>(0, 0, 0), seed, periodX, periodY, periodZ);\n  let c100 = cloud_hash3_periodic(cell + vec3<i32>(1, 0, 0), seed, periodX, periodY, periodZ);\n  let c010 = cloud_hash3_periodic(cell + vec3<i32>(0, 1, 0), seed, periodX, periodY, periodZ);\n  let c110 = cloud_hash3_periodic(cell + vec3<i32>(1, 1, 0), seed, periodX, periodY, periodZ);\n  let c001 = cloud_hash3_periodic(cell + vec3<i32>(0, 0, 1), seed, periodX, periodY, periodZ);\n  let c101 = cloud_hash3_periodic(cell + vec3<i32>(1, 0, 1), seed, periodX, periodY, periodZ);\n  let c011 = cloud_hash3_periodic(cell + vec3<i32>(0, 1, 1), seed, periodX, periodY, periodZ);\n  let c111 = cloud_hash3_periodic(cell + vec3<i32>(1, 1, 1), seed, periodX, periodY, periodZ);\n  let x00 = mix(c000, c100, smoothFraction.x);\n  let x10 = mix(c010, c110, smoothFraction.x);\n  let x01 = mix(c001, c101, smoothFraction.x);\n  let x11 = mix(c011, c111, smoothFraction.x);\n  return mix(mix(x00, x10, smoothFraction.y), mix(x01, x11, smoothFraction.y), smoothFraction.z);\n}\n\nfn cloud_cellular_noise(position: vec3<f32>, seed: u32, periodXZ: i32, periodY: i32) -> f32 {\n  let cell = vec3<i32>(floor(position));\n  let fraction = fract(position);\n  var nearest = 1e9;\n  var dz: i32 = -1;\n  loop {\n    var dy: i32 = -1;\n    loop {\n      var dx: i32 = -1;\n      loop {\n        let random = cloud_hash3_periodic(\n          cell + vec3<i32>(dx, dy, dz),\n          seed ^ 0x9e3779b9u,\n          periodXZ,\n          periodY,\n          periodXZ,\n        );\n        let point = vec3<f32>(\n          f32(dx) + fract(random * 17.0) - fraction.x,\n          f32(dy) + fract(random * 31.0) - fraction.y,\n          f32(dz) + fract(random * 47.0) - fraction.z,\n        );\n        nearest = min(nearest, dot(point, point));\n        if (dx >= 1) { break; }\n        dx = dx + 1;\n      }\n      if (dy >= 1) { break; }\n      dy = dy + 1;\n    }\n    if (dz >= 1) { break; }\n    dz = dz + 1;\n  }\n  return 1.0 - clamp(sqrt(nearest) * 1.25, 0.0, 1.0);\n}\n\nfn cloud_weather_field(position: vec3<f32>, seed: u32) -> f32 {\n  return smoothstep(\n    0.34,\n    0.66,\n    cloud_value_noise(\n      vec3<f32>(position.x * 2.0, 0.37, position.z * 2.0),\n      seed + 17041u,\n      2,\n      1,\n      2,\n    ),\n  );\n}\n\nfn cloud_formation_field(position: vec3<f32>, seed: u32) -> vec3<f32> {\n  let macroWarpX = cloud_value_noise(\n    vec3<f32>(position.x * 2.0, position.y * CLOUD_VERTICAL_NOISE_CELLS + 3.0, position.z * 2.0),\n    seed + 41023u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let macroWarpZ = cloud_value_noise(\n    vec3<f32>(position.x * 2.0 + 5.0, position.y * CLOUD_VERTICAL_NOISE_CELLS - 7.0, position.z * 2.0),\n    seed + 41023u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let bodyX = position.x + macroWarpX * 0.3;\n  let bodyZ = position.z + macroWarpZ * 0.3;\n  var noise = 0.0;\n  var weight = 0.0;\n  var amplitude = 0.5;\n  var frequency = 1.0;\n  for (var octave = 0u; octave < 4u; octave = octave + 1u) {\n    let tilePeriod = 4.0 * frequency;\n    noise = noise + cloud_value_noise(\n      vec3<f32>(bodyX * tilePeriod, position.y * frequency * CLOUD_VERTICAL_NOISE_CELLS, bodyZ * tilePeriod),\n      seed + octave * 1013u,\n      i32(tilePeriod),\n      i32(frequency * CLOUD_VERTICAL_NOISE_CELLS),\n      i32(tilePeriod),\n    ) * amplitude;\n    weight = weight + amplitude;\n    amplitude = amplitude * 0.4;\n    frequency = frequency * 2.0;\n  }\n  let broad = noise / max(0.0001, weight);\n  let cells = cloud_cellular_noise(\n    vec3<f32>(bodyX * 4.0, position.y * CLOUD_VERTICAL_NOISE_CELLS, bodyZ * 4.0),\n    seed + 5011u,\n    4,\n    i32(CLOUD_VERTICAL_NOISE_CELLS),\n  );\n  // Keep the broad field responsible for the cloud silhouette and use the\n  // cellular term as bounded breakup. A broad-dominant mix reads as fewer,\n  // wider formations instead of evenly spaced foam balls.\n  let base = clamp(broad * 0.85 + cells * 0.15 + 0.15, 0.0, 1.0);\n  let weather = cloud_weather_field(position, seed);\n  let detailPosition = position * 3.0;\n  let warpX = cloud_value_noise(\n    vec3<f32>(detailPosition.x * 2.0, detailPosition.y * 2.0 + 11.0, detailPosition.z * 2.0),\n    seed + 29011u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let warpZ = cloud_value_noise(\n    vec3<f32>(detailPosition.x * 2.0 + 7.0, detailPosition.y * 2.0 - 5.0, detailPosition.z * 2.0),\n    seed + 29011u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let erosion = cloud_cellular_noise(\n    vec3<f32>(\n      (detailPosition.x + warpX * 0.22) * 12.0,\n      detailPosition.y * 3.0,\n      (detailPosition.z + warpZ * 0.22) * 12.0,\n    ),\n    seed + 7919u,\n    12,\n    3,\n  );\n  return vec3<f32>(weather, base, erosion);\n}\n\nfn cloud_height_profile(height: f32, body: f32, weather: f32) -> f32 {\n  // A body-dependent crown breaks the fixed horizontal slab silhouette while\n  // keeping the profile smooth enough for the bounded ray step budget.\n  let lowerEdge = 0.05 + (1.0 - body) * 0.1;\n  let crownEdge = min(0.96, 0.6 + body * 0.3 + weather * 0.08);\n  let lower = smoothstep(lowerEdge, min(1.0, lowerEdge + 0.12), height);\n  let upper = 1.0 - smoothstep(crownEdge, min(1.0, crownEdge + 0.14), height);\n  return lower * upper;\n}\n\nfn cloud_compose_density(height: f32, formation: vec3<f32>, coverage: f32) -> f32 {\n  let threshold = 1.0 - coverage * (0.45 + formation.x * 0.55);\n  let covered = smoothstep(0.0, 0.4, (formation.y - threshold) / max(0.001, 1.0 - threshold));\n  let shaped = covered * cloud_height_profile(height, formation.y, formation.x);\n  let erosion = (1.0 - formation.z) * 0.18;\n  return clamp((shaped - erosion) / (1.0 - erosion), 0.0, 1.0);\n}\n\nfn cloud_analytic_density(position: vec3<f32>) -> f32 {\n  let height = (position.y - cloud.layer.x) / max(0.000001, cloud.layer.y);\n  if (height <= 0.0 || height >= 1.0 || cloud.layer.w <= 0.0 || cloud.field.x <= 0.0) { return 0.0; }\n  let advected = position + cloud.wind.xyz * cloud.field.y;\n  let advectedHeight = height +\n    cloud.wind.y * cloud.field.y * cloud.layer.z / max(CLOUD_VERTICAL_CELLS, 0.000001);\n  let p = vec3<f32>(\n    advected.x * cloud.layer.z,\n    fract(advectedHeight) * CLOUD_VERTICAL_CELLS,\n    advected.z * cloud.layer.z,\n  );\n  let formation = cloud_formation_field(p, u32(round(cloud.field.w)));\n  return cloud_compose_density(height, formation, cloud.field.x) * cloud.layer.w;\n}\n\nfn cloud_cache_byte(index: u32) -> f32 {\n  let word = densityCache[index >> 2u];\n  let shift = (index & 3u) * 8u;\n  return f32((word >> shift) & 255u) / 255.0;\n}\n\nfn cloud_cache_component(plane: u32, index: u32, stride: u32) -> f32 {\n  return cloud_cache_byte(plane * stride + index);\n}\n\nfn cloud_cache_trilinear(\n  plane: u32,\n  resolution: u32,\n  x0: u32,\n  x1: u32,\n  y0: u32,\n  y1: u32,\n  z0: u32,\n  z1: u32,\n  fx: f32,\n  fy: f32,\n  fz: f32,\n) -> f32 {\n  let stride = resolution * resolution * resolution;\n  let layer = resolution * resolution;\n  let c000 = cloud_cache_component(plane, z0 * layer + y0 * resolution + x0, stride);\n  let c100 = cloud_cache_component(plane, z0 * layer + y0 * resolution + x1, stride);\n  let c010 = cloud_cache_component(plane, z0 * layer + y1 * resolution + x0, stride);\n  let c110 = cloud_cache_component(plane, z0 * layer + y1 * resolution + x1, stride);\n  let c001 = cloud_cache_component(plane, z1 * layer + y0 * resolution + x0, stride);\n  let c101 = cloud_cache_component(plane, z1 * layer + y0 * resolution + x1, stride);\n  let c011 = cloud_cache_component(plane, z1 * layer + y1 * resolution + x0, stride);\n  let c111 = cloud_cache_component(plane, z1 * layer + y1 * resolution + x1, stride);\n  let x00 = mix(c000, c100, fx);\n  let x10 = mix(c010, c110, fx);\n  let x01 = mix(c001, c101, fx);\n  let x11 = mix(c011, c111, fx);\n  return mix(mix(x00, x10, fy), mix(x01, x11, fy), fz);\n}\n\nfn cloud_density(position: vec3<f32>) -> f32 {\n  let height = (position.y - cloud.layer.x) / max(0.000001, cloud.layer.y);\n  if (height <= 0.0 || height >= 1.0 || cloud.layer.w <= 0.0 || cloud.field.x <= 0.0) { return 0.0; }\n  let resolution = cloud.integration.x;\n  if (resolution < 4u) { return max(cloud_analytic_density(position), 0.0); }\n  let periodCoordinate = fract((position.xz + cloud.wind.xz * cloud.field.y) * cloud.layer.z);\n  let x = fract(periodCoordinate.x - 0.5 / f32(resolution)) * f32(resolution);\n  let z = fract(periodCoordinate.y - 0.5 / f32(resolution)) * f32(resolution);\n  let advectedHeight = height +\n    cloud.wind.y * cloud.field.y * cloud.layer.z / max(CLOUD_VERTICAL_CELLS, 0.000001);\n  let y = fract(advectedHeight - 0.5 / f32(resolution)) * f32(resolution);\n  let x0 = u32(floor(x));\n  let y0 = u32(floor(y));\n  let z0 = u32(floor(z));\n  let x1 = (x0 + 1u) % resolution;\n  let y1 = (y0 + 1u) % resolution;\n  let z1 = (z0 + 1u) % resolution;\n  let fx = x - f32(x0);\n  let fy = y - f32(y0);\n  let fz = z - f32(z0);\n  let weather = cloud_cache_trilinear(0u, resolution, x0, x1, y0, y1, z0, z1, fx, fy, fz);\n  let body = cloud_cache_trilinear(1u, resolution, x0, x1, y0, y1, z0, z1, fx, fy, fz);\n  // Repeat only the independent erosion plane: fine boundary structure with\n  // the same eight packed reads and the same cache allocation.\n  let detail = fract(vec3<f32>(periodCoordinate.x, advectedHeight, periodCoordinate.y) * 3.0 - vec3<f32>(0.5 / f32(resolution))) * f32(resolution);\n  let d0 = vec3<u32>(floor(detail));\n  let d1 = (d0 + vec3<u32>(1u)) % vec3<u32>(resolution);\n  let df = fract(detail);\n  let erosion = cloud_cache_trilinear(2u, resolution, d0.x, d1.x, d0.y, d1.y, d0.z, d1.z, df.x, df.y, df.z);\n  return cloud_compose_density(height, vec3<f32>(weather, body, erosion), cloud.field.x) * cloud.layer.w;\n}\n\nfn cloud_layer_interval(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> vec2<f32> {\n  if (abs(direction.y) < 0.000001) {\n    if (origin.y < cloud.layer.x || origin.y > cloud.layer.x + cloud.layer.y) {\n      return vec2<f32>(1.0, 0.0);\n    }\n    return vec2<f32>(0.0, maxDistance);\n  }\n  let lower = (cloud.layer.x - origin.y) / direction.y;\n  let upper = (cloud.layer.x + cloud.layer.y - origin.y) / direction.y;\n  return vec2<f32>(\n    max(0.0, min(lower, upper)),\n    min(maxDistance, max(lower, upper)),\n  );\n}\n\nfn cloud_solar_transmittance(position: vec3<f32>) -> f32 {\n  let sunDirection = normalize(-view.lightDir);\n  let solarDistance = select(cloud.field.z, cloud.shadowProjection.x, cloud.shadowProjection.x > 0.0);\n  let interval = cloud_layer_interval(position, sunDirection, solarDistance);\n  if (interval.y <= interval.x) { return 1.0; }\n  let steps = min(cloud.integration.z, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var opticalDepth = 0.0;\n  let solarJitter = cloud_solar_jitter(position);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let samplePosition = position + sunDirection * (interval.x + (f32(index) + solarJitter) * stepLength);\n    opticalDepth = opticalDepth + cloud_density(samplePosition) * 0.03 * stepLength;\n  }\n  return exp(-max(opticalDepth, 0.0));\n}\n\nfn cloud_henyey_greenstein(cosTheta: f32, g: f32) -> f32 {\n  let denominator = max(0.0001, 1.0 + g * g - 2.0 * g * cosTheta);\n  return (1.0 - g * g) / (denominator * sqrt(denominator)) * 0.0795774715;\n}\n\nfn cloud_phase(cosTheta: f32) -> f32 {\n  // A bounded dual lobe gives a readable forward highlight and a small\n  // back-scatter rim without another solar march.\n  return cloud_henyey_greenstein(cosTheta, 0.55) * 0.8 +\n    cloud_henyey_greenstein(cosTheta, -0.2) * 0.2;\n}\n\n// Reuse the same remaining-path optical depth for two bounded scattering\n// orders. This adds arithmetic only; no extra density or light-ray samples.\nfn cloud_incident_light(solarT: f32, cosTheta: f32, height: f32) -> vec3<f32> {\n  let direct = solarT * cloud_phase(cosTheta);\n  let multiple = (0.5 * pow(solarT, 0.5) + 0.25 * pow(solarT, 0.25)) * 0.0795774715;\n  let skyFill = mix(0.025, 0.075, smoothstep(0.1, 0.85, height));\n  // Match volume-integrate: the shared DirectionalLight value uses the\n  // unnormalized phase convention. Convert the normalized HG basis once.\n  return cloud.sunRadiance.xyz *\n    (vec3<f32>((direct + multiple) * 12.5663706144) + vec3<f32>(0.72, 0.84, 1.0) * skyFill);\n}\n\nfn cloud_ray_jitter(pixel: vec2<f32>) -> f32 {\n  // A stable per-pixel offset removes view-step contour bands without adding\n  // a frame-varying noise source that would fight temporal reprojection.\n  return fract(sin(dot(pixel, vec2<f32>(12.9898, 78.233))) * 43758.5453);\n}\n\nfn cloud_solar_jitter(position: vec3<f32>) -> f32 {\n  // Dither the light-column samples in world space so low shadow-step\n  // profiles do not paint parallel contour bands across cloud bases.\n  return fract(sin(dot(position.xz, vec2<f32>(19.193, 47.117))) * 15731.743);\n}\n\nfn reconstruct_world(uv: vec2<f32>, depth: f32) -> vec3<f32> {\n  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);\n  let world = view.inverseViewProj * ndc;\n  return world.xyz / max(abs(world.w), 0.00001);\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) index: u32) -> CloudViewOut {\n  var positions = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0),\n    vec2<f32>(3.0, -1.0),\n    vec2<f32>(-1.0, 3.0),\n  );\n  var output: CloudViewOut;\n  output.position = vec4<f32>(positions[index], 0.0, 1.0);\n  // WebGPU clip-space Y grows upward while sampled framebuffer rows and the\n  // depth texture use a top-left origin. Keep this one top-left UV for color,\n  // depth and inverse-projection reconstruction; flipping only the final\n  // color would leave the camera ray and depth cut mirrored.\n  output.uv = vec2<f32>(\n    positions[index].x * 0.5 + 0.5,\n    1.0 - (positions[index].y * 0.5 + 0.5),\n  );\n  return output;\n}\n\n@fragment\nfn fs_main(input: CloudViewOut) -> @location(0) vec4<f32> {\n  // The shadow producer uses this same production density/cache contract but\n  // rasterizes a camera-independent, texel-snapped light-space map. It does\n  // not consume scene colour; the generic fullscreen host still supplies the\n  // input binding to keep the feature binding ABI single and validated.\n  if (cloud.integration.w == 1u) {\n    let projection = cloud.shadowProjection;\n    if (projection.y < 0.5 || projection.z > 0.5 || projection.x <= 0.0) {\n      return vec4<f32>(1.0);\n    }\n    let offset = (input.uv - vec2<f32>(0.5)) * projection.x;\n    let receiver = cloud.shadowOrigin.xyz +\n      cloud.shadowRight.xyz * offset.x + cloud.shadowUp.xyz * offset.y;\n    let sunDirection = normalize(-view.lightDir);\n    let interval = cloud_layer_interval(receiver, sunDirection, projection.x);\n    if (interval.y <= interval.x) { return vec4<f32>(1.0); }\n    let steps = min(cloud.integration.z, 64u);\n    let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n    var opticalDepth = 0.0;\n    var firstHeight = 1.0;\n    var lastHeight = 0.0;\n    var occupied = false;\n    let solarJitter = cloud_solar_jitter(receiver);\n    for (var index = 0u; index < 64u; index = index + 1u) {\n      if (index >= steps) { break; }\n      let samplePosition = receiver + sunDirection *\n        (interval.x + (f32(index) + solarJitter) * stepLength);\n      let localDensity = cloud_density(samplePosition);\n      opticalDepth = opticalDepth + localDensity * 0.03 * stepLength;\n      if (localDensity > 0.0001) {\n        let sampleHeight = clamp(\n          (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y),\n          0.0,\n          1.0,\n        );\n        if (!occupied) { firstHeight = sampleHeight; }\n        lastHeight = sampleHeight;\n        occupied = true;\n      }\n    }\n    let transmittance = exp(-max(opticalDepth, 0.0));\n    // R stores full-column transmittance. G/B preserve the first/last\n    // occupied normalized layer heights so interior samples can estimate the\n    // remaining segment without pretending optical depth is uniform through\n    // the whole layer. A stores the integrated optical depth and distinguishes\n    // an empty projected column from a valid, nearly-clear one.\n    return vec4<f32>(\n      transmittance,\n      select(1.0, firstHeight, occupied),\n      select(0.0, lastHeight, occupied),\n      select(0.0, opticalDepth, occupied),\n    );\n  }\n  // The shadow producer branch above is per-fragment (its light-space\n  // interval depends on the rasterized receiver), so derivative-based\n  // sampling here would violate WGSL uniform-control-flow rules. The cloud\n  // scene path already owns an explicit level-0 sampler contract.\n  // Keep point semantics for the current full-resolution scene path. The\n  // half-resolution transport contract is introduced with its own resolve\n  // shader so this path retains the established depth convention.\n  let depthPixel = vec2<i32>(input.position.xy);\n  let depth = textureLoad(sceneDepth, depthPixel, 0);\n  let farWorld = reconstruct_world(input.uv, 1.0);\n  let sceneWorld = reconstruct_world(input.uv, clamp(depth, 0.0, 1.0));\n  let ray = normalize(farWorld - view.cameraPos);\n  let rayJitter = cloud_ray_jitter(input.position.xy);\n  let sceneDistance = select(cloud.field.z, length(sceneWorld - view.cameraPos), depth < 0.999999);\n  let interval = cloud_layer_interval(view.cameraPos, ray, sceneDistance);\n\n  // The depth producer shares the same camera ray, interval and density\n  // contract as the display path. It writes a cloud representative world\n  // position and a validity bit so history remains comparable after camera\n  // translation or rotation and never uses an opaque scene distance as a\n  // proxy for a participating medium.\n  if (cloud.integration.w == 2u) {\n    if (interval.y <= interval.x) { return vec4<f32>(sceneWorld, 0.0); }\n    let depthSteps = min(cloud.integration.y, 64u);\n    let depthStepLength = (interval.y - interval.x) / max(1.0, f32(depthSteps));\n    var depthTransmittance = 1.0;\n    var weightedDistance = 0.0;\n    var opticalWeight = 0.0;\n    for (var depthIndex = 0u; depthIndex < 64u; depthIndex = depthIndex + 1u) {\n      if (depthIndex >= depthSteps) { break; }\n      let sampleDistance = interval.x + (f32(depthIndex) + rayJitter) * depthStepLength;\n      let samplePosition = view.cameraPos + ray * sampleDistance;\n      let localDensity = cloud_density(samplePosition);\n      let localTransmittance = exp(-max(localDensity * 0.03 * depthStepLength, 0.0));\n      let weight = depthTransmittance * (1.0 - localTransmittance);\n      weightedDistance = weightedDistance + sampleDistance * weight;\n      opticalWeight = opticalWeight + weight;\n      depthTransmittance = depthTransmittance * localTransmittance;\n    }\n    let hasCloud = opticalWeight > 0.00001;\n    let representativeDistance = select(sceneDistance, weightedDistance / opticalWeight, hasCloud);\n    let representativeWorld = view.cameraPos + ray * representativeDistance;\n    return vec4<f32>(representativeWorld, select(0.0, 1.0, hasCloud));\n  }\n\n  let scene = textureSampleLevel(sceneColor, sceneSampler, input.uv, 0.0);\n  if (interval.y <= interval.x) { return scene; }\n  let steps = min(cloud.integration.y, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var transmittance = 1.0;\n  var scattering = vec3<f32>(0.0);\n  var weightedDistance = 0.0;\n  var opticalWeight = 0.0;\n  let sunDirection = normalize(-view.lightDir);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let distance = interval.x + (f32(index) + rayJitter) * stepLength;\n    let samplePosition = view.cameraPos + ray * distance;\n    let localDensity = cloud_density(samplePosition);\n    let extinction = localDensity * 0.03 * stepLength;\n    let localTransmittance = exp(-max(extinction, 0.0));\n    let depthWeight = transmittance * (1.0 - localTransmittance);\n    weightedDistance = weightedDistance + distance * depthWeight;\n    opticalWeight = opticalWeight + depthWeight;\n    // Empty samples are common in the separated-cloud field. Avoid a nested\n    // solar march for them and stop once the camera path is effectively opaque.\n    if (localDensity > 0.0001 && transmittance > 0.01) {\n      let solarTransmittance = cloud_solar_transmittance(samplePosition);\n      let cloudHeight = clamp(\n        (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y), 0.0, 1.0,\n      );\n      scattering = scattering + cloud_incident_light(\n        solarTransmittance, dot(ray, sunDirection), cloudHeight,\n      ) * depthWeight;\n    }\n    transmittance = transmittance * localTransmittance;\n    if (transmittance < 0.01) { break; }\n  }\n  let hasCloud = opticalWeight > 0.00001;\n  let representativeDistance = select(sceneDistance, weightedDistance / opticalWeight, hasCloud);\n  let representativeWorld = view.cameraPos + ray * representativeDistance;\n  // Wind is an advective coordinate change. Reproject the cloud point into\n  // the previous frame's world before applying the previous camera matrix;\n  // authored field values remain immutable.\n  let windDelta = cloud.wind.xyz * max(0.0, cloud.field.y - cloud.temporal.w);\n  // cloud_density evaluates the authored field at position + wind*time.\n  // Keeping the same field sample in the previous frame therefore advances\n  // the previous world point by the elapsed wind delta as well.\n  let previousCloudWorld = representativeWorld + windDelta;\n  let previousCloudClip = view.temporalPreviousViewProj * vec4<f32>(previousCloudWorld, 1.0);\n  let previousCloudNdc = previousCloudClip.xyz / max(abs(previousCloudClip.w), 0.00001);\n  let previousCloudUv = vec2<f32>(\n    previousCloudNdc.x * 0.5 + 0.5,\n    1.0 - (previousCloudNdc.y * 0.5 + 0.5),\n  );\n  let cloudInBounds = all(previousCloudUv >= vec2<f32>(0.0)) && all(previousCloudUv <= vec2<f32>(1.0));\n  let cloudHistoryUv = clamp(previousCloudUv, vec2<f32>(0.0), vec2<f32>(1.0));\n  let cloudHistoryDepthSample = textureSampleLevel(previousDepth, depthSampler, cloudHistoryUv, 0.0);\n  let cloudHistoryWorld = cloudHistoryDepthSample.xyz;\n  let previous = textureSampleLevel(previousRadiance, sceneSampler, cloudHistoryUv, 0.0);\n  let previousTransport = textureSampleLevel(\n    previousTransmittance,\n    sceneSampler,\n    cloudHistoryUv,\n    0.0,\n  );\n  let worldTolerance = max(0.05, length(previousCloudWorld - view.cameraPos) * 0.02);\n  let depthAccepted = cloudHistoryDepthSample.a > 0.5 &&\n    distance(cloudHistoryWorld, previousCloudWorld) <= worldTolerance;\n  let accepted =\n    hasCloud && cloud.temporal.x > 0.5 && cloud.temporal.y < 0.5 && cloudInBounds &&\n    depthAccepted && previousTransport.a > 0.0;\n  let historyWeight = select(0.0, clamp(cloud.temporal.z, 0.0, 0.95), accepted);\n  let cloudRadiance = mix(scattering, previous.rgb, historyWeight);\n  // Preserve scene-linear HDR output for the downstream material lane. The\n  // history owner receives cloudRadiance separately through the history pass.\n  return vec4<f32>(scene.rgb * transmittance + cloudRadiance, transmittance);\n}\n\n// The light-space shadow producer already paid for a bounded column integral.\n// Reuse that texel for camera samples instead of starting a full solar march\n// for every occupied camera step. Outside the occupied interval the cached\n// full-column transmittance is exact for the projected column. Inside the\n// interval, the cache supplies the stable projection/bounds and a short\n// residual march resolves the non-uniform density that a linear optical-depth\n// interpolation would lose. Invalid/out-of-range projections retain the\n// analytic path as an explicit fallback.\nfn cloud_solar_cached_transmittance(position: vec3<f32>) -> f32 {\n  let projection = cloud.shadowProjection;\n  if (projection.y < 0.5 || projection.x <= 0.0) {\n    return cloud_solar_transmittance(position);\n  }\n  let relative = position - cloud.shadowOrigin.xyz;\n  let uv = vec2<f32>(\n    dot(relative, cloud.shadowRight.xyz) / projection.x + 0.5,\n    dot(relative, cloud.shadowUp.xyz) / projection.x + 0.5,\n  );\n  if (any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0))) {\n    return cloud_solar_transmittance(position);\n  }\n  let cachedShadow = textureSampleLevel(previousRadiance, sceneSampler, uv, 0.0);\n  let cachedOpticalDepth = max(cachedShadow.a, 0.0);\n  let layerHeight = clamp(\n    (position.y - cloud.layer.x) / max(0.0001, cloud.layer.y),\n    0.0,\n    1.0,\n  );\n  if (cachedOpticalDepth <= 0.0001) { return 1.0; }\n  let firstHeight = clamp(cachedShadow.g, 0.0, 1.0);\n  let lastHeight = clamp(cachedShadow.b, 0.0, 1.0);\n  let occupiedMin = min(firstHeight, lastHeight);\n  let occupiedMax = max(firstHeight, lastHeight);\n  let sunDirection = normalize(-view.lightDir);\n  // G/B are ordered along the light ray, not necessarily bottom-to-top. Only\n  // use the cached full/empty fast paths when the light has enough vertical\n  // component to make that ordering meaningful; grazing light stays on the\n  // residual path so a low-sun column cannot invert the cache bounds.\n  if (abs(sunDirection.y) > 0.2) {\n    if (sunDirection.y > 0.0) {\n      if (layerHeight <= occupiedMin) { return exp(-cachedOpticalDepth); }\n      if (layerHeight >= occupiedMax) { return 1.0; }\n    } else {\n      if (layerHeight >= occupiedMax) { return exp(-cachedOpticalDepth); }\n      if (layerHeight <= occupiedMin) { return 1.0; }\n    }\n  }\n\n  // A short residual march is only paid for samples inside the projected\n  // cloud span. Vertical light uses twelve taps, oblique light sixteen, and\n  // grazing light up to thirty-two because the same layer projects across a\n  // much longer solar segment. This removes the large error caused by\n  // assuming optical depth is uniform between the first and last occupied\n  // heights while keeping the normal camera path far below a second full\n  // solar integration.\n  let solarDistance = select(cloud.field.z, projection.x, projection.x > 0.0);\n  let interval = cloud_layer_interval(position, sunDirection, solarDistance);\n  if (interval.y <= interval.x) { return 1.0; }\n  let absLightY = abs(sunDirection.y);\n  let directionBudget = select(\n    32u,\n    select(16u, 12u, absLightY > 0.5),\n    absLightY > 0.2,\n  );\n  let residualSteps = min(directionBudget, max(8u, cloud.integration.z * 3u));\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(residualSteps));\n  var opticalDepth = 0.0;\n  let solarJitter = cloud_solar_jitter(position);\n  for (var index = 0u; index < 32u; index = index + 1u) {\n    if (index >= residualSteps) { break; }\n    let samplePosition = position + sunDirection *\n      (interval.x + (f32(index) + solarJitter) * stepLength);\n    opticalDepth = opticalDepth + cloud_density(samplePosition) *\n      0.03 * stepLength;\n  }\n  return exp(-max(opticalDepth, 0.0));\n}\n\nstruct CloudTransportOutput {\n  @location(0) radiance: vec4<f32>,\n  @location(1) transmittance: vec4<f32>,\n  @location(2) depth: vec4<f32>,\n};\n\n// One half-resolution transport pass writes all three reusable cloud fields.\n// The full-resolution resolve below reconstructs colour and applies temporal\n// history; no second full raymarch exists solely to obtain cloud depth.\n@fragment\nfn fs_transport(input: CloudViewOut) -> CloudTransportOutput {\n  let depth = textureSampleLevel(sceneDepth, depthSampler, input.uv, 0u);\n  let farWorld = reconstruct_world(input.uv, 1.0);\n  let sceneWorld = reconstruct_world(input.uv, clamp(depth, 0.0, 1.0));\n  let ray = normalize(farWorld - view.cameraPos);\n  let rayJitter = cloud_ray_jitter(input.position.xy);\n  let sceneDistance = select(cloud.field.z, length(sceneWorld - view.cameraPos), depth < 0.999999);\n  let interval = cloud_layer_interval(view.cameraPos, ray, sceneDistance);\n  var output: CloudTransportOutput;\n  output.radiance = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n  output.transmittance = vec4<f32>(1.0, 1.0, 1.0, 1.0);\n  output.depth = vec4<f32>(sceneWorld, 0.0);\n  if (interval.y <= interval.x) { return output; }\n\n  let steps = min(cloud.integration.y, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var transmittance = 1.0;\n  var scattering = vec3<f32>(0.0);\n  var weightedDistance = 0.0;\n  var opticalWeight = 0.0;\n  let sunDirection = normalize(-view.lightDir);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let distance = interval.x + (f32(index) + rayJitter) * stepLength;\n    let samplePosition = view.cameraPos + ray * distance;\n    let localDensity = cloud_density(samplePosition);\n    let extinction = localDensity * 0.03 * stepLength;\n    let localTransmittance = exp(-max(extinction, 0.0));\n    let depthWeight = transmittance * (1.0 - localTransmittance);\n    weightedDistance = weightedDistance + distance * depthWeight;\n    opticalWeight = opticalWeight + depthWeight;\n    if (localDensity > 0.0001 && transmittance > 0.01) {\n      let solarTransmittance = cloud_solar_cached_transmittance(samplePosition);\n      let cloudHeight = clamp(\n        (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y), 0.0, 1.0,\n      );\n      scattering = scattering + cloud_incident_light(\n        solarTransmittance, dot(ray, sunDirection), cloudHeight,\n      ) * depthWeight;\n    }\n    transmittance = transmittance * localTransmittance;\n    if (transmittance < 0.01) { break; }\n  }\n  let hasCloud = opticalWeight > 0.00001;\n  let representativeDistance = select(sceneDistance, weightedDistance / max(opticalWeight, 0.00001), hasCloud);\n  output.radiance = vec4<f32>(scattering, select(0.0, 1.0, hasCloud));\n  output.transmittance = vec4<f32>(transmittance, transmittance, transmittance, 1.0);\n  output.depth = vec4<f32>(view.cameraPos + ray * representativeDistance, select(0.0, 1.0, hasCloud));\n  return output;\n}\n";
+/** Shared cloud transport module; `fs_transport` is selected by the MRT PSO. */
+export declare const CLOUD_TRANSPORT_FULLSCREEN_WGSL = "\nconst CLOUD_VERTICAL_CELLS: f32 = 1;\nconst CLOUD_VERTICAL_NOISE_CELLS: f32 = 2.0;\n\nstruct CloudCameraView {\n  worldViewProj: mat4x4<f32>,\n  lightDir: vec3<f32>,\n  lightColor: vec3<f32>,\n  cameraPos: vec3<f32>,\n  lightViewProj_A: mat4x4<f32>,\n  inverseViewProj: mat4x4<f32>,\n  lightViewProj_B: mat4x4<f32>,\n  lightViewProj_C: mat4x4<f32>,\n  lightViewProj_D: mat4x4<f32>,\n  splitPlanes: array<vec4<f32>, 4>,\n  cascadeCount: f32,\n  cascadeBlend: f32,\n  depthBias: f32,\n  normalBias: f32,\n  directionalShadowFilter: vec4<f32>,\n  spotLightViewProj: array<mat4x4<f32>, 4>,\n  temporalCurrentViewProj: mat4x4<f32>,\n  temporalPreviousViewProj: mat4x4<f32>,\n  temporalProjection: vec4<f32>,\n  temporalPreviousCameraPos: vec4<f32>,\n  ssrParams: vec4<f32>,\n};\n\nstruct CloudViewParams {\n  layer: vec4<f32>,       // baseHeight, thickness, scale, density\n  field: vec4<f32>,       // coverage, timeSeconds, maxDistance, seed\n  wind: vec4<f32>,        // xyz m/s\n  sunDirection: vec4<f32>,\n  sunRadiance: vec4<f32>,\n  integration: vec4<u32>, // cacheResolution, viewSteps, solarSteps, reserved\n  shadowOrigin: vec4<f32>,\n  shadowRight: vec4<f32>,\n  shadowUp: vec4<f32>,\n  shadowProjection: vec4<f32>, // range, valid, lowSun, texelSize\n  temporal: vec4<f32>,          // valid, reset, historyWeight, reserved\n};\n\n@group(0) @binding(0) var<uniform> view: CloudCameraView;\n@group(1) @binding(0) var sceneColor: texture_2d<f32>;\n@group(1) @binding(1) var sceneSampler: sampler;\n@group(1) @binding(2) var<uniform> cloud: CloudViewParams;\n@group(1) @binding(3) var sceneDepth: texture_depth_2d;\n@group(1) @binding(4) var depthSampler: sampler;\n@group(1) @binding(5) var previousRadiance: texture_2d<f32>;\n@group(1) @binding(6) var previousTransmittance: texture_2d<f32>;\n@group(1) @binding(7) var previousDepth: texture_2d<f32>;\n@group(1) @binding(8) var<storage, read> densityCache: array<u32>;\n\nstruct CloudViewOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\nfn cloud_hash3(cell: vec3<i32>, seed: u32) -> f32 {\n  var h = bitcast<u32>(cell.x) * 0x45d9f3bu;\n  h = (h ^ (bitcast<u32>(cell.y) * 0x119de1f3u)) * 0x45d9f3bu;\n  h = (h ^ (bitcast<u32>(cell.z) * 0x3449fu)) * 0x45d9f3bu;\n  h = h ^ seed;\n  h = (h ^ (h >> 16u)) * 0x45d9f3bu;\n  h = (h ^ (h >> 13u)) * 0x27d4eb2du;\n  return f32(h ^ (h >> 16u)) / 4294967296.0;\n}\n\nfn cloud_wrap_cell(value: i32, period: i32) -> i32 {\n  let wrapped = value % period;\n  return select(wrapped, wrapped + period, wrapped < 0);\n}\n\nfn cloud_hash3_periodic(\n  cell: vec3<i32>,\n  seed: u32,\n  periodX: i32,\n  periodY: i32,\n  periodZ: i32,\n) -> f32 {\n  return cloud_hash3(\n    vec3<i32>(\n      cloud_wrap_cell(cell.x, periodX),\n      cloud_wrap_cell(cell.y, periodY),\n      cloud_wrap_cell(cell.z, periodZ),\n    ),\n    seed,\n  );\n}\n\nfn cloud_value_noise(\n  position: vec3<f32>,\n  seed: u32,\n  periodX: i32,\n  periodY: i32,\n  periodZ: i32,\n) -> f32 {\n  let cell = vec3<i32>(floor(position));\n  let fraction = fract(position);\n  let smoothFraction = fraction * fraction * (3.0 - 2.0 * fraction);\n  let c000 = cloud_hash3_periodic(cell + vec3<i32>(0, 0, 0), seed, periodX, periodY, periodZ);\n  let c100 = cloud_hash3_periodic(cell + vec3<i32>(1, 0, 0), seed, periodX, periodY, periodZ);\n  let c010 = cloud_hash3_periodic(cell + vec3<i32>(0, 1, 0), seed, periodX, periodY, periodZ);\n  let c110 = cloud_hash3_periodic(cell + vec3<i32>(1, 1, 0), seed, periodX, periodY, periodZ);\n  let c001 = cloud_hash3_periodic(cell + vec3<i32>(0, 0, 1), seed, periodX, periodY, periodZ);\n  let c101 = cloud_hash3_periodic(cell + vec3<i32>(1, 0, 1), seed, periodX, periodY, periodZ);\n  let c011 = cloud_hash3_periodic(cell + vec3<i32>(0, 1, 1), seed, periodX, periodY, periodZ);\n  let c111 = cloud_hash3_periodic(cell + vec3<i32>(1, 1, 1), seed, periodX, periodY, periodZ);\n  let x00 = mix(c000, c100, smoothFraction.x);\n  let x10 = mix(c010, c110, smoothFraction.x);\n  let x01 = mix(c001, c101, smoothFraction.x);\n  let x11 = mix(c011, c111, smoothFraction.x);\n  return mix(mix(x00, x10, smoothFraction.y), mix(x01, x11, smoothFraction.y), smoothFraction.z);\n}\n\nfn cloud_cellular_noise(position: vec3<f32>, seed: u32, periodXZ: i32, periodY: i32) -> f32 {\n  let cell = vec3<i32>(floor(position));\n  let fraction = fract(position);\n  var nearest = 1e9;\n  var dz: i32 = -1;\n  loop {\n    var dy: i32 = -1;\n    loop {\n      var dx: i32 = -1;\n      loop {\n        let random = cloud_hash3_periodic(\n          cell + vec3<i32>(dx, dy, dz),\n          seed ^ 0x9e3779b9u,\n          periodXZ,\n          periodY,\n          periodXZ,\n        );\n        let point = vec3<f32>(\n          f32(dx) + fract(random * 17.0) - fraction.x,\n          f32(dy) + fract(random * 31.0) - fraction.y,\n          f32(dz) + fract(random * 47.0) - fraction.z,\n        );\n        nearest = min(nearest, dot(point, point));\n        if (dx >= 1) { break; }\n        dx = dx + 1;\n      }\n      if (dy >= 1) { break; }\n      dy = dy + 1;\n    }\n    if (dz >= 1) { break; }\n    dz = dz + 1;\n  }\n  return 1.0 - clamp(sqrt(nearest) * 1.25, 0.0, 1.0);\n}\n\nfn cloud_weather_field(position: vec3<f32>, seed: u32) -> f32 {\n  return smoothstep(\n    0.34,\n    0.66,\n    cloud_value_noise(\n      vec3<f32>(position.x * 2.0, 0.37, position.z * 2.0),\n      seed + 17041u,\n      2,\n      1,\n      2,\n    ),\n  );\n}\n\nfn cloud_formation_field(position: vec3<f32>, seed: u32) -> vec3<f32> {\n  let macroWarpX = cloud_value_noise(\n    vec3<f32>(position.x * 2.0, position.y * CLOUD_VERTICAL_NOISE_CELLS + 3.0, position.z * 2.0),\n    seed + 41023u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let macroWarpZ = cloud_value_noise(\n    vec3<f32>(position.x * 2.0 + 5.0, position.y * CLOUD_VERTICAL_NOISE_CELLS - 7.0, position.z * 2.0),\n    seed + 41023u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let bodyX = position.x + macroWarpX * 0.3;\n  let bodyZ = position.z + macroWarpZ * 0.3;\n  var noise = 0.0;\n  var weight = 0.0;\n  var amplitude = 0.5;\n  var frequency = 1.0;\n  for (var octave = 0u; octave < 4u; octave = octave + 1u) {\n    let tilePeriod = 4.0 * frequency;\n    noise = noise + cloud_value_noise(\n      vec3<f32>(bodyX * tilePeriod, position.y * frequency * CLOUD_VERTICAL_NOISE_CELLS, bodyZ * tilePeriod),\n      seed + octave * 1013u,\n      i32(tilePeriod),\n      i32(frequency * CLOUD_VERTICAL_NOISE_CELLS),\n      i32(tilePeriod),\n    ) * amplitude;\n    weight = weight + amplitude;\n    amplitude = amplitude * 0.4;\n    frequency = frequency * 2.0;\n  }\n  let broad = noise / max(0.0001, weight);\n  let cells = cloud_cellular_noise(\n    vec3<f32>(bodyX * 4.0, position.y * CLOUD_VERTICAL_NOISE_CELLS, bodyZ * 4.0),\n    seed + 5011u,\n    4,\n    i32(CLOUD_VERTICAL_NOISE_CELLS),\n  );\n  // Keep the broad field responsible for the cloud silhouette and use the\n  // cellular term as bounded breakup. A broad-dominant mix reads as fewer,\n  // wider formations instead of evenly spaced foam balls.\n  let base = clamp(broad * 0.85 + cells * 0.15 + 0.15, 0.0, 1.0);\n  let weather = cloud_weather_field(position, seed);\n  let detailPosition = position * 3.0;\n  let warpX = cloud_value_noise(\n    vec3<f32>(detailPosition.x * 2.0, detailPosition.y * 2.0 + 11.0, detailPosition.z * 2.0),\n    seed + 29011u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let warpZ = cloud_value_noise(\n    vec3<f32>(detailPosition.x * 2.0 + 7.0, detailPosition.y * 2.0 - 5.0, detailPosition.z * 2.0),\n    seed + 29011u,\n    2,\n    2,\n    2,\n  ) - 0.5;\n  let erosion = cloud_cellular_noise(\n    vec3<f32>(\n      (detailPosition.x + warpX * 0.22) * 12.0,\n      detailPosition.y * 3.0,\n      (detailPosition.z + warpZ * 0.22) * 12.0,\n    ),\n    seed + 7919u,\n    12,\n    3,\n  );\n  return vec3<f32>(weather, base, erosion);\n}\n\nfn cloud_height_profile(height: f32, body: f32, weather: f32) -> f32 {\n  // A body-dependent crown breaks the fixed horizontal slab silhouette while\n  // keeping the profile smooth enough for the bounded ray step budget.\n  let lowerEdge = 0.05 + (1.0 - body) * 0.1;\n  let crownEdge = min(0.96, 0.6 + body * 0.3 + weather * 0.08);\n  let lower = smoothstep(lowerEdge, min(1.0, lowerEdge + 0.12), height);\n  let upper = 1.0 - smoothstep(crownEdge, min(1.0, crownEdge + 0.14), height);\n  return lower * upper;\n}\n\nfn cloud_compose_density(height: f32, formation: vec3<f32>, coverage: f32) -> f32 {\n  let threshold = 1.0 - coverage * (0.45 + formation.x * 0.55);\n  let covered = smoothstep(0.0, 0.4, (formation.y - threshold) / max(0.001, 1.0 - threshold));\n  let shaped = covered * cloud_height_profile(height, formation.y, formation.x);\n  let erosion = (1.0 - formation.z) * 0.18;\n  return clamp((shaped - erosion) / (1.0 - erosion), 0.0, 1.0);\n}\n\nfn cloud_analytic_density(position: vec3<f32>) -> f32 {\n  let height = (position.y - cloud.layer.x) / max(0.000001, cloud.layer.y);\n  if (height <= 0.0 || height >= 1.0 || cloud.layer.w <= 0.0 || cloud.field.x <= 0.0) { return 0.0; }\n  let advected = position + cloud.wind.xyz * cloud.field.y;\n  let advectedHeight = height +\n    cloud.wind.y * cloud.field.y * cloud.layer.z / max(CLOUD_VERTICAL_CELLS, 0.000001);\n  let p = vec3<f32>(\n    advected.x * cloud.layer.z,\n    fract(advectedHeight) * CLOUD_VERTICAL_CELLS,\n    advected.z * cloud.layer.z,\n  );\n  let formation = cloud_formation_field(p, u32(round(cloud.field.w)));\n  return cloud_compose_density(height, formation, cloud.field.x) * cloud.layer.w;\n}\n\nfn cloud_cache_byte(index: u32) -> f32 {\n  let word = densityCache[index >> 2u];\n  let shift = (index & 3u) * 8u;\n  return f32((word >> shift) & 255u) / 255.0;\n}\n\nfn cloud_cache_component(plane: u32, index: u32, stride: u32) -> f32 {\n  return cloud_cache_byte(plane * stride + index);\n}\n\nfn cloud_cache_trilinear(\n  plane: u32,\n  resolution: u32,\n  x0: u32,\n  x1: u32,\n  y0: u32,\n  y1: u32,\n  z0: u32,\n  z1: u32,\n  fx: f32,\n  fy: f32,\n  fz: f32,\n) -> f32 {\n  let stride = resolution * resolution * resolution;\n  let layer = resolution * resolution;\n  let c000 = cloud_cache_component(plane, z0 * layer + y0 * resolution + x0, stride);\n  let c100 = cloud_cache_component(plane, z0 * layer + y0 * resolution + x1, stride);\n  let c010 = cloud_cache_component(plane, z0 * layer + y1 * resolution + x0, stride);\n  let c110 = cloud_cache_component(plane, z0 * layer + y1 * resolution + x1, stride);\n  let c001 = cloud_cache_component(plane, z1 * layer + y0 * resolution + x0, stride);\n  let c101 = cloud_cache_component(plane, z1 * layer + y0 * resolution + x1, stride);\n  let c011 = cloud_cache_component(plane, z1 * layer + y1 * resolution + x0, stride);\n  let c111 = cloud_cache_component(plane, z1 * layer + y1 * resolution + x1, stride);\n  let x00 = mix(c000, c100, fx);\n  let x10 = mix(c010, c110, fx);\n  let x01 = mix(c001, c101, fx);\n  let x11 = mix(c011, c111, fx);\n  return mix(mix(x00, x10, fy), mix(x01, x11, fy), fz);\n}\n\nfn cloud_density(position: vec3<f32>) -> f32 {\n  let height = (position.y - cloud.layer.x) / max(0.000001, cloud.layer.y);\n  if (height <= 0.0 || height >= 1.0 || cloud.layer.w <= 0.0 || cloud.field.x <= 0.0) { return 0.0; }\n  let resolution = cloud.integration.x;\n  if (resolution < 4u) { return max(cloud_analytic_density(position), 0.0); }\n  let periodCoordinate = fract((position.xz + cloud.wind.xz * cloud.field.y) * cloud.layer.z);\n  let x = fract(periodCoordinate.x - 0.5 / f32(resolution)) * f32(resolution);\n  let z = fract(periodCoordinate.y - 0.5 / f32(resolution)) * f32(resolution);\n  let advectedHeight = height +\n    cloud.wind.y * cloud.field.y * cloud.layer.z / max(CLOUD_VERTICAL_CELLS, 0.000001);\n  let y = fract(advectedHeight - 0.5 / f32(resolution)) * f32(resolution);\n  let x0 = u32(floor(x));\n  let y0 = u32(floor(y));\n  let z0 = u32(floor(z));\n  let x1 = (x0 + 1u) % resolution;\n  let y1 = (y0 + 1u) % resolution;\n  let z1 = (z0 + 1u) % resolution;\n  let fx = x - f32(x0);\n  let fy = y - f32(y0);\n  let fz = z - f32(z0);\n  let weather = cloud_cache_trilinear(0u, resolution, x0, x1, y0, y1, z0, z1, fx, fy, fz);\n  let body = cloud_cache_trilinear(1u, resolution, x0, x1, y0, y1, z0, z1, fx, fy, fz);\n  // Repeat only the independent erosion plane: fine boundary structure with\n  // the same eight packed reads and the same cache allocation.\n  let detail = fract(vec3<f32>(periodCoordinate.x, advectedHeight, periodCoordinate.y) * 3.0 - vec3<f32>(0.5 / f32(resolution))) * f32(resolution);\n  let d0 = vec3<u32>(floor(detail));\n  let d1 = (d0 + vec3<u32>(1u)) % vec3<u32>(resolution);\n  let df = fract(detail);\n  let erosion = cloud_cache_trilinear(2u, resolution, d0.x, d1.x, d0.y, d1.y, d0.z, d1.z, df.x, df.y, df.z);\n  return cloud_compose_density(height, vec3<f32>(weather, body, erosion), cloud.field.x) * cloud.layer.w;\n}\n\nfn cloud_layer_interval(origin: vec3<f32>, direction: vec3<f32>, maxDistance: f32) -> vec2<f32> {\n  if (abs(direction.y) < 0.000001) {\n    if (origin.y < cloud.layer.x || origin.y > cloud.layer.x + cloud.layer.y) {\n      return vec2<f32>(1.0, 0.0);\n    }\n    return vec2<f32>(0.0, maxDistance);\n  }\n  let lower = (cloud.layer.x - origin.y) / direction.y;\n  let upper = (cloud.layer.x + cloud.layer.y - origin.y) / direction.y;\n  return vec2<f32>(\n    max(0.0, min(lower, upper)),\n    min(maxDistance, max(lower, upper)),\n  );\n}\n\nfn cloud_solar_transmittance(position: vec3<f32>) -> f32 {\n  let sunDirection = normalize(-view.lightDir);\n  let solarDistance = select(cloud.field.z, cloud.shadowProjection.x, cloud.shadowProjection.x > 0.0);\n  let interval = cloud_layer_interval(position, sunDirection, solarDistance);\n  if (interval.y <= interval.x) { return 1.0; }\n  let steps = min(cloud.integration.z, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var opticalDepth = 0.0;\n  let solarJitter = cloud_solar_jitter(position);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let samplePosition = position + sunDirection * (interval.x + (f32(index) + solarJitter) * stepLength);\n    opticalDepth = opticalDepth + cloud_density(samplePosition) * 0.03 * stepLength;\n  }\n  return exp(-max(opticalDepth, 0.0));\n}\n\nfn cloud_henyey_greenstein(cosTheta: f32, g: f32) -> f32 {\n  let denominator = max(0.0001, 1.0 + g * g - 2.0 * g * cosTheta);\n  return (1.0 - g * g) / (denominator * sqrt(denominator)) * 0.0795774715;\n}\n\nfn cloud_phase(cosTheta: f32) -> f32 {\n  // A bounded dual lobe gives a readable forward highlight and a small\n  // back-scatter rim without another solar march.\n  return cloud_henyey_greenstein(cosTheta, 0.55) * 0.8 +\n    cloud_henyey_greenstein(cosTheta, -0.2) * 0.2;\n}\n\n// Reuse the same remaining-path optical depth for two bounded scattering\n// orders. This adds arithmetic only; no extra density or light-ray samples.\nfn cloud_incident_light(solarT: f32, cosTheta: f32, height: f32) -> vec3<f32> {\n  let direct = solarT * cloud_phase(cosTheta);\n  let multiple = (0.5 * pow(solarT, 0.5) + 0.25 * pow(solarT, 0.25)) * 0.0795774715;\n  let skyFill = mix(0.025, 0.075, smoothstep(0.1, 0.85, height));\n  // Match volume-integrate: the shared DirectionalLight value uses the\n  // unnormalized phase convention. Convert the normalized HG basis once.\n  return cloud.sunRadiance.xyz *\n    (vec3<f32>((direct + multiple) * 12.5663706144) + vec3<f32>(0.72, 0.84, 1.0) * skyFill);\n}\n\nfn cloud_ray_jitter(pixel: vec2<f32>) -> f32 {\n  // A stable per-pixel offset removes view-step contour bands without adding\n  // a frame-varying noise source that would fight temporal reprojection.\n  return fract(sin(dot(pixel, vec2<f32>(12.9898, 78.233))) * 43758.5453);\n}\n\nfn cloud_solar_jitter(position: vec3<f32>) -> f32 {\n  // Dither the light-column samples in world space so low shadow-step\n  // profiles do not paint parallel contour bands across cloud bases.\n  return fract(sin(dot(position.xz, vec2<f32>(19.193, 47.117))) * 15731.743);\n}\n\nfn reconstruct_world(uv: vec2<f32>, depth: f32) -> vec3<f32> {\n  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);\n  let world = view.inverseViewProj * ndc;\n  return world.xyz / max(abs(world.w), 0.00001);\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) index: u32) -> CloudViewOut {\n  var positions = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0),\n    vec2<f32>(3.0, -1.0),\n    vec2<f32>(-1.0, 3.0),\n  );\n  var output: CloudViewOut;\n  output.position = vec4<f32>(positions[index], 0.0, 1.0);\n  // WebGPU clip-space Y grows upward while sampled framebuffer rows and the\n  // depth texture use a top-left origin. Keep this one top-left UV for color,\n  // depth and inverse-projection reconstruction; flipping only the final\n  // color would leave the camera ray and depth cut mirrored.\n  output.uv = vec2<f32>(\n    positions[index].x * 0.5 + 0.5,\n    1.0 - (positions[index].y * 0.5 + 0.5),\n  );\n  return output;\n}\n\n@fragment\nfn fs_main(input: CloudViewOut) -> @location(0) vec4<f32> {\n  // The shadow producer uses this same production density/cache contract but\n  // rasterizes a camera-independent, texel-snapped light-space map. It does\n  // not consume scene colour; the generic fullscreen host still supplies the\n  // input binding to keep the feature binding ABI single and validated.\n  if (cloud.integration.w == 1u) {\n    let projection = cloud.shadowProjection;\n    if (projection.y < 0.5 || projection.z > 0.5 || projection.x <= 0.0) {\n      return vec4<f32>(1.0);\n    }\n    let offset = (input.uv - vec2<f32>(0.5)) * projection.x;\n    let receiver = cloud.shadowOrigin.xyz +\n      cloud.shadowRight.xyz * offset.x + cloud.shadowUp.xyz * offset.y;\n    let sunDirection = normalize(-view.lightDir);\n    let interval = cloud_layer_interval(receiver, sunDirection, projection.x);\n    if (interval.y <= interval.x) { return vec4<f32>(1.0); }\n    let steps = min(cloud.integration.z, 64u);\n    let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n    var opticalDepth = 0.0;\n    var firstHeight = 1.0;\n    var lastHeight = 0.0;\n    var occupied = false;\n    let solarJitter = cloud_solar_jitter(receiver);\n    for (var index = 0u; index < 64u; index = index + 1u) {\n      if (index >= steps) { break; }\n      let samplePosition = receiver + sunDirection *\n        (interval.x + (f32(index) + solarJitter) * stepLength);\n      let localDensity = cloud_density(samplePosition);\n      opticalDepth = opticalDepth + localDensity * 0.03 * stepLength;\n      if (localDensity > 0.0001) {\n        let sampleHeight = clamp(\n          (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y),\n          0.0,\n          1.0,\n        );\n        if (!occupied) { firstHeight = sampleHeight; }\n        lastHeight = sampleHeight;\n        occupied = true;\n      }\n    }\n    let transmittance = exp(-max(opticalDepth, 0.0));\n    // R stores full-column transmittance. G/B preserve the first/last\n    // occupied normalized layer heights so interior samples can estimate the\n    // remaining segment without pretending optical depth is uniform through\n    // the whole layer. A stores the integrated optical depth and distinguishes\n    // an empty projected column from a valid, nearly-clear one.\n    return vec4<f32>(\n      transmittance,\n      select(1.0, firstHeight, occupied),\n      select(0.0, lastHeight, occupied),\n      select(0.0, opticalDepth, occupied),\n    );\n  }\n  // The shadow producer branch above is per-fragment (its light-space\n  // interval depends on the rasterized receiver), so derivative-based\n  // sampling here would violate WGSL uniform-control-flow rules. The cloud\n  // scene path already owns an explicit level-0 sampler contract.\n  // Keep point semantics for the current full-resolution scene path. The\n  // half-resolution transport contract is introduced with its own resolve\n  // shader so this path retains the established depth convention.\n  let depthPixel = vec2<i32>(input.position.xy);\n  let depth = textureLoad(sceneDepth, depthPixel, 0);\n  let farWorld = reconstruct_world(input.uv, 1.0);\n  let sceneWorld = reconstruct_world(input.uv, clamp(depth, 0.0, 1.0));\n  let ray = normalize(farWorld - view.cameraPos);\n  let rayJitter = cloud_ray_jitter(input.position.xy);\n  let sceneDistance = select(cloud.field.z, length(sceneWorld - view.cameraPos), depth < 0.999999);\n  let interval = cloud_layer_interval(view.cameraPos, ray, sceneDistance);\n\n  // The depth producer shares the same camera ray, interval and density\n  // contract as the display path. It writes a cloud representative world\n  // position and a validity bit so history remains comparable after camera\n  // translation or rotation and never uses an opaque scene distance as a\n  // proxy for a participating medium.\n  if (cloud.integration.w == 2u) {\n    if (interval.y <= interval.x) { return vec4<f32>(sceneWorld, 0.0); }\n    let depthSteps = min(cloud.integration.y, 64u);\n    let depthStepLength = (interval.y - interval.x) / max(1.0, f32(depthSteps));\n    var depthTransmittance = 1.0;\n    var weightedDistance = 0.0;\n    var opticalWeight = 0.0;\n    for (var depthIndex = 0u; depthIndex < 64u; depthIndex = depthIndex + 1u) {\n      if (depthIndex >= depthSteps) { break; }\n      let sampleDistance = interval.x + (f32(depthIndex) + rayJitter) * depthStepLength;\n      let samplePosition = view.cameraPos + ray * sampleDistance;\n      let localDensity = cloud_density(samplePosition);\n      let localTransmittance = exp(-max(localDensity * 0.03 * depthStepLength, 0.0));\n      let weight = depthTransmittance * (1.0 - localTransmittance);\n      weightedDistance = weightedDistance + sampleDistance * weight;\n      opticalWeight = opticalWeight + weight;\n      depthTransmittance = depthTransmittance * localTransmittance;\n    }\n    let hasCloud = opticalWeight > 0.00001;\n    let representativeDistance = select(sceneDistance, weightedDistance / opticalWeight, hasCloud);\n    let representativeWorld = view.cameraPos + ray * representativeDistance;\n    return vec4<f32>(representativeWorld, select(0.0, 1.0, hasCloud));\n  }\n\n  let scene = textureSampleLevel(sceneColor, sceneSampler, input.uv, 0.0);\n  if (interval.y <= interval.x) { return scene; }\n  let steps = min(cloud.integration.y, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var transmittance = 1.0;\n  var scattering = vec3<f32>(0.0);\n  var weightedDistance = 0.0;\n  var opticalWeight = 0.0;\n  let sunDirection = normalize(-view.lightDir);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let distance = interval.x + (f32(index) + rayJitter) * stepLength;\n    let samplePosition = view.cameraPos + ray * distance;\n    let localDensity = cloud_density(samplePosition);\n    let extinction = localDensity * 0.03 * stepLength;\n    let localTransmittance = exp(-max(extinction, 0.0));\n    let depthWeight = transmittance * (1.0 - localTransmittance);\n    weightedDistance = weightedDistance + distance * depthWeight;\n    opticalWeight = opticalWeight + depthWeight;\n    // Empty samples are common in the separated-cloud field. Avoid a nested\n    // solar march for them and stop once the camera path is effectively opaque.\n    if (localDensity > 0.0001 && transmittance > 0.01) {\n      let solarTransmittance = cloud_solar_transmittance(samplePosition);\n      let cloudHeight = clamp(\n        (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y), 0.0, 1.0,\n      );\n      scattering = scattering + cloud_incident_light(\n        solarTransmittance, dot(ray, sunDirection), cloudHeight,\n      ) * depthWeight;\n    }\n    transmittance = transmittance * localTransmittance;\n    if (transmittance < 0.01) { break; }\n  }\n  let hasCloud = opticalWeight > 0.00001;\n  let representativeDistance = select(sceneDistance, weightedDistance / opticalWeight, hasCloud);\n  let representativeWorld = view.cameraPos + ray * representativeDistance;\n  // Wind is an advective coordinate change. Reproject the cloud point into\n  // the previous frame's world before applying the previous camera matrix;\n  // authored field values remain immutable.\n  let windDelta = cloud.wind.xyz * max(0.0, cloud.field.y - cloud.temporal.w);\n  // cloud_density evaluates the authored field at position + wind*time.\n  // Keeping the same field sample in the previous frame therefore advances\n  // the previous world point by the elapsed wind delta as well.\n  let previousCloudWorld = representativeWorld + windDelta;\n  let previousCloudClip = view.temporalPreviousViewProj * vec4<f32>(previousCloudWorld, 1.0);\n  let previousCloudNdc = previousCloudClip.xyz / max(abs(previousCloudClip.w), 0.00001);\n  let previousCloudUv = vec2<f32>(\n    previousCloudNdc.x * 0.5 + 0.5,\n    1.0 - (previousCloudNdc.y * 0.5 + 0.5),\n  );\n  let cloudInBounds = all(previousCloudUv >= vec2<f32>(0.0)) && all(previousCloudUv <= vec2<f32>(1.0));\n  let cloudHistoryUv = clamp(previousCloudUv, vec2<f32>(0.0), vec2<f32>(1.0));\n  let cloudHistoryDepthSample = textureSampleLevel(previousDepth, depthSampler, cloudHistoryUv, 0.0);\n  let cloudHistoryWorld = cloudHistoryDepthSample.xyz;\n  let previous = textureSampleLevel(previousRadiance, sceneSampler, cloudHistoryUv, 0.0);\n  let previousTransport = textureSampleLevel(\n    previousTransmittance,\n    sceneSampler,\n    cloudHistoryUv,\n    0.0,\n  );\n  let worldTolerance = max(0.05, length(previousCloudWorld - view.cameraPos) * 0.02);\n  let depthAccepted = cloudHistoryDepthSample.a > 0.5 &&\n    distance(cloudHistoryWorld, previousCloudWorld) <= worldTolerance;\n  let accepted =\n    hasCloud && cloud.temporal.x > 0.5 && cloud.temporal.y < 0.5 && cloudInBounds &&\n    depthAccepted && previousTransport.a > 0.0;\n  let historyWeight = select(0.0, clamp(cloud.temporal.z, 0.0, 0.95), accepted);\n  let cloudRadiance = mix(scattering, previous.rgb, historyWeight);\n  // Preserve scene-linear HDR output for the downstream material lane. The\n  // history owner receives cloudRadiance separately through the history pass.\n  return vec4<f32>(scene.rgb * transmittance + cloudRadiance, transmittance);\n}\n\n// The light-space shadow producer already paid for a bounded column integral.\n// Reuse that texel for camera samples instead of starting a full solar march\n// for every occupied camera step. Outside the occupied interval the cached\n// full-column transmittance is exact for the projected column. Inside the\n// interval, the cache supplies the stable projection/bounds and a short\n// residual march resolves the non-uniform density that a linear optical-depth\n// interpolation would lose. Invalid/out-of-range projections retain the\n// analytic path as an explicit fallback.\nfn cloud_solar_cached_transmittance(position: vec3<f32>) -> f32 {\n  let projection = cloud.shadowProjection;\n  if (projection.y < 0.5 || projection.x <= 0.0) {\n    return cloud_solar_transmittance(position);\n  }\n  let relative = position - cloud.shadowOrigin.xyz;\n  let uv = vec2<f32>(\n    dot(relative, cloud.shadowRight.xyz) / projection.x + 0.5,\n    dot(relative, cloud.shadowUp.xyz) / projection.x + 0.5,\n  );\n  if (any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0))) {\n    return cloud_solar_transmittance(position);\n  }\n  let cachedShadow = textureSampleLevel(previousRadiance, sceneSampler, uv, 0.0);\n  let cachedOpticalDepth = max(cachedShadow.a, 0.0);\n  let layerHeight = clamp(\n    (position.y - cloud.layer.x) / max(0.0001, cloud.layer.y),\n    0.0,\n    1.0,\n  );\n  if (cachedOpticalDepth <= 0.0001) { return 1.0; }\n  let firstHeight = clamp(cachedShadow.g, 0.0, 1.0);\n  let lastHeight = clamp(cachedShadow.b, 0.0, 1.0);\n  let occupiedMin = min(firstHeight, lastHeight);\n  let occupiedMax = max(firstHeight, lastHeight);\n  let sunDirection = normalize(-view.lightDir);\n  // G/B are ordered along the light ray, not necessarily bottom-to-top. Only\n  // use the cached full/empty fast paths when the light has enough vertical\n  // component to make that ordering meaningful; grazing light stays on the\n  // residual path so a low-sun column cannot invert the cache bounds.\n  if (abs(sunDirection.y) > 0.2) {\n    if (sunDirection.y > 0.0) {\n      if (layerHeight <= occupiedMin) { return exp(-cachedOpticalDepth); }\n      if (layerHeight >= occupiedMax) { return 1.0; }\n    } else {\n      if (layerHeight >= occupiedMax) { return exp(-cachedOpticalDepth); }\n      if (layerHeight <= occupiedMin) { return 1.0; }\n    }\n  }\n\n  // A short residual march is only paid for samples inside the projected\n  // cloud span. Vertical light uses twelve taps, oblique light sixteen, and\n  // grazing light up to thirty-two because the same layer projects across a\n  // much longer solar segment. This removes the large error caused by\n  // assuming optical depth is uniform between the first and last occupied\n  // heights while keeping the normal camera path far below a second full\n  // solar integration.\n  let solarDistance = select(cloud.field.z, projection.x, projection.x > 0.0);\n  let interval = cloud_layer_interval(position, sunDirection, solarDistance);\n  if (interval.y <= interval.x) { return 1.0; }\n  let absLightY = abs(sunDirection.y);\n  let directionBudget = select(\n    32u,\n    select(16u, 12u, absLightY > 0.5),\n    absLightY > 0.2,\n  );\n  let residualSteps = min(directionBudget, max(8u, cloud.integration.z * 3u));\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(residualSteps));\n  var opticalDepth = 0.0;\n  let solarJitter = cloud_solar_jitter(position);\n  for (var index = 0u; index < 32u; index = index + 1u) {\n    if (index >= residualSteps) { break; }\n    let samplePosition = position + sunDirection *\n      (interval.x + (f32(index) + solarJitter) * stepLength);\n    opticalDepth = opticalDepth + cloud_density(samplePosition) *\n      0.03 * stepLength;\n  }\n  return exp(-max(opticalDepth, 0.0));\n}\n\nstruct CloudTransportOutput {\n  @location(0) radiance: vec4<f32>,\n  @location(1) transmittance: vec4<f32>,\n  @location(2) depth: vec4<f32>,\n};\n\n// One half-resolution transport pass writes all three reusable cloud fields.\n// The full-resolution resolve below reconstructs colour and applies temporal\n// history; no second full raymarch exists solely to obtain cloud depth.\n@fragment\nfn fs_transport(input: CloudViewOut) -> CloudTransportOutput {\n  let depth = textureSampleLevel(sceneDepth, depthSampler, input.uv, 0u);\n  let farWorld = reconstruct_world(input.uv, 1.0);\n  let sceneWorld = reconstruct_world(input.uv, clamp(depth, 0.0, 1.0));\n  let ray = normalize(farWorld - view.cameraPos);\n  let rayJitter = cloud_ray_jitter(input.position.xy);\n  let sceneDistance = select(cloud.field.z, length(sceneWorld - view.cameraPos), depth < 0.999999);\n  let interval = cloud_layer_interval(view.cameraPos, ray, sceneDistance);\n  var output: CloudTransportOutput;\n  output.radiance = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n  output.transmittance = vec4<f32>(1.0, 1.0, 1.0, 1.0);\n  output.depth = vec4<f32>(sceneWorld, 0.0);\n  if (interval.y <= interval.x) { return output; }\n\n  let steps = min(cloud.integration.y, 64u);\n  let stepLength = (interval.y - interval.x) / max(1.0, f32(steps));\n  var transmittance = 1.0;\n  var scattering = vec3<f32>(0.0);\n  var weightedDistance = 0.0;\n  var opticalWeight = 0.0;\n  let sunDirection = normalize(-view.lightDir);\n  for (var index = 0u; index < 64u; index = index + 1u) {\n    if (index >= steps) { break; }\n    let distance = interval.x + (f32(index) + rayJitter) * stepLength;\n    let samplePosition = view.cameraPos + ray * distance;\n    let localDensity = cloud_density(samplePosition);\n    let extinction = localDensity * 0.03 * stepLength;\n    let localTransmittance = exp(-max(extinction, 0.0));\n    let depthWeight = transmittance * (1.0 - localTransmittance);\n    weightedDistance = weightedDistance + distance * depthWeight;\n    opticalWeight = opticalWeight + depthWeight;\n    if (localDensity > 0.0001 && transmittance > 0.01) {\n      let solarTransmittance = cloud_solar_cached_transmittance(samplePosition);\n      let cloudHeight = clamp(\n        (samplePosition.y - cloud.layer.x) / max(0.0001, cloud.layer.y), 0.0, 1.0,\n      );\n      scattering = scattering + cloud_incident_light(\n        solarTransmittance, dot(ray, sunDirection), cloudHeight,\n      ) * depthWeight;\n    }\n    transmittance = transmittance * localTransmittance;\n    if (transmittance < 0.01) { break; }\n  }\n  let hasCloud = opticalWeight > 0.00001;\n  let representativeDistance = select(sceneDistance, weightedDistance / max(opticalWeight, 0.00001), hasCloud);\n  output.radiance = vec4<f32>(scattering, select(0.0, 1.0, hasCloud));\n  output.transmittance = vec4<f32>(transmittance, transmittance, transmittance, 1.0);\n  output.depth = vec4<f32>(view.cameraPos + ray * representativeDistance, select(0.0, 1.0, hasCloud));\n  return output;\n}\n";
+/** Analytic fallback for adapters without a projected cloud-shadow target. */
+export declare const CLOUD_TRANSPORT_ANALYTIC_FULLSCREEN_WGSL: string;
+/**
+ * History writer. It is a separate MRT pass so the cloud composite remains a
+ * normal scene-linear color producer while the renderer owns the ping-pong
+ * radiance/transmittance/depth attachments and advances them only on submit.
+ */
+export declare const CLOUD_HISTORY_FULLSCREEN_WGSL = "\nstruct CloudCameraView {\n  worldViewProj: mat4x4<f32>,\n  lightDir: vec3<f32>,\n  lightColor: vec3<f32>,\n  cameraPos: vec3<f32>,\n  lightViewProj_A: mat4x4<f32>,\n  inverseViewProj: mat4x4<f32>,\n  lightViewProj_B: mat4x4<f32>,\n  lightViewProj_C: mat4x4<f32>,\n  lightViewProj_D: mat4x4<f32>,\n  splitPlanes: array<vec4<f32>, 4>,\n  cascadeCount: f32,\n  cascadeBlend: f32,\n  depthBias: f32,\n  normalBias: f32,\n  directionalShadowFilter: vec4<f32>,\n  spotLightViewProj: array<mat4x4<f32>, 4>,\n  temporalCurrentViewProj: mat4x4<f32>,\n  temporalPreviousViewProj: mat4x4<f32>,\n  temporalProjection: vec4<f32>,\n  temporalPreviousCameraPos: vec4<f32>,\n  ssrParams: vec4<f32>,\n};\n\nstruct CloudHistoryParams {\n  temporal: vec4<f32>, // valid, reset, historyWeight, reserved\n  windTime: vec4<f32>, // wind.xyz, elapsed seconds since previous submit\n};\n\n@group(0) @binding(0) var<uniform> view: CloudCameraView;\n@group(1) @binding(0) var currentRadiance: texture_2d<f32>;\n@group(1) @binding(1) var sceneSampler: sampler;\n@group(1) @binding(2) var<uniform> params: CloudHistoryParams;\n@group(1) @binding(3) var sceneDepth: texture_depth_2d;\n@group(1) @binding(4) var depthSampler: sampler;\n@group(1) @binding(5) var currentCloudDepth: texture_2d<f32>;\n@group(1) @binding(6) var sceneBackground: texture_2d<f32>;\n\nstruct CloudHistoryInput {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\nstruct CloudHistoryOutput {\n  @location(0) radiance: vec4<f32>,\n  @location(1) transmittance: vec4<f32>,\n};\n\nfn reconstruct_world(uv: vec2<f32>, depth: f32) -> vec3<f32> {\n  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);\n  let world = view.inverseViewProj * ndc;\n  return world.xyz / max(abs(world.w), 0.00001);\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) index: u32) -> CloudHistoryInput {\n  var positions = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0),\n    vec2<f32>(3.0, -1.0),\n    vec2<f32>(-1.0, 3.0),\n  );\n  var output: CloudHistoryInput;\n  output.position = vec4<f32>(positions[index], 0.0, 1.0);\n  output.uv = vec2<f32>(\n    positions[index].x * 0.5 + 0.5,\n    1.0 - (positions[index].y * 0.5 + 0.5),\n  );\n  return output;\n}\n\n@fragment\nfn fs_main(input: CloudHistoryInput) -> CloudHistoryOutput {\n  let current = textureSampleLevel(currentRadiance, sceneSampler, input.uv, 0.0);\n  let background = textureSampleLevel(sceneBackground, sceneSampler, input.uv, 0.0);\n  let cloudDepth = textureSampleLevel(currentCloudDepth, depthSampler, input.uv, 0.0);\n  let currentValid = cloudDepth.a > 0.5;\n  // currentRadiance is the scene-linear cloud composite. Remove the\n  // unchanged scene background before writing history so the persistent owner\n  // stores raw cloud radiance only. The view pass is the sole temporal blend\n  // owner; blending here as well would accumulate history twice per frame.\n  let currentCloudRadiance = max(current.rgb - background.rgb * current.a, vec3<f32>(0.0));\n  let currentTransmittance = vec4<f32>(current.a, current.a, current.a, 1.0);\n  var output: CloudHistoryOutput;\n  output.radiance = vec4<f32>(currentCloudRadiance, select(0.0, 1.0, currentValid));\n  output.transmittance = currentTransmittance;\n  return output;\n}\n";
+/** Full-resolution resolve for the half-resolution transport MRT. */
+export declare const CLOUD_RESOLVE_FULLSCREEN_WGSL = "\nstruct CloudCameraView {\n  worldViewProj: mat4x4<f32>,\n  lightDir: vec3<f32>,\n  lightColor: vec3<f32>,\n  cameraPos: vec3<f32>,\n  lightViewProj_A: mat4x4<f32>,\n  inverseViewProj: mat4x4<f32>,\n  lightViewProj_B: mat4x4<f32>,\n  lightViewProj_C: mat4x4<f32>,\n  lightViewProj_D: mat4x4<f32>,\n  splitPlanes: array<vec4<f32>, 4>,\n  cascadeCount: f32,\n  cascadeBlend: f32,\n  depthBias: f32,\n  normalBias: f32,\n  directionalShadowFilter: vec4<f32>,\n  spotLightViewProj: array<mat4x4<f32>, 4>,\n  temporalCurrentViewProj: mat4x4<f32>,\n  temporalPreviousViewProj: mat4x4<f32>,\n  temporalProjection: vec4<f32>,\n  temporalPreviousCameraPos: vec4<f32>,\n  ssrParams: vec4<f32>,\n};\n\nstruct CloudResolveParams {\n  layer: vec4<f32>,\n  field: vec4<f32>,\n  wind: vec4<f32>,\n  sunDirection: vec4<f32>,\n  sunRadiance: vec4<f32>,\n  integration: vec4<u32>,\n  shadowOrigin: vec4<f32>,\n  shadowRight: vec4<f32>,\n  shadowUp: vec4<f32>,\n  shadowProjection: vec4<f32>,\n  temporal: vec4<f32>,\n};\n\n@group(0) @binding(0) var<uniform> view: CloudCameraView;\n@group(1) @binding(0) var sceneColor: texture_2d<f32>;\n@group(1) @binding(1) var sceneSampler: sampler;\n@group(1) @binding(2) var<uniform> cloud: CloudResolveParams;\n@group(1) @binding(3) var sceneDepth: texture_depth_2d;\n@group(1) @binding(4) var depthSampler: sampler;\n@group(1) @binding(5) var currentRadiance: texture_2d<f32>;\n@group(1) @binding(6) var currentTransmittance: texture_2d<f32>;\n@group(1) @binding(7) var currentDepth: texture_2d<f32>;\n@group(1) @binding(8) var previousRadiance: texture_2d<f32>;\n@group(1) @binding(9) var previousTransmittance: texture_2d<f32>;\n@group(1) @binding(10) var previousDepth: texture_2d<f32>;\n\nstruct CloudResolveInput {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n};\n\nfn reconstruct_world(uv: vec2<f32>, depth: f32) -> vec3<f32> {\n  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);\n  let world = view.inverseViewProj * ndc;\n  return world.xyz / max(abs(world.w), 0.00001);\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) index: u32) -> CloudResolveInput {\n  var positions = array<vec2<f32>, 3>(\n    vec2<f32>(-1.0, -1.0),\n    vec2<f32>(3.0, -1.0),\n    vec2<f32>(-1.0, 3.0),\n  );\n  var output: CloudResolveInput;\n  output.position = vec4<f32>(positions[index], 0.0, 1.0);\n  output.uv = vec2<f32>(\n    positions[index].x * 0.5 + 0.5,\n    1.0 - (positions[index].y * 0.5 + 0.5),\n  );\n  return output;\n}\n\n@fragment\nfn fs_main(input: CloudResolveInput) -> @location(0) vec4<f32> {\n  let scene = textureSampleLevel(sceneColor, sceneSampler, input.uv, 0.0);\n  // The resolve owns the full-resolution foreground test. Reject the current\n  // low-resolution transport before any history or radiance is composited;\n  // gating history alone still lets a newly sampled cloud bleed over geometry.\n  let sceneDepthValue = textureLoad(sceneDepth, vec2<i32>(input.position.xy), 0);\n  let sceneWorld = reconstruct_world(input.uv, clamp(sceneDepthValue, 0.0, 1.0));\n  let sceneDistance = length(sceneWorld - view.cameraPos);\n  let transport = textureSampleLevel(currentRadiance, sceneSampler, input.uv, 0.0);\n  let transportT = textureSampleLevel(currentTransmittance, sceneSampler, input.uv, 0.0);\n  // The transport depth is an rgba16float color attachment, not the scene's\n  // depth texture. Sample it with the filtering color sampler; binding the\n  // non-filtering scene-depth sampler here makes the shader contract depend on\n  // an incompatible sampler/texture pair on strict WebGPU implementations.\n  let cloudDepth = textureSampleLevel(currentDepth, sceneSampler, input.uv, 0.0);\n  let currentValid = transport.a > 0.5 && cloudDepth.a > 0.5;\n  let cloudDistance = length(cloudDepth.xyz - view.cameraPos);\n  let foregroundAccepted = sceneDepthValue >= 0.999999 ||\n    cloudDistance <= sceneDistance + max(0.05, sceneDistance * 0.01);\n  if (!currentValid || !foregroundAccepted) { return scene; }\n\n  let previousClip = view.temporalPreviousViewProj * vec4<f32>(\n    cloudDepth.xyz + cloud.wind.xyz * max(0.0, cloud.field.y - cloud.temporal.w),\n    1.0,\n  );\n  let previousNdc = previousClip.xyz / max(abs(previousClip.w), 0.00001);\n  let previousUv = vec2<f32>(\n    previousNdc.x * 0.5 + 0.5,\n    1.0 - (previousNdc.y * 0.5 + 0.5),\n  );\n  let inBounds = all(previousUv >= vec2<f32>(0.0)) && all(previousUv <= vec2<f32>(1.0));\n  let historyUv = clamp(previousUv, vec2<f32>(0.0), vec2<f32>(1.0));\n  let historyDepth = textureSampleLevel(previousDepth, sceneSampler, historyUv, 0.0);\n  let previous = textureSampleLevel(previousRadiance, sceneSampler, historyUv, 0.0);\n  let previousTransport = textureSampleLevel(previousTransmittance, sceneSampler, historyUv, 0.0);\n  let dims = vec2<f32>(textureDimensions(previousRadiance));\n  let texel = 1.0 / max(dims, vec2<f32>(1.0));\n  // Clamp reprojected history against the current low-resolution transport\n  // neighborhood. Using only previous-frame neighbors (and including the\n  // previous center in both extrema) is a no-op and lets stale bright cloud\n  // pixels leak across a newly exposed edge.\n  let c0 = transport.rgb;\n  let c1 = textureSampleLevel(currentRadiance, sceneSampler, clamp(input.uv + vec2<f32>(-texel.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).rgb;\n  let c2 = textureSampleLevel(currentRadiance, sceneSampler, clamp(input.uv + vec2<f32>(texel.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).rgb;\n  let c3 = textureSampleLevel(currentRadiance, sceneSampler, clamp(input.uv + vec2<f32>(0.0, -texel.y), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).rgb;\n  let c4 = textureSampleLevel(currentRadiance, sceneSampler, clamp(input.uv + vec2<f32>(0.0, texel.y), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).rgb;\n  let minRadiance = min(c0, min(min(c1, c2), min(c3, c4)));\n  let maxRadiance = max(c0, max(max(c1, c2), max(c3, c4)));\n  let t1 = textureSampleLevel(currentTransmittance, sceneSampler, clamp(input.uv + vec2<f32>(-texel.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).r;\n  let t2 = textureSampleLevel(currentTransmittance, sceneSampler, clamp(input.uv + vec2<f32>(texel.x, 0.0), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).r;\n  let t3 = textureSampleLevel(currentTransmittance, sceneSampler, clamp(input.uv + vec2<f32>(0.0, -texel.y), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).r;\n  let t4 = textureSampleLevel(currentTransmittance, sceneSampler, clamp(input.uv + vec2<f32>(0.0, texel.y), vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).r;\n  let minTransport = min(transportT.r, min(min(t1, t2), min(t3, t4)));\n  let maxTransport = max(transportT.r, max(max(t1, t2), max(t3, t4)));\n  let worldTolerance = max(0.05, distance(cloudDepth.xyz, view.cameraPos) * 0.02);\n  let depthAccepted = historyDepth.a > 0.5 && distance(historyDepth.xyz, cloudDepth.xyz) <= worldTolerance;\n  let accepted = cloud.temporal.x > 0.5 && cloud.temporal.y < 0.5 && inBounds && depthAccepted;\n  let historyWeight = select(0.0, clamp(cloud.temporal.z, 0.0, 0.92), accepted);\n  let stableHistory = clamp(previous.rgb, minRadiance, maxRadiance);\n  let stableTransport = clamp(previousTransport.r, minTransport, maxTransport);\n  let radiance = mix(transport.rgb, stableHistory, historyWeight);\n  let transmittance = mix(transportT.r, stableTransport, historyWeight);\n  return vec4<f32>(scene.rgb * transmittance + radiance, transmittance);\n}\n";
+export interface CloudLayerFeatureFrame {
+    readonly params: ValidatedCloudLayer | undefined;
+    readonly cache: CloudDensityCache | undefined;
+    readonly sourceKey: string | undefined;
+    readonly timeSeconds: number;
+    readonly sunDirection: readonly [number, number, number] | undefined;
+    readonly sunRadiance: readonly [number, number, number] | undefined;
+    readonly shadowProjection: CloudShadowProjection | undefined;
+    readonly temporal: CloudTemporalFrame | undefined;
+    readonly generation: number;
+    readonly inspection: CloudLayerInspection;
+}
+export interface CloudLayerFeatureOptions {
+    /** Disable the renderer-owned CloudLayer projection while retaining the component. */
+    readonly enabled?: boolean;
+}
+/**
+ * Renderer-installed cloud producer. Authoring is read once from World at
+ * extraction; resource preparation, graph ordering and retirement stay with
+ * RenderFeatureHost.
+ */
+export declare function createCloudLayerFeature(options?: CloudLayerFeatureOptions): RenderFeature<CloudLayerFeatureFrame>;
+//# sourceMappingURL=feature.d.ts.map

package/dist/cloud/feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/cloud/feature.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAA+B,MAAM,mBAAmB,CAAC;AACpF,OAAO,EAAgD,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACjG,OAAO,EACL,KAAK,oBAAoB,EAG1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,KAAK,qBAAqB,EAA+B,MAAM,UAAU,CAAC;AACnF,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,4BAA4B,wBAAwB,CAAC;AAClE,eAAO,MAAM,2BAA2B,wBAAwB,CAAC;AACjE,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAC3E,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAWvE,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAa3C,8EAA8E;AAC9E,eAAO,MAAM,0BAA0B,8bAUtC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,45gCA4uBtC,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,+BAA+B,45gCAA6B,CAAC;AAC1E,8EAA8E;AAC9E,eAAO,MAAM,wCAAwC,QAGpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,ysGAwFzC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,6BAA6B,+uOAgJzC,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACrE,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,gBAAgB,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC7D,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;CAC3C;AAED,MAAM,WAAW,wBAAwB;IACvC,sFAAsF;IACtF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAqgBD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,wBAA6B,GACrC,aAAa,CAAC,sBAAsB,CAAC,CAkMvC"}

package/dist/cloud/frame-context.d.ts

@@ -0,0 +1,8 @@
+import type { World } from '@forgeax/engine-ecs';
+import type { RenderFeatureFrameContext, RenderFeatureViewContext } from '../features/types';
+import type { CameraSnapshot } from '../render-contract';
+import type { ExtractedCloudLayer } from './extract';
+/** Project the stable camera/world facts consumed by the cloud feature owner. */
+export declare function createCloudFeatureView(camera: CameraSnapshot | undefined, worlds: readonly World[], cameraOwner: number, width: number, height: number, deviceGeneration: number, cameraCut: boolean, recovery: boolean): RenderFeatureViewContext | undefined;
+export declare function createCloudFeatureFrameContext(cloudLayer: ExtractedCloudLayer | undefined, view: RenderFeatureViewContext | undefined): RenderFeatureFrameContext;
+//# sourceMappingURL=frame-context.d.ts.map

package/dist/cloud/frame-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-context.d.ts","sourceRoot":"","sources":["../../src/cloud/frame-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD,iFAAiF;AACjF,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,OAAO,GAChB,wBAAwB,GAAG,SAAS,CAgBtC;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,mBAAmB,GAAG,SAAS,EAC3C,IAAI,EAAE,wBAAwB,GAAG,SAAS,GACzC,yBAAyB,CAK3B"}

package/dist/cloud/inspection.d.ts

@@ -0,0 +1,59 @@
+import type { RhiCaps } from '@forgeax/engine-rhi';
+import type { CloudLayerResourceFacts } from './resources';
+import type { CloudTemporalResetReason } from './temporal';
+export type CloudLayerInspectionStatus = 'off' | 'available' | 'unavailable' | 'degraded';
+export type CloudLayerResourceStage = 'none' | 'candidate' | 'accepted' | 'lkg' | 'recovering';
+/** Physical-adapter evidence is explicit; RHI backend labels cannot prove it. */
+export type CloudPhysicalGpuEvidence = 'unknown' | 'available' | 'unavailable';
+export interface CloudLayerBudgetObservation {
+    readonly measured: boolean;
+    readonly physicalGpu: CloudPhysicalGpuEvidence;
+    readonly gpuTimestamp: boolean;
+    readonly quality: 'low' | 'medium' | 'high' | undefined;
+    readonly warmupFrames: number;
+    readonly sampleFrames: number;
+    readonly p50GpuMs: number | undefined;
+    readonly p95GpuMs: number | undefined;
+    readonly coldGenerationMs: number | undefined;
+    readonly frameBudgetMs: number | undefined;
+    readonly reason?: string;
+}
+export interface CloudLayerInspection {
+    readonly status: CloudLayerInspectionStatus;
+    readonly resourceStage: CloudLayerResourceStage;
+    readonly sourceKey: string | undefined;
+    readonly generation: number | undefined;
+    readonly candidateGeneration: number | undefined;
+    readonly lkgGeneration: number | undefined;
+    readonly shadowRevision: number | undefined;
+    readonly temporalResets: number;
+    readonly lastTemporalReset: CloudTemporalResetReason | undefined;
+    readonly resourceFacts: CloudLayerResourceFacts | undefined;
+    readonly capability: {
+        readonly compute: boolean;
+        readonly storageBuffer: boolean;
+        readonly rgba16floatRenderable: boolean;
+        readonly physicalGpu: CloudPhysicalGpuEvidence;
+        readonly timestampQuery: boolean;
+    };
+    readonly budget: CloudLayerBudgetObservation;
+}
+export interface CloudLayerInspectionInput {
+    readonly authored: boolean;
+    readonly sourceKey?: string;
+    readonly generation?: number;
+    readonly candidateGeneration?: number;
+    readonly lkgGeneration?: number;
+    readonly shadowRevision?: number;
+    readonly temporalResets?: number;
+    readonly lastTemporalReset?: CloudTemporalResetReason;
+    readonly resourceFacts?: CloudLayerResourceFacts;
+    readonly capability?: Partial<CloudLayerInspection['capability']>;
+    readonly degraded?: boolean;
+    readonly budget?: Partial<CloudLayerBudgetObservation>;
+}
+/** Capability and lifecycle facts are inspectable even when the lane is unavailable. */
+export declare function inspectCloudLayer(input: CloudLayerInspectionInput): CloudLayerInspection;
+/** Convert RHI facts without letting inspection invent physical measurements. */
+export declare function cloudCapabilitiesFromRhi(caps: Readonly<RhiCaps>): CloudLayerInspection['capability'];
+//# sourceMappingURL=inspection.d.ts.map

package/dist/cloud/inspection.d.ts.map

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

package/dist/cloud/optics.d.ts

@@ -0,0 +1,56 @@
+import type { CloudDensityCache } from './density';
+import { type ValidatedCloudLayer } from './parameters';
+export type CloudOpticalPath = 'camera' | 'solar-column' | 'cloud-interior';
+export interface CloudRay {
+    readonly origin: readonly [number, number, number];
+    readonly direction: readonly [number, number, number];
+    readonly maxDistance: number;
+}
+export interface CloudOpticalResult {
+    readonly path: CloudOpticalPath;
+    readonly transmittance: number;
+    readonly scattering: readonly [number, number, number];
+    readonly opticalDepth: number;
+    readonly representativeDepth: number;
+    readonly steps: number;
+    readonly entered: boolean;
+    readonly exited: boolean;
+}
+export interface CloudInteriorLighting {
+    readonly sunRadiance: readonly [number, number, number];
+    readonly sunDirection: readonly [number, number, number];
+    readonly phaseG?: number;
+}
+export interface CloudOpticsInput {
+    readonly params: ValidatedCloudLayer;
+    readonly ray: CloudRay;
+    readonly path: CloudOpticalPath;
+    readonly timeSeconds?: number;
+    readonly cache?: CloudDensityCache;
+    readonly steps?: number;
+    readonly lighting?: CloudInteriorLighting;
+}
+export declare function intersectCloudLayer(ray: CloudRay, params: ValidatedCloudLayer): {
+    readonly start: number;
+    readonly end: number;
+} | undefined;
+/** Unit-sun incident light, using the same phase basis as production volumes. */
+export declare function cloudIncidentLight(solarT: number, cosTheta: number, height: number, forwardG?: number): readonly [number, number, number];
+/**
+ * Integrate one explicitly named optical path through the layer.
+ *
+ * Camera, solar-column and cloud-interior paths are intentionally separate
+ * call sites. A caller cannot accidentally use a camera interval as the
+ * light interval and apply the same cloud attenuation twice.
+ */
+export declare function integrateCloudPath(input: CloudOpticsInput): CloudOpticalResult;
+export declare function integrateCloudCameraPath(params: ValidatedCloudLayer, ray: CloudRay, options?: Omit<CloudOpticsInput, 'params' | 'ray' | 'path'>): CloudOpticalResult;
+export declare function integrateCloudSolarColumn(params: ValidatedCloudLayer, origin: readonly [number, number, number], sunDirection: readonly [number, number, number], options?: Omit<CloudOpticsInput, 'params' | 'ray' | 'path'> & {
+    readonly maxDistance?: number;
+}): CloudOpticalResult;
+export declare function integrateCloudInterior(params: ValidatedCloudLayer, ray: CloudRay, lighting: CloudInteriorLighting, options?: Omit<CloudOpticsInput, 'params' | 'ray' | 'path' | 'lighting'>): CloudOpticalResult;
+/** Standard's one selected sun term consumes this factor exactly once. */
+export declare function applyCloudSolarTransmittance(directSunRadiance: readonly [number, number, number], cloudTransmittance: number, meshVisibility?: number): readonly [number, number, number];
+/** Scene-linear HDR composition at the cloud interval/depth boundary. */
+export declare function compositeCloudRadiance(sceneLinearHdr: readonly [number, number, number, number], cloud: CloudOpticalResult, sceneDepth: number, cloudDepth?: number): readonly [number, number, number, number];
+//# sourceMappingURL=optics.d.ts.map

package/dist/cloud/optics.d.ts.map

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

package/dist/cloud/parameters.d.ts

@@ -0,0 +1,73 @@
+import { type Result } from '@forgeax/engine-types';
+import { type CloudLayerData, type CloudQuality } from '../components/cloud-layer';
+import { type CloudLayerError } from '../errors/cloud';
+export interface CloudLayerAuthoring {
+    readonly seed?: number;
+    readonly baseHeight?: number;
+    readonly thickness?: number;
+    readonly scale?: number;
+    readonly coverage?: number;
+    readonly density?: number;
+    readonly wind?: ArrayLike<number>;
+    readonly quality?: CloudQuality | number;
+    readonly shadowRange?: number;
+}
+export interface ValidatedCloudLayer {
+    readonly seed: number;
+    readonly baseHeight: number;
+    readonly thickness: number;
+    readonly scale: number;
+    readonly coverage: number;
+    readonly density: number;
+    readonly wind: readonly [number, number, number];
+    readonly quality: CloudQuality;
+    readonly shadowRange: number;
+}
+export interface CloudQualityProfile {
+    readonly cacheResolution: number;
+    readonly viewSteps: number;
+    readonly shadowSteps: number;
+    readonly historyWeight: number;
+    /** Renderer-owned sky trace domain in world units; independent of Camera.far. */
+    readonly viewDistance: number;
+}
+/**
+ * Quality values are bounded in one place. The values are deliberately
+ * renderer policy, while the component stores only the closed quality code.
+ */
+export declare const CLOUD_QUALITY_PROFILES: Readonly<Record<CloudQuality, CloudQualityProfile>>;
+/**
+ * The spatial cloud-shadow map is intentionally derived from the same quality
+ * profile everywhere: graph allocation, light-space projection and inspection
+ * must agree on one texel grid.  Keep the multiplier here rather than letting
+ * each owner invent a resolution.
+ */
+export declare function cloudShadowResolutionForQuality(qualityValue: CloudQuality): number;
+/**
+ * Cloud visibility is a sky-domain concern. It must not inherit the opaque
+ * geometry far plane or the finite receiver-shadow footprint: either value is
+ * commonly much shorter than a ground-view cloud trace and would turn the
+ * distant layer into a flat wall.
+ */
+export declare function cloudViewDistanceForQuality(qualityValue: CloudQuality): number;
+/** rgba16float is four 16-bit channels (8 bytes per texel). */
+export declare const CLOUD_SHADOW_BYTES_PER_TEXEL = 8;
+/**
+ * Authored density is a normalized formation value. Convert it to a bounded
+ * per-world-unit extinction coefficient only at integration time; otherwise a
+ * long horizon step would become opaque after its first sample and expose
+ * marching bands instead of a participating volume.
+ */
+export declare const CLOUD_EXTINCTION_COEFFICIENT = 0.03;
+export declare const DEFAULT_CLOUD_LAYER: ValidatedCloudLayer;
+/** Validate one detached CloudLayer POD before deriving cache or graph state. */
+export declare function validateCloudLayer(input: CloudLayerAuthoring | Partial<CloudLayerData> | undefined): Result<ValidatedCloudLayer, CloudLayerError>;
+/** Stable source identity used by cache, history and recovery receipts. */
+export declare function cloudLayerSourceKey(params: ValidatedCloudLayer): string;
+/**
+ * Stable identity for the reusable formation bases. Coverage, density and
+ * wind are evaluation inputs and deliberately do not rebuild the weather,
+ * body or erosion cache when they change continuously.
+ */
+export declare function cloudLayerFormationKey(params: ValidatedCloudLayer): string;
+//# sourceMappingURL=parameters.d.ts.map

package/dist/cloud/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/cloud/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,YAAY,EAGlB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,eAAe,EAAmC,MAAM,iBAAiB,CAAC;AAExF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,mBAAmB,CAAC,CAyBnF,CAAC;AAEL;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAElF;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAE9E;AAED,+DAA+D;AAC/D,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,OAAO,CAAC;AAEjD,eAAO,MAAM,mBAAmB,EAAE,mBAUhC,CAAC;AAqDH,iFAAiF;AACjF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,GAC/D,MAAM,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAkD9C;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAevE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAS1E"}