@plasius/gpu-shared 0.1.13 → 0.1.15

package/dist/dist-B5R2GZQR.js

@@ -0,0 +1,1433 @@
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// node_modules/@plasius/gpu-lighting/dist/index.js
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function createModuleBaseUrl(metaUrl) {
+  return Reflect.construct(URL, [String(metaUrl)]);
+}
+var baseUrl = (() => {
+  if (typeof import.meta.url !== "undefined") {
+    return createModuleBaseUrl(import.meta.url);
+  }
+  if (typeof __filename !== "undefined" && typeof __require2 !== "undefined") {
+    const { pathToFileURL } = __require2("url");
+    return pathToFileURL(__filename);
+  }
+  const base = typeof process !== "undefined" && process.cwd ? `file://${process.cwd()}/` : "file:///";
+  return new URL("./index.js", base);
+})();
+var techniqueSpecs = {
+  hybrid: {
+    description: "Lumen-inspired hybrid realtime GI and reflections with radiance cache final gather.",
+    prelude: "prelude.wgsl",
+    jobs: {
+      directLighting: "direct-lighting.job.wgsl",
+      screenTrace: "screen-trace.job.wgsl",
+      radianceCache: "radiance-cache.job.wgsl",
+      finalGather: "final-gather.job.wgsl",
+      reflectionResolve: "reflection-resolve.job.wgsl"
+    }
+  },
+  pathtracer: {
+    description: "Monte Carlo path-traced reference mode with progressive accumulation and denoise stage.",
+    prelude: "prelude.wgsl",
+    jobs: {
+      pathTrace: "pathtrace.job.wgsl",
+      accumulate: "accumulate.job.wgsl",
+      denoise: "denoise.job.wgsl"
+    }
+  },
+  volumetrics: {
+    description: "Froxel volumetric lighting for fog, shafts, and participating media shadows.",
+    prelude: "prelude.wgsl",
+    jobs: {
+      froxelIntegrate: "froxel-integrate.job.wgsl",
+      volumetricShadow: "volumetric-shadow.job.wgsl"
+    }
+  },
+  hdri: {
+    description: "HDRI and IBL precompute passes including irradiance, specular prefilter, and BRDF LUT.",
+    prelude: "prelude.wgsl",
+    jobs: {
+      irradianceConvolution: "irradiance-convolution.job.wgsl",
+      specularPrefilter: "specular-prefilter.job.wgsl",
+      brdfLut: "brdf-lut.job.wgsl"
+    }
+  }
+};
+function buildTechnique(name, spec) {
+  const preludeUrl = new URL(`./techniques/${name}/${spec.prelude}`, baseUrl);
+  const jobs = Object.entries(spec.jobs).map(([key, file]) => {
+    const label = `lighting.${name}.${key}`;
+    return {
+      key,
+      label,
+      url: new URL(`./techniques/${name}/${file}`, baseUrl),
+      sourceName: label
+    };
+  });
+  return {
+    name,
+    description: spec.description,
+    preludeUrl,
+    jobs
+  };
+}
+var lightingTechniques = Object.freeze(
+  Object.fromEntries(
+    Object.entries(techniqueSpecs).map(([name, spec]) => [
+      name,
+      buildTechnique(name, spec)
+    ])
+  )
+);
+var lightingTechniqueNames = Object.freeze(Object.keys(lightingTechniques));
+var defaultLightingTechnique = "hybrid";
+var profileSpecs = {
+  realtime: {
+    description: "Primary runtime profile: hybrid GI/reflections with volumetrics and HDRI/IBL.",
+    techniques: ["hybrid", "volumetrics", "hdri"]
+  },
+  hybrid: {
+    description: "Hybrid-focused profile for direct tuning of Lumen-inspired realtime passes.",
+    techniques: ["hybrid", "hdri"]
+  },
+  reference: {
+    description: "Reference quality profile: path tracing plus volumetrics and HDRI/IBL validation.",
+    techniques: ["pathtracer", "volumetrics", "hdri"]
+  }
+};
+function buildProfile(name, spec) {
+  return {
+    name,
+    description: spec.description,
+    techniques: [...spec.techniques]
+  };
+}
+var lightingProfiles = Object.freeze(
+  Object.fromEntries(
+    Object.entries(profileSpecs).map(([name, spec]) => [
+      name,
+      buildProfile(name, spec)
+    ])
+  )
+);
+var lightingProfileNames = Object.freeze(Object.keys(lightingProfiles));
+var defaultLightingProfile = "realtime";
+var lightingProfileModeOrder = Object.freeze([
+  "realtime",
+  "hybrid",
+  "reference"
+]);
+var lightingEnvironmentPresetNames = Object.freeze([
+  "moonlit-harbor",
+  "product-studio",
+  "neutral-studio"
+]);
+var defaultAdaptiveLightingProfilePolicy = Object.freeze({
+  preferredProfile: "reference",
+  minimumFrameRate: 30,
+  sampleWindowSize: 4
+});
+var lightingDistanceBands = Object.freeze([
+  "near",
+  "mid",
+  "far",
+  "horizon"
+]);
+var lightingWorkerQueueClass = "lighting";
+var lightingDebugOwner = "lighting";
+function freezeVec4(value) {
+  return Object.freeze([value[0], value[1], value[2], value[3] ?? 1]);
+}
+function normalizeVector3(value, fallback) {
+  if (!Array.isArray(value) || value.length < 3) {
+    return [...fallback];
+  }
+  const vector = [
+    Number.isFinite(value[0]) ? value[0] : fallback[0],
+    Number.isFinite(value[1]) ? value[1] : fallback[1],
+    Number.isFinite(value[2]) ? value[2] : fallback[2]
+  ];
+  const length = Math.hypot(vector[0], vector[1], vector[2]);
+  if (!Number.isFinite(length) || length <= 1e-6) {
+    return [...fallback];
+  }
+  return vector.map((component) => component / length);
+}
+function readColor(value, fallback) {
+  if (!Array.isArray(value) || value.length < 3) {
+    return freezeVec4(fallback);
+  }
+  return freezeVec4([
+    Number.isFinite(value[0]) ? Math.max(0, value[0]) : fallback[0],
+    Number.isFinite(value[1]) ? Math.max(0, value[1]) : fallback[1],
+    Number.isFinite(value[2]) ? Math.max(0, value[2]) : fallback[2],
+    Number.isFinite(value[3]) ? Math.max(0, Math.min(1, value[3])) : fallback[3] ?? 1
+  ]);
+}
+function readFinite(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+var environmentLightingPresets = Object.freeze({
+  "moonlit-harbor": Object.freeze({
+    preset: "moonlit-harbor",
+    environmentMode: 0,
+    environmentIntensity: 0.86,
+    exposure: 1,
+    horizonColor: freezeVec4([0.33, 0.43, 0.53, 1]),
+    zenithColor: freezeVec4([0.035, 0.07, 0.14, 1]),
+    sunDirection: Object.freeze(normalizeVector3([0.22, 0.88, 0.42], [0, 1, 0])),
+    sunColor: freezeVec4([2.1, 2.25, 2.65, 1]),
+    ambientColor: freezeVec4([0.018, 0.023, 0.03, 1])
+  }),
+  "product-studio": Object.freeze({
+    preset: "product-studio",
+    environmentMode: 1,
+    environmentIntensity: 1.05,
+    exposure: 1,
+    horizonColor: freezeVec4([0.52, 0.61, 0.65, 1]),
+    zenithColor: freezeVec4([0.18, 0.22, 0.26, 1]),
+    sunDirection: Object.freeze(normalizeVector3([0.18, 0.93, 0.24], [0, 1, 0])),
+    sunColor: freezeVec4([3.8, 3.55, 2.85, 1]),
+    ambientColor: freezeVec4([0.024, 0.027, 0.03, 1])
+  }),
+  "neutral-studio": Object.freeze({
+    preset: "neutral-studio",
+    environmentMode: 2,
+    environmentIntensity: 0.95,
+    exposure: 1,
+    horizonColor: freezeVec4([0.48, 0.53, 0.55, 1]),
+    zenithColor: freezeVec4([0.24, 0.26, 0.29, 1]),
+    sunDirection: Object.freeze(normalizeVector3([-0.24, 0.86, 0.36], [0, 1, 0])),
+    sunColor: freezeVec4([2.4, 2.35, 2.2, 1]),
+    ambientColor: freezeVec4([0.028, 0.029, 0.03, 1])
+  })
+});
+function resolveEnvironmentPreset(name) {
+  const presetName = typeof name === "string" && name.length > 0 ? name : "product-studio";
+  const preset = environmentLightingPresets[presetName];
+  if (!preset) {
+    throw new Error(
+      `Unknown lighting environment preset "${presetName}". Expected one of: ${lightingEnvironmentPresetNames.join(", ")}.`
+    );
+  }
+  return preset;
+}
+function estimateEnvironmentColor(config) {
+  const horizonWeight = 0.58;
+  const zenithWeight = 1 - horizonWeight;
+  const glowWeight = 0.055;
+  const intensity = Math.max(config.environmentIntensity, 1e-4);
+  return freezeVec4([
+    (config.horizonColor[0] * horizonWeight + config.zenithColor[0] * zenithWeight + config.sunColor[0] * glowWeight) * intensity,
+    (config.horizonColor[1] * horizonWeight + config.zenithColor[1] * zenithWeight + config.sunColor[1] * glowWeight) * intensity,
+    (config.horizonColor[2] * horizonWeight + config.zenithColor[2] * zenithWeight + config.sunColor[2] * glowWeight) * intensity,
+    1
+  ]);
+}
+function createEnvironmentLightingConfig(options = {}) {
+  const preset = resolveEnvironmentPreset(options.preset ?? options.name);
+  const environmentIntensity = Math.max(
+    readFinite(options.environmentIntensity ?? options.intensity, preset.environmentIntensity),
+    1e-4
+  );
+  const config = {
+    preset: preset.preset,
+    profile: typeof options.profile === "string" ? options.profile : defaultLightingProfile,
+    environmentMode: Math.max(0, Math.trunc(readFinite(options.environmentMode, preset.environmentMode))),
+    environmentIntensity,
+    exposure: Math.max(1e-4, readFinite(options.exposure, preset.exposure)),
+    horizonColor: readColor(options.horizonColor, preset.horizonColor),
+    zenithColor: readColor(options.zenithColor, preset.zenithColor),
+    sunDirection: Object.freeze(
+      normalizeVector3(options.sunDirection, preset.sunDirection)
+    ),
+    sunColor: readColor(options.sunColor, preset.sunColor),
+    ambientColor: readColor(options.ambientColor, preset.ambientColor)
+  };
+  const environmentColor = estimateEnvironmentColor(config);
+  return Object.freeze({
+    ...config,
+    environmentColor,
+    wavefront: Object.freeze({
+      environmentColor,
+      ambientColor: config.ambientColor,
+      environmentLighting: Object.freeze({
+        horizonColor: config.horizonColor,
+        zenithColor: config.zenithColor,
+        sunDirection: Object.freeze([...config.sunDirection]),
+        sunColor: config.sunColor,
+        intensity: config.environmentIntensity,
+        mode: config.environmentMode,
+        exposure: config.exposure
+      })
+    })
+  });
+}
+function createWavefrontEnvironmentLightingOptions(options = {}) {
+  const config = createEnvironmentLightingConfig(options);
+  return Object.freeze({
+    environmentColor: config.wavefront.environmentColor,
+    ambientColor: config.wavefront.ambientColor,
+    environmentLighting: config.wavefront.environmentLighting,
+    lightingEnvironment: config
+  });
+}
+var lightingImportanceLevels = Object.freeze([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+var lightingBandPolicySpecs = Object.freeze({
+  near: Object.freeze({
+    primaryShadowSource: "ray-traced-primary",
+    assistShadowSources: Object.freeze(["visibility-raster", "shadow-map-assist"]),
+    temporalReuse: "balanced",
+    updateCadenceDivisor: 1,
+    liveObjectShadows: true,
+    impressionOnly: false
+  }),
+  mid: Object.freeze({
+    primaryShadowSource: "selective-raster-and-proxy",
+    assistShadowSources: Object.freeze([
+      "regional-shadow-map",
+      "proxy-caster",
+      "temporal-history"
+    ]),
+    temporalReuse: "aggressive",
+    updateCadenceDivisor: 2,
+    liveObjectShadows: true,
+    impressionOnly: false
+  }),
+  far: Object.freeze({
+    primaryShadowSource: "merged-proxy-casters",
+    assistShadowSources: Object.freeze([
+      "coarse-directional",
+      "semi-static-occlusion"
+    ]),
+    temporalReuse: "high",
+    updateCadenceDivisor: 8,
+    liveObjectShadows: false,
+    impressionOnly: false
+  }),
+  horizon: Object.freeze({
+    primaryShadowSource: "baked-impression",
+    assistShadowSources: Object.freeze(["atmospheric-gradient", "skyline-darkening"]),
+    temporalReuse: "baked",
+    updateCadenceDivisor: 60,
+    liveObjectShadows: false,
+    impressionOnly: true
+  })
+});
+function assertLightingImportance(name, value) {
+  if (!lightingImportanceLevels.includes(value)) {
+    throw new Error(
+      `${name} must be one of: ${lightingImportanceLevels.join(", ")}.`
+    );
+  }
+  return value;
+}
+function readPositiveIntegerOption(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || Math.round(value) !== value) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+  return value;
+}
+function resolveBandParticipation(profileName, band, importance) {
+  const referenceProfile = profileName === "reference";
+  const premiumImportance = importance === "critical" || importance === "high";
+  if (band === "near") {
+    return Object.freeze({
+      directShadows: premiumImportance ? "premium" : "selective",
+      reflections: premiumImportance ? "premium" : "selective",
+      globalIllumination: referenceProfile || importance === "critical" ? "premium" : "selective"
+    });
+  }
+  if (band === "mid") {
+    return Object.freeze({
+      directShadows: premiumImportance ? "selective" : "proxy",
+      reflections: referenceProfile && premiumImportance ? "selective" : "proxy",
+      globalIllumination: referenceProfile && importance === "critical" ? "selective" : "disabled"
+    });
+  }
+  if (band === "far") {
+    return Object.freeze({
+      directShadows: "proxy",
+      reflections: referenceProfile && importance === "critical" ? "proxy" : "disabled",
+      globalIllumination: "disabled"
+    });
+  }
+  return Object.freeze({
+    directShadows: "disabled",
+    reflections: "disabled",
+    globalIllumination: "disabled"
+  });
+}
+function createLightingBandPlan(options = {}) {
+  const profileName = options.profile ?? defaultLightingProfile;
+  const profile = getLightingProfile(profileName);
+  const importance = assertLightingImportance(
+    "importance",
+    options.importance ?? "high"
+  );
+  const bands = Object.freeze(
+    lightingDistanceBands.map(
+      (band) => Object.freeze({
+        band,
+        profile: profile.name,
+        importance,
+        primaryShadowSource: lightingBandPolicySpecs[band].primaryShadowSource,
+        assistShadowSources: Object.freeze([
+          ...lightingBandPolicySpecs[band].assistShadowSources
+        ]),
+        rtParticipation: resolveBandParticipation(profile.name, band, importance),
+        temporalReuse: lightingBandPolicySpecs[band].temporalReuse,
+        updateCadenceDivisor: lightingBandPolicySpecs[band].updateCadenceDivisor,
+        liveObjectShadows: lightingBandPolicySpecs[band].liveObjectShadows,
+        impressionOnly: lightingBandPolicySpecs[band].impressionOnly
+      })
+    )
+  );
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: lightingDebugOwner,
+    profile: profile.name,
+    importance,
+    techniques: Object.freeze([...profile.techniques]),
+    bands
+  });
+}
+var lightingProfileModeEstimatedCostMs = Object.freeze({
+  realtime: 4.5,
+  hybrid: 7.5,
+  reference: 12.5
+});
+function createLightingProfileModeLadder(options = {}) {
+  const moduleId = typeof options.id === "string" && options.id.trim().length > 0 ? options.id.trim() : "lighting-profile-mode";
+  const preferredProfile = getLightingProfile(
+    options.preferredProfile ?? defaultAdaptiveLightingProfilePolicy.preferredProfile
+  ).name;
+  const initialProfile = getLightingProfile(
+    options.initialProfile ?? preferredProfile
+  ).name;
+  const minimumFrameRate = readPositiveIntegerOption(
+    "minimumFrameRate",
+    options.minimumFrameRate,
+    defaultAdaptiveLightingProfilePolicy.minimumFrameRate
+  );
+  const sampleWindowSize = readPositiveIntegerOption(
+    "sampleWindowSize",
+    options.sampleWindowSize,
+    defaultAdaptiveLightingProfilePolicy.sampleWindowSize
+  );
+  const importance = assertLightingImportance(
+    "importance",
+    options.importance ?? "high"
+  );
+  const moduleImportance = assertLightingImportance(
+    "moduleImportance",
+    options.moduleImportance ?? "critical"
+  );
+  const levels = Object.freeze(
+    lightingProfileModeOrder.map((profileName) => {
+      const profile = getLightingProfile(profileName);
+      return Object.freeze({
+        id: profile.name,
+        estimatedCostMs: lightingProfileModeEstimatedCostMs[profile.name],
+        config: Object.freeze({
+          profile: profile.name,
+          description: profile.description,
+          techniques: Object.freeze([...profile.techniques]),
+          lightingBandPlan: createLightingBandPlan({
+            profile: profile.name,
+            importance
+          }),
+          policy: Object.freeze({
+            preferredProfile,
+            minimumFrameRate,
+            sampleWindowSize
+          })
+        })
+      });
+    })
+  );
+  return Object.freeze({
+    id: moduleId,
+    domain: "lighting",
+    authority: "visual",
+    importance: moduleImportance,
+    initialLevel: initialProfile,
+    levels,
+    target: Object.freeze({
+      minimumFrameRate,
+      maximumFrameRate: minimumFrameRate,
+      preferredFrameRates: Object.freeze([minimumFrameRate])
+    }),
+    adaptation: Object.freeze({
+      sampleWindowSize,
+      minimumSamplesBeforeAdjustment: sampleWindowSize,
+      degradeCooldownFrames: 1,
+      upgradeCooldownFrames: sampleWindowSize,
+      minStableFramesForRecovery: sampleWindowSize
+    }),
+    policy: Object.freeze({
+      preferredProfile,
+      minimumFrameRate,
+      sampleWindowSize
+    })
+  });
+}
+function buildWorkerBudgetLevels(jobType, queueClass, presets) {
+  return Object.freeze([
+    Object.freeze({
+      id: "low",
+      estimatedCostMs: presets.low.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.low.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.low.maxJobsPerDispatch,
+        cadenceDivisor: presets.low.cadenceDivisor,
+        workgroupScale: presets.low.workgroupScale,
+        maxQueueDepth: presets.low.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "low"
+        })
+      })
+    }),
+    Object.freeze({
+      id: "medium",
+      estimatedCostMs: presets.medium.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.medium.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.medium.maxJobsPerDispatch,
+        cadenceDivisor: presets.medium.cadenceDivisor,
+        workgroupScale: presets.medium.workgroupScale,
+        maxQueueDepth: presets.medium.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "medium"
+        })
+      })
+    }),
+    Object.freeze({
+      id: "high",
+      estimatedCostMs: presets.high.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.high.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.high.maxJobsPerDispatch,
+        cadenceDivisor: presets.high.cadenceDivisor,
+        workgroupScale: presets.high.workgroupScale,
+        maxQueueDepth: presets.high.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "high"
+        })
+      })
+    })
+  ]);
+}
+var lightingWorkerSpecPresets = {
+  hybrid: {
+    suggestedAllocationIds: [
+      "lighting.hybrid.radiance-cache",
+      "lighting.hybrid.reflection-history",
+      "lighting.hybrid.shadow-atlas"
+    ],
+    jobs: {
+      directLighting: {
+        domain: "lighting",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.directLighting",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 128
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 256
+            },
+            high: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 256,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 512
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.shadow-atlas"]
+      },
+      screenTrace: {
+        domain: "reflections",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.screenTrace",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 3,
+              workgroupScale: 0.4,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 2,
+              workgroupScale: 0.7,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 2.2,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 192,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 384
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.reflection-history"]
+      },
+      radianceCache: {
+        domain: "lighting",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.radianceCache",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.7,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.8,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.radiance-cache"]
+      },
+      finalGather: {
+        domain: "lighting",
+        importance: "critical",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.finalGather",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 48,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 128
+            },
+            medium: {
+              estimatedCostMs: 1.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 256
+            },
+            high: {
+              estimatedCostMs: 2.6,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 192,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 384
+            }
+          }
+        ),
+        suggestedAllocationIds: [
+          "lighting.hybrid.radiance-cache",
+          "lighting.hybrid.reflection-history"
+        ]
+      },
+      reflectionResolve: {
+        domain: "reflections",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.reflectionResolve",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.reflection-history"]
+      }
+    }
+  },
+  pathtracer: {
+    suggestedAllocationIds: [
+      "lighting.pathtracer.path-state",
+      "lighting.pathtracer.accumulation",
+      "lighting.pathtracer.denoise-history"
+    ],
+    jobs: {
+      pathTrace: {
+        domain: "lighting",
+        importance: "critical",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.pathTrace",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 3,
+              workgroupScale: 0.45,
+              maxQueueDepth: 48
+            },
+            medium: {
+              estimatedCostMs: 2.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.7,
+              maxQueueDepth: 96
+            },
+            high: {
+              estimatedCostMs: 3.8,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 128
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.path-state"]
+      },
+      accumulate: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.accumulate",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 32
+            },
+            medium: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 64
+            },
+            high: {
+              estimatedCostMs: 1.1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 96
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.accumulation"]
+      },
+      denoise: {
+        domain: "post-processing",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.denoise",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 32
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 64
+            },
+            high: {
+              estimatedCostMs: 1.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 96
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.denoise-history"]
+      }
+    }
+  },
+  volumetrics: {
+    suggestedAllocationIds: [
+      "lighting.volumetrics.froxel-grid",
+      "lighting.volumetrics.shadow-history"
+    ],
+    jobs: {
+      froxelIntegrate: {
+        domain: "volumetrics",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.volumetrics.froxelIntegrate",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.6,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.7,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.volumetrics.froxel-grid"]
+      },
+      volumetricShadow: {
+        domain: "volumetrics",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.volumetrics.volumetricShadow",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 24,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 64
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 48,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 128
+            },
+            high: {
+              estimatedCostMs: 1.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 192
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.volumetrics.shadow-history"]
+      }
+    }
+  },
+  hdri: {
+    suggestedAllocationIds: [
+      "lighting.hdri.cubemap",
+      "lighting.hdri.prefilter",
+      "lighting.hdri.brdf-lut"
+    ],
+    jobs: {
+      irradianceConvolution: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.irradianceConvolution",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            },
+            medium: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 32
+            },
+            high: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.cubemap"]
+      },
+      specularPrefilter: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.specularPrefilter",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            },
+            medium: {
+              estimatedCostMs: 0.7,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 32
+            },
+            high: {
+              estimatedCostMs: 1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.prefilter"]
+      },
+      brdfLut: {
+        domain: "lighting",
+        importance: "low",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.brdfLut",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 4,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 8
+            },
+            medium: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 16
+            },
+            high: {
+              estimatedCostMs: 0.6,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 24
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.brdf-lut"]
+      }
+    }
+  }
+};
+var lightingWorkerDagSpecs = {
+  hybrid: {
+    directLighting: { priority: 4, dependencies: [] },
+    screenTrace: { priority: 3, dependencies: [] },
+    radianceCache: { priority: 4, dependencies: ["directLighting"] },
+    finalGather: { priority: 2, dependencies: ["radianceCache", "screenTrace"] },
+    reflectionResolve: {
+      priority: 1,
+      dependencies: ["screenTrace", "finalGather"]
+    }
+  },
+  pathtracer: {
+    pathTrace: { priority: 4, dependencies: [] },
+    accumulate: { priority: 3, dependencies: ["pathTrace"] },
+    denoise: { priority: 2, dependencies: ["accumulate"] }
+  },
+  volumetrics: {
+    volumetricShadow: { priority: 3, dependencies: [] },
+    froxelIntegrate: { priority: 2, dependencies: ["volumetricShadow"] }
+  },
+  hdri: {
+    irradianceConvolution: { priority: 3, dependencies: [] },
+    specularPrefilter: { priority: 3, dependencies: [] },
+    brdfLut: {
+      priority: 2,
+      dependencies: ["irradianceConvolution", "specularPrefilter"]
+    }
+  }
+};
+function resolveLightingQualityDimensions(techniqueName, jobKey) {
+  const key = `${techniqueName}.${jobKey}`;
+  return Object.freeze(
+    {
+      "hybrid.directLighting": { shadows: 1, lightingSamples: 0.7 },
+      "hybrid.screenTrace": { rayTracing: 1, temporalReuse: 0.4 },
+      "hybrid.radianceCache": {
+        lightingSamples: 0.8,
+        updateCadence: 0.7,
+        temporalReuse: 1
+      },
+      "hybrid.finalGather": { lightingSamples: 1, rayTracing: 0.6 },
+      "hybrid.reflectionResolve": {
+        rayTracing: 0.5,
+        temporalReuse: 1,
+        shading: 0.3
+      },
+      "pathtracer.pathTrace": { rayTracing: 1, lightingSamples: 1 },
+      "pathtracer.accumulate": { temporalReuse: 1, updateCadence: 0.4 },
+      "pathtracer.denoise": { temporalReuse: 1, shading: 0.4 },
+      "volumetrics.froxelIntegrate": {
+        lightingSamples: 0.6,
+        shading: 0.4,
+        updateCadence: 0.3
+      },
+      "volumetrics.volumetricShadow": { shadows: 0.8, updateCadence: 0.5 },
+      "hdri.irradianceConvolution": {
+        lightingSamples: 0.4,
+        temporalReuse: 1,
+        updateCadence: 1
+      },
+      "hdri.specularPrefilter": {
+        lightingSamples: 0.5,
+        temporalReuse: 1,
+        updateCadence: 1
+      },
+      "hdri.brdfLut": {
+        shading: 0.4,
+        temporalReuse: 1,
+        updateCadence: 1
+      }
+    }[key] ?? {}
+  );
+}
+function resolveLightingImportanceSignals(techniqueName, jobKey) {
+  const key = `${techniqueName}.${jobKey}`;
+  return Object.freeze(
+    {
+      "hybrid.directLighting": { visible: true, shadowSignificance: "high" },
+      "hybrid.screenTrace": { visible: true, reflectionSignificance: "high" },
+      "hybrid.radianceCache": { visible: true },
+      "hybrid.finalGather": {
+        visible: true,
+        shadowSignificance: "critical",
+        reflectionSignificance: "high"
+      },
+      "hybrid.reflectionResolve": { visible: true, reflectionSignificance: "high" },
+      "pathtracer.pathTrace": {
+        visible: true,
+        shadowSignificance: "high",
+        reflectionSignificance: "high"
+      },
+      "pathtracer.accumulate": { visible: true },
+      "pathtracer.denoise": { visible: true },
+      "volumetrics.froxelIntegrate": { visible: true },
+      "volumetrics.volumetricShadow": { visible: true, shadowSignificance: "high" },
+      "hdri.irradianceConvolution": { visible: false },
+      "hdri.specularPrefilter": { visible: false, reflectionSignificance: "medium" },
+      "hdri.brdfLut": { visible: false }
+    }[key] ?? {}
+  );
+}
+function buildWorkerManifestJob(techniqueName, job) {
+  const spec = lightingWorkerSpecPresets[techniqueName].jobs[job.key];
+  const dag = lightingWorkerDagSpecs[techniqueName][job.key];
+  const dependencies = dag.dependencies.map(
+    (dependency) => `lighting.${techniqueName}.${dependency}`
+  );
+  return Object.freeze({
+    key: job.key,
+    label: job.label,
+    worker: Object.freeze({
+      jobType: job.label,
+      queueClass: lightingWorkerQueueClass,
+      priority: dag.priority,
+      dependencies: Object.freeze(dependencies),
+      schedulerMode: "dag"
+    }),
+    performance: Object.freeze({
+      id: job.label,
+      jobType: job.label,
+      queueClass: lightingWorkerQueueClass,
+      domain: spec.domain,
+      authority: "visual",
+      importance: spec.importance,
+      qualityDimensions: resolveLightingQualityDimensions(techniqueName, job.key),
+      importanceSignals: resolveLightingImportanceSignals(techniqueName, job.key),
+      levels: spec.levels
+    }),
+    debug: Object.freeze({
+      owner: lightingDebugOwner,
+      queueClass: lightingWorkerQueueClass,
+      jobType: job.label,
+      tags: Object.freeze([
+        "lighting",
+        techniqueName,
+        job.key,
+        spec.domain
+      ]),
+      suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds])
+    })
+  });
+}
+function buildLightingWorkerManifest(name, technique) {
+  const spec = lightingWorkerSpecPresets[name];
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: lightingDebugOwner,
+    technique: name,
+    description: technique.description,
+    queueClass: lightingWorkerQueueClass,
+    schedulerMode: "dag",
+    suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds]),
+    jobs: Object.freeze(
+      technique.jobs.map((job) => buildWorkerManifestJob(name, job))
+    )
+  });
+}
+var lightingWorkerManifests = Object.freeze(
+  Object.fromEntries(
+    Object.entries(lightingTechniques).map(([name, technique]) => [
+      name,
+      buildLightingWorkerManifest(name, technique)
+    ])
+  )
+);
+function getTechniqueJob(technique, key) {
+  const job = technique.jobs.find((entry) => entry.key === key);
+  if (!job) {
+    const available = technique.jobs.map((entry) => entry.key).join(", ");
+    throw new Error(
+      `Unknown job "${key}" for technique "${technique.name}". Available: ${available}.`
+    );
+  }
+  return job;
+}
+function getLightingTechnique(name = defaultLightingTechnique) {
+  const technique = lightingTechniques[name];
+  if (!technique) {
+    const available = lightingTechniqueNames.join(", ");
+    throw new Error(`Unknown lighting technique "${name}". Available: ${available}.`);
+  }
+  return technique;
+}
+function getLightingProfile(name = defaultLightingProfile) {
+  const profile = lightingProfiles[name];
+  if (!profile) {
+    const available = lightingProfileNames.join(", ");
+    throw new Error(`Unknown lighting profile "${name}". Available: ${available}.`);
+  }
+  return profile;
+}
+function getLightingTechniqueWorkerManifest(name = defaultLightingTechnique) {
+  const manifest = lightingWorkerManifests[name];
+  if (!manifest) {
+    const available = lightingTechniqueNames.join(", ");
+    throw new Error(
+      `Unknown lighting technique "${name}". Available: ${available}.`
+    );
+  }
+  return manifest;
+}
+function getLightingProfileWorkerManifest(name = defaultLightingProfile) {
+  const profile = getLightingProfile(name);
+  const techniques = profile.techniques.map(
+    (techniqueName) => getLightingTechniqueWorkerManifest(techniqueName)
+  );
+  const lightingBandPlan = createLightingBandPlan({ profile: profile.name });
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: lightingDebugOwner,
+    profile: profile.name,
+    description: profile.description,
+    schedulerMode: "dag",
+    techniques: Object.freeze(techniques),
+    lightingBands: lightingBandPlan.bands,
+    jobs: Object.freeze(techniques.flatMap((technique) => technique.jobs))
+  });
+}
+var defaultTechnique = getLightingTechnique(defaultLightingTechnique);
+var lightingPreludeWgslUrl = defaultTechnique.preludeUrl;
+var lightingJobLabels = Object.freeze(
+  Object.fromEntries(defaultTechnique.jobs.map((job) => [job.key, job.label]))
+);
+var lightingJobs = defaultTechnique.jobs.map((job) => ({
+  label: job.label,
+  url: job.url,
+  sourceName: job.sourceName
+}));
+function assertNotHtmlWgsl(source, context) {
+  const sample = source.slice(0, 200).toLowerCase();
+  if (sample.includes("<!doctype") || sample.includes("<html") || sample.includes("<meta")) {
+    const label = context ? ` for ${context}` : "";
+    throw new Error(
+      `Expected WGSL${label} but received HTML. Check the URL or server root.`
+    );
+  }
+}
+async function loadWgslSource(options = {}) {
+  const { wgsl, url, fetcher = globalThis.fetch, base } = options ?? {};
+  if (typeof wgsl === "string") {
+    assertNotHtmlWgsl(wgsl, "inline WGSL");
+    return wgsl;
+  }
+  if (!url) {
+    return null;
+  }
+  const resolved = url instanceof URL ? url : new URL(url, base ?? baseUrl);
+  if (!fetcher || resolved.protocol === "file:") {
+    const { readFile } = await import("fs/promises");
+    const { fileURLToPath } = await import("url");
+    const source2 = await readFile(fileURLToPath(resolved), "utf8");
+    assertNotHtmlWgsl(source2, resolved.href);
+    return source2;
+  }
+  const response = await fetcher(resolved);
+  if (!response.ok) {
+    const status = "status" in response ? response.status : "unknown";
+    const statusText = "statusText" in response ? response.statusText : "";
+    const detail = statusText ? `${status} ${statusText}` : `${status}`;
+    throw new Error(`Failed to load WGSL (${detail})`);
+  }
+  const source = await response.text();
+  assertNotHtmlWgsl(source, resolved.href);
+  return source;
+}
+async function loadTechniquePrelude(technique, fetcher) {
+  const source = await loadWgslSource({ url: technique.preludeUrl, fetcher });
+  if (typeof source !== "string") {
+    throw new Error(`Failed to load ${technique.name} prelude WGSL source.`);
+  }
+  return source;
+}
+async function loadTechniqueJob(technique, job, fetcher) {
+  const source = await loadWgslSource({ url: job.url, fetcher });
+  if (typeof source !== "string") {
+    throw new Error(
+      `Failed to load ${technique.name} job "${job.key}" WGSL source.`
+    );
+  }
+  return source;
+}
+async function loadLightingTechniquePreludeWgsl(techniqueName, options = {}) {
+  const { fetcher } = options ?? {};
+  const technique = getLightingTechnique(techniqueName);
+  return loadTechniquePrelude(technique, fetcher);
+}
+async function loadLightingTechniqueJobWgsl(techniqueName, jobKey, options = {}) {
+  const { fetcher } = options ?? {};
+  const technique = getLightingTechnique(techniqueName);
+  const job = getTechniqueJob(technique, jobKey);
+  return loadTechniqueJob(technique, job, fetcher);
+}
+async function loadLightingTechniqueJobs(techniqueName, options = {}) {
+  const { fetcher } = options ?? {};
+  const technique = getLightingTechnique(techniqueName);
+  const preludeWgsl = await loadTechniquePrelude(technique, fetcher);
+  const jobSources = await Promise.all(
+    technique.jobs.map((job) => loadTechniqueJob(technique, job, fetcher))
+  );
+  const jobs = technique.jobs.map((job, index) => ({
+    wgsl: jobSources[index],
+    label: job.label,
+    sourceName: job.sourceName
+  }));
+  return { preludeWgsl, jobs };
+}
+async function loadLightingTechniqueWorkerBundle(techniqueName = defaultLightingTechnique, options = {}) {
+  const technique = getLightingTechnique(techniqueName);
+  const { preludeWgsl, jobs } = await loadLightingTechniqueJobs(
+    technique.name,
+    options
+  );
+  return {
+    technique: technique.name,
+    preludeWgsl,
+    jobs,
+    workerManifest: getLightingTechniqueWorkerManifest(technique.name)
+  };
+}
+async function loadLightingPreludeWgsl(options = {}) {
+  const { fetcher } = options ?? {};
+  return loadTechniquePrelude(defaultTechnique, fetcher);
+}
+async function loadLightingJobs(options = {}) {
+  return loadLightingTechniqueJobs(defaultLightingTechnique, options);
+}
+async function loadLightingProfile(profileName, options = {}) {
+  const profile = getLightingProfile(profileName);
+  const techniques = await Promise.all(
+    profile.techniques.map(async (techniqueName) => {
+      const { preludeWgsl, jobs } = await loadLightingTechniqueJobs(
+        techniqueName,
+        options
+      );
+      return {
+        technique: techniqueName,
+        preludeWgsl,
+        jobs
+      };
+    })
+  );
+  return { profile, techniques };
+}
+async function loadLightingProfileWorkerPlan(profileName = defaultLightingProfile, options = {}) {
+  const profile = getLightingProfile(profileName);
+  const techniques = await Promise.all(
+    profile.techniques.map(
+      (techniqueName) => loadLightingTechniqueWorkerBundle(techniqueName, options)
+    )
+  );
+  return {
+    profile,
+    techniques,
+    lightingBandPlan: createLightingBandPlan({ profile: profile.name }),
+    workerManifest: getLightingProfileWorkerManifest(profile.name)
+  };
+}
+export {
+  createEnvironmentLightingConfig,
+  createLightingBandPlan,
+  createLightingProfileModeLadder,
+  createWavefrontEnvironmentLightingOptions,
+  defaultAdaptiveLightingProfilePolicy,
+  defaultLightingProfile,
+  defaultLightingTechnique,
+  getLightingProfile,
+  getLightingProfileWorkerManifest,
+  getLightingTechnique,
+  getLightingTechniqueWorkerManifest,
+  lightingDebugOwner,
+  lightingDistanceBands,
+  lightingEnvironmentPresetNames,
+  lightingJobLabels,
+  lightingJobs,
+  lightingPreludeWgslUrl,
+  lightingProfileModeOrder,
+  lightingProfileNames,
+  lightingProfiles,
+  lightingTechniqueNames,
+  lightingTechniques,
+  lightingWorkerManifests,
+  lightingWorkerQueueClass,
+  loadLightingJobs,
+  loadLightingPreludeWgsl,
+  loadLightingProfile,
+  loadLightingProfileWorkerPlan,
+  loadLightingTechniqueJobWgsl,
+  loadLightingTechniqueJobs,
+  loadLightingTechniquePreludeWgsl,
+  loadLightingTechniqueWorkerBundle
+};
+//# sourceMappingURL=dist-B5R2GZQR.js.map