@plasius/gpu-shared 0.1.14 → 0.1.15

package/dist/index.cjs

@@ -29,6 +29,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/feature-flags.js
+var GPU_SHOWCASE_REALISTIC_MODELS_FEATURE, GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE;
+var init_feature_flags = __esm({
+  "src/feature-flags.js"() {
+    GPU_SHOWCASE_REALISTIC_MODELS_FEATURE = "gpu_showcase_realistic_models_v1";
+    GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE = "gpu_showcase_product_studio_wavefront_v1";
+  }
+});
+
 // src/showcase-inline-assets.js
 var showcase_inline_assets_exports = {};
 __export(showcase_inline_assets_exports, {
@@ -231,15 +240,6 @@ var init_i18n = __esm({
   }
 });
 
-// src/feature-flags.js
-var GPU_SHOWCASE_REALISTIC_MODELS_FEATURE, GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE;
-var init_feature_flags = __esm({
-  "src/feature-flags.js"() {
-    GPU_SHOWCASE_REALISTIC_MODELS_FEATURE = "gpu_showcase_realistic_models_v1";
-    GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE = "gpu_showcase_product_studio_wavefront_v1";
-  }
-});
-
 // src/gltf-loader.js
 var gltf_loader_exports = {};
 __export(gltf_loader_exports, {
@@ -367,6 +367,11 @@ function appendValues(target, values) {
     target.push(values[index]);
   }
 }
+function appendIndicesWithOffset(target, values, vertexOffset) {
+  for (let index = 0; index < values.length; index += 1) {
+    target.push(values[index] + vertexOffset);
+  }
+}
 function resolveBrowserRequestBaseUrl() {
   if (typeof document !== "undefined" && typeof document.baseURI === "string" && document.baseURI.length > 0) {
     return document.baseURI;
@@ -556,7 +561,7 @@ async function loadInlineShowcaseDocument() {
   const module2 = await Promise.resolve().then(() => (init_showcase_inline_assets(), showcase_inline_assets_exports));
   return loadGltfDocument(new URL(module2.INLINE_SHOWCASE_ASSET_URLS.brigantine));
 }
-async function buildGltfModel(document2, baseUrl) {
+async function buildGltfModel(document2, baseUrl2) {
   const buffers = await Promise.all(
     (document2.buffers ?? []).map(async (buffer) => {
       if (typeof buffer.uri !== "string") {
@@ -565,7 +570,7 @@ async function buildGltfModel(document2, baseUrl) {
       if (buffer.uri.startsWith("data:")) {
         return decodeDataUri(buffer.uri);
       }
-      const nested = await fetch(new URL(buffer.uri, baseUrl));
+      const nested = await fetch(new URL(buffer.uri, baseUrl2));
       if (!nested.ok) {
         throw new Error(`Failed to load glTF buffer: ${nested.status} ${nested.statusText}`);
       }
@@ -578,9 +583,7 @@ async function buildGltfModel(document2, baseUrl) {
   for (const primitive of scene.primitives) {
     const vertexOffset = aggregatePositions.length / 3;
     appendValues(aggregatePositions, primitive.positions);
-    for (const index of primitive.indices) {
-      aggregateIndices.push(index + vertexOffset);
-    }
+    appendIndicesWithOffset(aggregateIndices, primitive.indices, vertexOffset);
   }
   const color = scene.primitives[0]?.material?.color ?? { r: 0.56, g: 0.33, b: 0.22, a: 1 };
   return Object.freeze({
@@ -601,14 +604,14 @@ function shouldRetryWithInlineShowcaseFallback(url, error) {
 }
 async function loadGltfModel(url) {
   try {
-    const { document: document2, baseUrl } = await loadGltfDocument(url);
-    return buildGltfModel(document2, baseUrl);
+    const { document: document2, baseUrl: baseUrl2 } = await loadGltfDocument(url);
+    return buildGltfModel(document2, baseUrl2);
   } catch (error) {
     if (!shouldRetryWithInlineShowcaseFallback(url, error)) {
       throw error;
     }
-    const { document: document2, baseUrl } = await loadInlineShowcaseDocument();
-    return buildGltfModel(document2, baseUrl);
+    const { document: document2, baseUrl: baseUrl2 } = await loadInlineShowcaseDocument();
+    return buildGltfModel(document2, baseUrl2);
   }
 }
 var init_gltf_loader = __esm({
@@ -617,6 +620,1442 @@ var init_gltf_loader = __esm({
   }
 });
 
+// node_modules/@plasius/gpu-lighting/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  createEnvironmentLightingConfig: () => createEnvironmentLightingConfig,
+  createLightingBandPlan: () => createLightingBandPlan,
+  createLightingProfileModeLadder: () => createLightingProfileModeLadder,
+  createWavefrontEnvironmentLightingOptions: () => createWavefrontEnvironmentLightingOptions,
+  defaultAdaptiveLightingProfilePolicy: () => defaultAdaptiveLightingProfilePolicy,
+  defaultLightingProfile: () => defaultLightingProfile,
+  defaultLightingTechnique: () => defaultLightingTechnique,
+  getLightingProfile: () => getLightingProfile,
+  getLightingProfileWorkerManifest: () => getLightingProfileWorkerManifest,
+  getLightingTechnique: () => getLightingTechnique,
+  getLightingTechniqueWorkerManifest: () => getLightingTechniqueWorkerManifest,
+  lightingDebugOwner: () => lightingDebugOwner,
+  lightingDistanceBands: () => lightingDistanceBands,
+  lightingEnvironmentPresetNames: () => lightingEnvironmentPresetNames,
+  lightingJobLabels: () => lightingJobLabels,
+  lightingJobs: () => lightingJobs,
+  lightingPreludeWgslUrl: () => lightingPreludeWgslUrl,
+  lightingProfileModeOrder: () => lightingProfileModeOrder,
+  lightingProfileNames: () => lightingProfileNames,
+  lightingProfiles: () => lightingProfiles,
+  lightingTechniqueNames: () => lightingTechniqueNames,
+  lightingTechniques: () => lightingTechniques,
+  lightingWorkerManifests: () => lightingWorkerManifests,
+  lightingWorkerQueueClass: () => lightingWorkerQueueClass,
+  loadLightingJobs: () => loadLightingJobs,
+  loadLightingPreludeWgsl: () => loadLightingPreludeWgsl,
+  loadLightingProfile: () => loadLightingProfile,
+  loadLightingProfileWorkerPlan: () => loadLightingProfileWorkerPlan,
+  loadLightingTechniqueJobWgsl: () => loadLightingTechniqueJobWgsl,
+  loadLightingTechniqueJobs: () => loadLightingTechniqueJobs,
+  loadLightingTechniquePreludeWgsl: () => loadLightingTechniquePreludeWgsl,
+  loadLightingTechniqueWorkerBundle: () => loadLightingTechniqueWorkerBundle
+});
+function createModuleBaseUrl(metaUrl) {
+  return Reflect.construct(URL, [String(metaUrl)]);
+}
+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
+  };
+}
+function buildProfile(name, spec) {
+  return {
+    name,
+    description: spec.description,
+    techniques: [...spec.techniques]
+  };
+}
+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;
+}
+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
+  });
+}
+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
+  });
+}
+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"
+        })
+      })
+    })
+  ]);
+}
+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))
+    )
+  });
+}
+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))
+  });
+}
+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)
+  };
+}
+var import_meta2, __require, baseUrl, techniqueSpecs, lightingTechniques, lightingTechniqueNames, defaultLightingTechnique, profileSpecs, lightingProfiles, lightingProfileNames, defaultLightingProfile, lightingProfileModeOrder, lightingEnvironmentPresetNames, defaultAdaptiveLightingProfilePolicy, lightingDistanceBands, lightingWorkerQueueClass, lightingDebugOwner, environmentLightingPresets, lightingImportanceLevels, lightingBandPolicySpecs, lightingProfileModeEstimatedCostMs, lightingWorkerSpecPresets, lightingWorkerDagSpecs, lightingWorkerManifests, defaultTechnique, lightingPreludeWgslUrl, lightingJobLabels, lightingJobs;
+var init_dist = __esm({
+  "node_modules/@plasius/gpu-lighting/dist/index.js"() {
+    import_meta2 = {};
+    __require = /* @__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');
+    });
+    baseUrl = (() => {
+      if (typeof import_meta2.url !== "undefined") {
+        return createModuleBaseUrl(import_meta2.url);
+      }
+      if (typeof __filename !== "undefined" && typeof __require !== "undefined") {
+        const { pathToFileURL } = __require("url");
+        return pathToFileURL(__filename);
+      }
+      const base = typeof process !== "undefined" && process.cwd ? `file://${process.cwd()}/` : "file:///";
+      return new URL("./index.js", base);
+    })();
+    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"
+        }
+      }
+    };
+    lightingTechniques = Object.freeze(
+      Object.fromEntries(
+        Object.entries(techniqueSpecs).map(([name, spec]) => [
+          name,
+          buildTechnique(name, spec)
+        ])
+      )
+    );
+    lightingTechniqueNames = Object.freeze(Object.keys(lightingTechniques));
+    defaultLightingTechnique = "hybrid";
+    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"]
+      }
+    };
+    lightingProfiles = Object.freeze(
+      Object.fromEntries(
+        Object.entries(profileSpecs).map(([name, spec]) => [
+          name,
+          buildProfile(name, spec)
+        ])
+      )
+    );
+    lightingProfileNames = Object.freeze(Object.keys(lightingProfiles));
+    defaultLightingProfile = "realtime";
+    lightingProfileModeOrder = Object.freeze([
+      "realtime",
+      "hybrid",
+      "reference"
+    ]);
+    lightingEnvironmentPresetNames = Object.freeze([
+      "moonlit-harbor",
+      "product-studio",
+      "neutral-studio"
+    ]);
+    defaultAdaptiveLightingProfilePolicy = Object.freeze({
+      preferredProfile: "reference",
+      minimumFrameRate: 30,
+      sampleWindowSize: 4
+    });
+    lightingDistanceBands = Object.freeze([
+      "near",
+      "mid",
+      "far",
+      "horizon"
+    ]);
+    lightingWorkerQueueClass = "lighting";
+    lightingDebugOwner = "lighting";
+    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])
+      })
+    });
+    lightingImportanceLevels = Object.freeze([
+      "low",
+      "medium",
+      "high",
+      "critical"
+    ]);
+    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
+      })
+    });
+    lightingProfileModeEstimatedCostMs = Object.freeze({
+      realtime: 4.5,
+      hybrid: 7.5,
+      reference: 12.5
+    });
+    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"]
+          }
+        }
+      }
+    };
+    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"]
+        }
+      }
+    };
+    lightingWorkerManifests = Object.freeze(
+      Object.fromEntries(
+        Object.entries(lightingTechniques).map(([name, technique]) => [
+          name,
+          buildLightingWorkerManifest(name, technique)
+        ])
+      )
+    );
+    defaultTechnique = getLightingTechnique(defaultLightingTechnique);
+    lightingPreludeWgslUrl = defaultTechnique.preludeUrl;
+    lightingJobLabels = Object.freeze(
+      Object.fromEntries(defaultTechnique.jobs.map((job) => [job.key, job.label]))
+    );
+    lightingJobs = defaultTechnique.jobs.map((job) => ({
+      label: job.label,
+      url: job.url,
+      sourceName: job.sourceName
+    }));
+  }
+});
+
 // src/product-studio-runtime.js
 var product_studio_runtime_exports = {};
 __export(product_studio_runtime_exports, {
@@ -931,7 +2370,7 @@ async function resolveWavefrontLightingOptions(options) {
     environmentColor: [0.35, 0.43, 0.49, 1],
     ambientColor: [0.02, 0.024, 0.028, 1]
   };
-  const lightingLoader = typeof options.__lightingLoader === "function" ? options.__lightingLoader : () => import("@plasius/gpu-lighting").catch(() => null);
+  const lightingLoader = typeof options.__lightingLoader === "function" ? options.__lightingLoader : () => Promise.resolve().then(() => (init_dist(), dist_exports)).catch(() => null);
   const lightingModule = await lightingLoader();
   if (typeof lightingModule?.createWavefrontEnvironmentLightingOptions !== "function") {
     return fallback;
@@ -999,6 +2438,7 @@ async function mountGpuProductStudio(options = {}, featureFlags = null) {
   return Object.freeze({
     state,
     model,
+    productModel: model,
     canvas,
     renderer,
     meshes,
@@ -4824,10 +6264,10 @@ __export(index_exports, {
   translateGpuSharedText: () => translateGpuSharedText
 });
 module.exports = __toCommonJS(index_exports);
+init_feature_flags();
 init_asset_url();
 init_i18n();
 init_en_GB();
-init_feature_flags();
 init_product_studio_runtime();
 var showcaseFocusModes2 = Object.freeze([
   "integrated",
@@ -4843,9 +6283,32 @@ async function loadGltfModel2(url) {
   const module2 = await Promise.resolve().then(() => (init_gltf_loader(), gltf_loader_exports));
   return module2.loadGltfModel(url);
 }
+function isProductStudioFeatureEnabled(featureFlags) {
+  if (typeof featureFlags?.get === "function") {
+    return featureFlags.get(GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE) === true;
+  }
+  const direct = featureFlags?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof direct === "boolean") {
+    return direct;
+  }
+  const flagsValue = featureFlags?.flags?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof flagsValue === "boolean") {
+    return flagsValue;
+  }
+  const enabledValue = featureFlags?.enabled?.[GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE];
+  if (typeof enabledValue === "boolean") {
+    return enabledValue;
+  }
+  return false;
+}
 async function mountGpuShowcase2(options = {}) {
   const demoMode = options.demoMode ?? options.mode;
   if (demoMode === "product-studio" || demoMode === "product" || demoMode === "studio" || demoMode === "eames") {
+    if (!isProductStudioFeatureEnabled(options.__featureFlags)) {
+      throw new Error(
+        `${GPU_SHOWCASE_PRODUCT_STUDIO_FEATURE} must be enabled before Product Studio can mount.`
+      );
+    }
     const productRuntimeLoader = typeof options.__productRuntimeLoader === "function" ? options.__productRuntimeLoader : () => Promise.resolve().then(() => (init_product_studio_runtime(), product_studio_runtime_exports));
     const productModule = await productRuntimeLoader();
     if (typeof productModule.mountGpuProductStudio !== "function") {