@forgeax/engine-render 0.1.33 → 0.1.35

package/dist/chunk-3RTCJTH4.mjs

@@ -1,1610 +0,0 @@
-import { LifecycleConstructionError, GpuDrivenPreparationError, RenderTargetDescriptorInvalidError } from './chunk-NB2S7ZRX.mjs';
-import { ok, err, derive } from '@forgeax/engine-types';
-import '@forgeax/engine-rhi';
-import { vec3 } from '@forgeax/engine-math';
-import { STANDARD_PIPELINE_PARAM_SCHEMA, standardPhysicalTextureFields, STANDARD_PHYSICAL_TEXTURE_FIELDS } from '@forgeax/engine-shader';
-import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
-
-var DeviceResourceRef = class {
-  kind;
-  owner;
-  generation;
-  value;
-  constructor(kind, owner, generation, value) {
-    this.kind = kind;
-    this.owner = owner;
-    this.generation = generation;
-    this.value = value;
-  }
-  isCurrent(scope) {
-    return scope.accepts(this);
-  }
-  isStale(scope) {
-    return !this.isCurrent(scope);
-  }
-};
-function idempotentCleanup(cleanup) {
-  let cleaned = false;
-  return (value) => {
-    if (cleaned) return;
-    cleaned = true;
-    return cleanup(value);
-  };
-}
-var DeviceScope = class _DeviceScope {
-  generation;
-  owner;
-  parent;
-  lifecycleState = "active";
-  resources = /* @__PURE__ */ new Map();
-  children = [];
-  constructor(generation, owner, parent) {
-    this.generation = generation;
-    this.owner = owner;
-    this.parent = parent;
-    parent?.children.push(this);
-  }
-  static create(generation, owner) {
-    if (!Number.isSafeInteger(generation) || generation < 0) {
-      throw new RangeError("DeviceScope generation must be a non-negative safe integer.");
-    }
-    if (owner.length === 0) throw new TypeError("DeviceScope owner must not be empty.");
-    return new _DeviceScope(generation, owner);
-  }
-  get state() {
-    return this.lifecycleState;
-  }
-  get childrenSnapshot() {
-    return [...this.children];
-  }
-  /** Create a renderer-owned child scope without exposing a second device owner. */
-  createChild(owner) {
-    if (this.lifecycleState !== "active") {
-      throw new Error("Cannot create a child DeviceScope from an inactive scope.");
-    }
-    if (owner.length === 0) throw new TypeError("DeviceScope child owner must not be empty.");
-    return new _DeviceScope(this.generation, owner, this);
-  }
-  ref(kind, value) {
-    const ref = new DeviceResourceRef(kind, this.owner, this.generation, value);
-    this.resources.set(ref, { ref, cleanup: () => void 0 });
-    return ref;
-  }
-  accepts(ref) {
-    return this.lifecycleState === "active" && ref.owner === this.owner && ref.generation === this.generation;
-  }
-  isAlive() {
-    return this.lifecycleState === "active";
-  }
-  resourceDelta() {
-    return this.resources.size;
-  }
-  /** @internal */
-  _adopt(kind, value, cleanup) {
-    const ref = new DeviceResourceRef(kind, this.owner, this.generation, value);
-    this.resources.set(ref, {
-      ref,
-      cleanup: idempotentCleanup(cleanup)
-    });
-    return ref;
-  }
-  /** @internal Remove ownership only after the resource's cleanup succeeded. */
-  _release(ref) {
-    this.resources.delete(ref);
-  }
-  /** @internal */
-  _clearResources() {
-    const resources = [...this.resources.values()];
-    this.resources.clear();
-    for (const resource of resources.reverse()) {
-      try {
-        const pending = resource.cleanup(resource.ref.value);
-        if (pending instanceof Promise) void pending.catch(() => void 0);
-      } catch {
-      }
-    }
-    return resources;
-  }
-  /** Mark an active child as retiring without releasing in-flight resources. */
-  beginRetire() {
-    if (this.lifecycleState === "active") this.lifecycleState = "retiring";
-  }
-  clearChildren() {
-    for (const child of [...this.children].reverse()) {
-      child.retire();
-    }
-  }
-  detachChild(child) {
-    const index = this.children.indexOf(child);
-    if (index >= 0) this.children.splice(index, 1);
-  }
-  retire() {
-    if (this.lifecycleState !== "active" && this.lifecycleState !== "retiring") return;
-    this.lifecycleState = "retiring";
-    this.clearChildren();
-    this._clearResources();
-    this.lifecycleState = "retired";
-  }
-  abandon() {
-    if (this.lifecycleState !== "active") return;
-    this.lifecycleState = "abandoned";
-    this.clearChildren();
-    this._clearResources();
-  }
-  dispose() {
-    if (this.lifecycleState === "disposed") return;
-    this.lifecycleState = "disposed";
-    this.clearChildren();
-    this._clearResources();
-  }
-  async replace(generation, resources) {
-    const replacement = new _DeviceScope(generation, this.owner, this);
-    const transaction = new LifecycleTransaction(replacement);
-    for (const resource of resources) transaction.add(resource);
-    const result = await transaction.commit();
-    if (!result.ok) {
-      replacement.abandon();
-      return result;
-    }
-    if (!this.isAlive()) {
-      replacement.dispose();
-      return transaction.failure("dispose");
-    }
-    this.detachChild(replacement);
-    this.retire();
-    return ok(replacement);
-  }
-  /** @internal */
-  _receipt() {
-    return {
-      owner: this.owner,
-      generation: this.generation,
-      resourceCount: this.resources.size
-    };
-  }
-};
-var LifecycleTransaction = class {
-  constructor(scope, options = {}) {
-    this.scope = scope;
-    this.options = options;
-  }
-  scope;
-  resources = [];
-  options;
-  committed = false;
-  add(spec) {
-    if (this.committed) throw new Error("LifecycleTransaction is already committed.");
-    this.resources.push(spec);
-    return this;
-  }
-  async commit() {
-    if (this.committed) return this.failure("create");
-    this.committed = true;
-    const created = [];
-    for (let index = 0; index < this.resources.length; index += 1) {
-      const spec = this.resources[index];
-      if (spec === void 0) continue;
-      try {
-        if (this.options.failureAt === index + 1) {
-          throw new Error(`injected lifecycle failure at ${index + 1}`);
-        }
-        const value = await spec.create();
-        if (!this.scope.isAlive()) {
-          await this.cleanupOne(value, created, idempotentCleanup(spec.cleanup));
-          return this.failure("dispose");
-        }
-        created.push({ spec, value, cleanup: idempotentCleanup(spec.cleanup) });
-      } catch (cause) {
-        const cleanupFailures = await this.cleanupCreated(created);
-        return this.failure("create", spec.kind, cleanupFailures, cause);
-      }
-    }
-    if (!this.scope.isAlive()) {
-      const cleanupFailures = await this.cleanupCreated(created);
-      return this.failure("dispose", this.resources.at(-1)?.kind ?? "listener", cleanupFailures);
-    }
-    for (const item of created) this.scope._adopt(item.spec.kind, item.value, item.spec.cleanup);
-    return ok(this.scope);
-  }
-  failure(operation, resourceKind = this.resources.at(-1)?.kind ?? "listener", cleanupFailures = [], cause = void 0) {
-    return err({
-      primary: new LifecycleConstructionError({
-        owner: this.scope.owner,
-        generation: this.scope.generation,
-        operation,
-        resourceKind,
-        cause,
-        cleanupFailures,
-        receipt: this.scope._receipt()
-      }),
-      cleanupFailures,
-      receipt: this.scope._receipt()
-    });
-  }
-  async cleanupCreated(created) {
-    const failures = [];
-    for (let index = created.length - 1; index >= 0; index -= 1) {
-      const item = created[index];
-      if (item === void 0) continue;
-      try {
-        await item.cleanup(item.value);
-      } catch (cause) {
-        failures.push({ resourceKind: item.spec.kind, cause });
-      }
-    }
-    return failures;
-  }
-  async cleanupOne(value, created, cleanup) {
-    await this.cleanupCreated(created);
-    try {
-      await cleanup(value);
-    } catch {
-    }
-  }
-};
-
-// src/gpu-usage.ts
-var GPU_BUFFER_USAGE_VERTEX = 32;
-var GPU_BUFFER_USAGE_INDEX = 16;
-var GPU_BUFFER_USAGE_COPY_DST = 8;
-var GPU_BUFFER_USAGE_COPY_SRC = 4;
-var GPU_BUFFER_USAGE_UNIFORM = 64;
-var GPU_BUFFER_USAGE_STORAGE = 128;
-var GPU_BUFFER_USAGE_INDIRECT = 256;
-var GPU_BUFFER_USAGE_MAP_READ = 1;
-var GPU_BUFFER_USAGE_QUERY_RESOLVE = 512;
-
-// src/prepare/extended-lighting/resources.ts
-var EXTENDED_LIGHTING_TOPOLOGY = "extendedLighting";
-var IES_SLICE_CAPACITY = 32;
-var COOKIE_SLICE_CAPACITY = 32;
-var IES_SLICE_WIDTH = 256;
-var IES_SLICE_HEIGHT = 128;
-var COOKIE_SLICE_SIZE = 256;
-var COOKIE_MATRIX_BYTES = 32 * 16 * Float32Array.BYTES_PER_ELEMENT;
-var EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES = 21;
-function extendedLightingSampledTextureCapacityAvailable(maxSampledTexturesPerShaderStage) {
-  return maxSampledTexturesPerShaderStage !== void 0 && maxSampledTexturesPerShaderStage >= EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES;
-}
-function deriveExtendedLightingCapability(device) {
-  const maxSampledTextures = device.limits.maxSampledTexturesPerShaderStage;
-  if (!extendedLightingSampledTextureCapacityAvailable(maxSampledTextures)) {
-    return {
-      admitted: false,
-      topology: EXTENDED_LIGHTING_TOPOLOGY,
-      reason: `maxSampledTexturesPerShaderStage ${maxSampledTextures ?? 0} < ${EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES}`
-    };
-  }
-  const maxLayers = device.limits.maxTextureArrayLayers ?? 0;
-  const maxUniformBuffers = device.limits.maxUniformBuffersPerShaderStage ?? 0;
-  if (maxLayers < IES_SLICE_CAPACITY) {
-    return {
-      admitted: false,
-      topology: EXTENDED_LIGHTING_TOPOLOGY,
-      reason: `maxTextureArrayLayers ${maxLayers} < ${IES_SLICE_CAPACITY}`
-    };
-  }
-  if (maxUniformBuffers < 1) {
-    return {
-      admitted: false,
-      topology: EXTENDED_LIGHTING_TOPOLOGY,
-      reason: `maxUniformBuffersPerShaderStage ${maxUniformBuffers} < 1`
-    };
-  }
-  if (!device.caps.storageBuffer || !device.caps.rgba16floatRenderable || !device.caps.samplerAliasing) {
-    return {
-      admitted: false,
-      topology: EXTENDED_LIGHTING_TOPOLOGY,
-      reason: "required storage-buffer, rgba16float, or sampler capability is unavailable"
-    };
-  }
-  return { admitted: true, topology: EXTENDED_LIGHTING_TOPOLOGY, reason: void 0 };
-}
-function worldEntityKey(worldId, entityKey) {
-  return worldId * 4294967296 + entityKey;
-}
-function instanceCollectionCacheKey(worldId, instance) {
-  return -(4294967296 + worldEntityKey(worldId, instance.collectionId ?? instance.cacheKey));
-}
-var ZERO_CAMERA_CLEAR_FALLBACK = [0, 0, 0, 1];
-var textureIdentities = /* @__PURE__ */ new WeakMap();
-var nextTextureIdentity = 1;
-var opaqueResourceIdentities = /* @__PURE__ */ new WeakMap();
-var nextOpaqueResourceIdentity = 1;
-function getOpaqueResourceIdentity(resource) {
-  const existing = opaqueResourceIdentities.get(resource);
-  if (existing !== void 0) return existing;
-  const identity = nextOpaqueResourceIdentity++;
-  opaqueResourceIdentities.set(resource, identity);
-  return identity;
-}
-function getTextureIdentity(texture) {
-  const object = texture;
-  const existing = textureIdentities.get(object);
-  if (existing !== void 0) return existing;
-  const identity = nextTextureIdentity++;
-  textureIdentities.set(object, identity);
-  return identity;
-}
-function validateGraphTargetCaptureReadback(input) {
-  const { bytes, expectedByteLength, sentinel, allowZero = false } = input;
-  if (bytes.byteLength !== expectedByteLength)
-    return { ok: false, code: "capture-readback-length" };
-  if (sentinel?.every((value, index2) => bytes[index2] === value)) {
-    return { ok: false, code: "capture-readback-untouched-sentinel" };
-  }
-  if (!allowZero && bytes.every((value) => value === 0)) {
-    return { ok: false, code: "capture-readback-empty" };
-  }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let index = 0;
-  for (; index + 3 < bytes.byteLength; index += 4) {
-    const word = view.getUint32(index, true);
-    if ((word & 31744) === 31744 || (word & 2080374784) === 2080374784)
-      return { ok: false, code: "capture-readback-non-finite" };
-  }
-  if (index + 1 < bytes.byteLength && (view.getUint16(index, true) & 31744) === 31744)
-    return { ok: false, code: "capture-readback-non-finite" };
-  return { ok: true };
-}
-function makeZeroCameraFallbackSnapshot() {
-  const identityWorld = new Float32Array(16);
-  identityWorld[0] = 1;
-  identityWorld[5] = 1;
-  identityWorld[10] = 1;
-  identityWorld[15] = 1;
-  return {
-    position: vec3.create(0, 0, 0),
-    world: identityWorld,
-    fov: Math.PI / 4,
-    aspect: 1,
-    near: 0.1,
-    far: 100,
-    // feat-20260613 M6 / w20: synthetic camera defaults to perspective so
-    // the CSM extract path stays consistent with the previously-implicit
-    // perspective shape (unchanged behavior; explicit field).
-    projection: "perspective",
-    orthoLeft: -1,
-    orthoRight: 1,
-    orthoBottom: -1,
-    orthoTop: 1,
-    tonemap: "none",
-    exposure: 1,
-    whitePoint: 4,
-    antialias: "none",
-    bloom: "off",
-    bloomThreshold: 1,
-    bloomIntensity: 1,
-    bloomSoftKnee: 0.5,
-    bloomScatter: 0.7,
-    clearColor: ZERO_CAMERA_CLEAR_FALLBACK
-  };
-}
-
-// src/temporal/coverage.ts
-function createTemporalCoverage(width, height) {
-  if (!Number.isSafeInteger(width) || width <= 0) throw new RangeError("width must be positive.");
-  if (!Number.isSafeInteger(height) || height <= 0)
-    throw new RangeError("height must be positive.");
-  return Object.freeze({ width, height, bytes: 34 * width * height, fullScreen: true });
-}
-function classifySceneDataCoverage(input) {
-  const exactContributorIds = input.contributors.filter((c) => c.kind === "exact").map((c) => c.id);
-  const reactiveContributorIds = input.contributors.filter((c) => c.kind === "reactive").map((c) => c.id);
-  const available = new Set(input.contributors.map((c) => c.id));
-  const missing = input.requiredContributorIds.filter((id) => !available.has(id));
-  return {
-    exactContributorIds: Object.freeze(exactContributorIds),
-    reactiveContributorIds: Object.freeze(reactiveContributorIds),
-    missingContributorIds: Object.freeze(missing.slice(0, 32)),
-    omittedMissingContributorCount: Math.max(0, missing.length - 32),
-    complete: missing.length === 0
-  };
-}
-function scanSceneDataCoverage(input) {
-  const classification = classifySceneDataCoverage({
-    contributors: input.contributorIds.map((id) => ({ id, kind: "exact" })),
-    requiredContributorIds: input.requiredContributorIds
-  });
-  return Object.freeze({
-    schema: input.schema,
-    lane: input.lane,
-    producerId: input.producerId,
-    ...classification,
-    contributorIds: Object.freeze([...input.contributorIds])
-  });
-}
-
-// src/gpu-stage.ts
-var GPU_SHADER_STAGE_VERTEX = 1;
-var GPU_SHADER_STAGE_FRAGMENT = 2;
-var GPU_SHADER_STAGE_COMPUTE = 4;
-var BGL_ONLY_SPEC_STUB = Object.freeze({
-  shader: { id: "", passKind: "forward", variantSet: void 0 },
-  attachments: { colorFormats: [], depthFormat: void 0, sampleCount: 1 },
-  geometry: { topology: "triangle-list", vertexLayout: {} },
-  renderState: void 0
-});
-function buildPbrMaterialUserRegionEntries(paramSchema = STANDARD_PIPELINE_PARAM_SCHEMA, excludedTextureFields = []) {
-  const excluded = new Set(excludedTextureFields);
-  for (const field of standardPhysicalTextureFields(paramSchema)) excluded.add(field);
-  const derived = derive(
-    excluded.size === 0 ? paramSchema : paramSchema.filter(
-      (entry) => !excluded.has(entry.name) || !entry.type.startsWith("texture")
-    )
-  );
-  let entries = derived.bglEntries.map(
-    (entry) => ({
-      binding: entry.binding,
-      visibility: entry.visibility,
-      ...entry.buffer === void 0 ? {} : { buffer: entry.buffer },
-      ...entry.sampler === void 0 ? {} : { sampler: entry.sampler },
-      ...entry.texture === void 0 ? {} : { texture: entry.texture },
-      ...entry.storageTexture === void 0 ? {} : { storageTexture: entry.storageTexture }
-    })
-  );
-  const ubo = entries[0];
-  if (ubo !== void 0 && ubo.binding === 0 && ubo.buffer?.type === "uniform") {
-    entries[0] = {
-      binding: 0,
-      visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-      buffer: { type: "uniform", hasDynamicOffset: true }
-    };
-  } else {
-    entries = [
-      {
-        binding: 0,
-        visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: "uniform", hasDynamicOffset: true }
-      },
-      ...entries.map((entry) => ({ ...entry, binding: entry.binding + 1 }))
-    ];
-  }
-  return entries;
-}
-function appendInjection(bgl, kind) {
-  const start = bgl.length;
-  switch (kind) {
-    case "ibl":
-      return [
-        // binding start+0: irradianceMap (texture_cube)
-        {
-          binding: start,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "cube" }
-        },
-        // binding start+1: irradianceSampler
-        {
-          binding: start + 1,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        // binding start+2: prefilterMap (texture_cube)
-        {
-          binding: start + 2,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "cube" }
-        },
-        // binding start+3: prefilterSampler
-        {
-          binding: start + 3,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        // binding start+4: brdfLut (texture_2d)
-        {
-          binding: start + 4,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "2d" }
-        },
-        // binding start+5: brdfLutSampler
-        {
-          binding: start + 5,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        // binding start+6: uniform { intensity: f32 }
-        {
-          binding: start + 6,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          buffer: { type: "uniform" }
-        }
-      ];
-    case "lightmap":
-      return [
-        // emissive sampler + texture pair
-        {
-          binding: start,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        {
-          binding: start + 1,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "2d" }
-        },
-        // occlusion sampler + texture pair
-        {
-          binding: start + 2,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        {
-          binding: start + 3,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "2d" }
-        }
-      ];
-    case "shadow":
-      return [
-        {
-          binding: start,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "comparison" }
-        },
-        {
-          binding: start + 1,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "depth", viewDimension: "2d" }
-        }
-      ];
-    case "transmission":
-      return [
-        {
-          binding: start,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          sampler: { type: "filtering" }
-        },
-        {
-          binding: start + 1,
-          visibility: GPU_SHADER_STAGE_FRAGMENT,
-          texture: { sampleType: "float", viewDimension: "2d" }
-        }
-      ];
-  }
-}
-function physicalTextureFields(paramSchema) {
-  return standardPhysicalTextureFields(paramSchema);
-}
-function appendTextureInjection(_bgl, fields) {
-  const fieldSet = new Set(fields);
-  return standardPhysicalTextureFields(
-    STANDARD_PIPELINE_PARAM_SCHEMA.concat(
-      fields.map((name) => ({ name, type: "texture2d" }))
-    )
-  ).flatMap((field) => {
-    if (!fieldSet.has(field)) return [];
-    const canonicalIndex = STANDARD_PHYSICAL_TEXTURE_FIELDS.indexOf(field);
-    const binding = 26 + canonicalIndex * 2;
-    return [
-      {
-        binding,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        sampler: { type: "filtering" }
-      },
-      {
-        binding: binding + 1,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d" }
-      }
-    ];
-  });
-}
-function materialBindGroupLayoutIdentity(shaderId, paramSchema) {
-  const descriptor = buildBindGroupLayoutDescriptor(
-    {
-      shader: { id: shaderId, passKind: "forward", variantSet: void 0 },
-      attachments: { colorFormats: [], depthFormat: void 0, sampleCount: 1 }},
-    { kind: "pbr-material-merged", materialParamSchema: paramSchema }
-  );
-  return JSON.stringify({
-    entries: descriptor.entries,
-    physicalTextureFields: physicalTextureFields(paramSchema)
-  });
-}
-function buildPbrViewBglEntries(caps) {
-  const entries = [
-    {
-      binding: 0,
-      visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-      // View captures use the same bind group with a per-face view slot.
-      // Keeping this dynamic is also valid for the display slot at offset 0.
-      buffer: { type: "uniform", hasDynamicOffset: true }
-    },
-    {
-      binding: 3,
-      visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-      texture: { sampleType: "depth", viewDimension: "2d" }
-    },
-    {
-      binding: 4,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      sampler: { type: "comparison" }
-    },
-    // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: point shadow
-    // cube_array depth atlas. Bound to either the real ShadowAtlas
-    // cube_array view (when point shadows are active) or a 1x1x6 fallback
-    // cube_array view cleared to 1.0 (fully lit). Visibility is FRAGMENT
-    // only -- the directional binding 3 is VERTEX|FRAGMENT for shadow
-    // probe-debug sampling, but the cube atlas has no host-side probe path.
-    {
-      binding: 5,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      texture: { sampleType: "depth", viewDimension: "cube-array" }
-    },
-    // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1: point shadow
-    // params UBO. Carries `array<vec4<f32>, 4>` = 64 B with one lane per
-    // shadow-casting point light slot (shadowAtlasLayer in [0, 4)). Each
-    // lane stores `(near, far, depthBias, normalBias)` so the fragment-shader
-    // depth-ref reconstruction (lighting-punctual.wgsl evalPointShadowed)
-    // can avoid sampling DirectLightSlot for the URP path. The shared
-    // DirectLightSlot metadata remains the identity owner, so binding 6 is
-    // unused on HDRP shaders even though the BGL declares it (charter P4 single SSOT
-    // BGL across pipelines; the HDRP variant simply doesn't reference the
-    // binding in WGSL, which is allowed).
-    {
-      binding: 6,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      buffer: { type: "uniform" }
-    },
-    // feat-20260613-csm-cascaded-shadow-maps M5 / w28: shadowCasterCascade
-    // UBO (16 B). Carries the 0-based cascade index of the shadow pass
-    // currently being rasterized so `shadow_caster.wgsl` can index into
-    // `view.lightViewProj_X` per cascade. Shifted from binding 5 to
-    // binding 7 on 2026-06-13 to make room for point-shadow bindings 5/6
-    // (they predate this feat in main; CSM's slot was the optimal-yield
-    // give since point-shadow needs FRAGMENT-only and the cascade UBO
-    // needs vertex-stage too — keeping cascade higher avoids interleaving
-    // visibility flags within the contiguous shadow-binding cluster).
-    {
-      binding: 7,
-      visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-      buffer: { type: "uniform" }
-    },
-    // feat-20260625-spot-light-shadow-mapping M3 / w14 (D-5): spot shadow
-    // atlas. A single `texture_depth_2d` holding up to 4 spot shadows in a 2x2
-    // tile grid (urp-pipeline.ts spotShadowDepth). FRAGMENT-only — the spot
-    // shadow factor is reconstructed at fragment time via perspective-divide in
-    // `evalSpotShadowed` (lighting-punctual.wgsl).
-    //
-    // ALWAYS-ON (no caps gate, unlike the point cube_array atlas at binding 5
-    // which rides POINT_SHADOW_AVAILABLE): spot uses `texture_depth_2d` which is
-    // compat-safe in every WebGPU profile, so the binding is unconditionally
-    // declared. The matching WGSL declaration is `spotShadowMap` at @group(0)
-    // binding 8 in common.wgsl (also unconditional) — the two must stay in
-    // lock-step or WebGPU validation rejects the bind group at smoke time
-    // (memory: BGL shape mismatch is a browser-path-only bug). No binding 9
-    // sampler: spot reuses the comparison sampler at binding 4.
-    // feat-20260625-spot-light-shadow-mapping M3 / w14 (D-5): spot shadow 2D
-    // atlas, the LAST view-BG binding. The per-spot fragment-read perspective
-    // lightViewProj matrices that w24 originally declared at a standalone
-    // binding 9 uniform buffer were folded into the View UBO (binding 0,
-    // `view.spotLightViewProj`) in w25 (scope-amend webkit-fallback): the
-    // standalone binding pushed the WebGL2 fallback fragment uniform-buffer
-    // count to 12, over GLES 3.0's `max_uniform_buffers_per_shader_stage = 11`,
-    // crashing pipeline-layout creation on the compat path (this feat's target).
-    {
-      binding: 8,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      texture: { sampleType: "depth", viewDimension: "2d" }
-    }
-  ];
-  const extendedLighting = caps.extendedLighting ?? true;
-  if (extendedLighting) {
-    entries.push(
-      {
-        binding: 9,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        sampler: { type: "filtering" }
-      },
-      {
-        binding: 11,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d-array" }
-      },
-      {
-        binding: 12,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d-array" }
-      },
-      {
-        binding: 13,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d" }
-      },
-      {
-        binding: 14,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d" }
-      },
-      {
-        binding: 15,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: "uniform" }
-      }
-    );
-  } else if (caps.projectorAvailable !== false) {
-    entries.push(
-      {
-        binding: 11,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d" }
-      },
-      {
-        binding: 12,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        sampler: { type: "filtering" }
-      }
-    );
-  }
-  entries.push({
-    binding: 10,
-    visibility: GPU_SHADER_STAGE_VERTEX,
-    buffer: { type: "uniform", hasDynamicOffset: true }
-  });
-  return entries;
-}
-function buildPbrPipelineLayouts(device, caps) {
-  const viewBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, { kind: "pbr-view", caps })
-  );
-  if (!viewBglRes.ok) throw viewBglRes.error;
-  const materialBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
-      kind: "pbr-material-merged",
-      caps
-    })
-  );
-  if (!materialBglRes.ok) throw materialBglRes.error;
-  const meshArrayBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, { kind: "pbr-mesh-array", caps })
-  );
-  if (!meshArrayBglRes.ok) throw meshArrayBglRes.error;
-  const instancesBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
-      kind: "pbr-instances",
-      caps: { ...caps, probeBlend: false }
-    })
-  );
-  if (!instancesBglRes.ok) throw instancesBglRes.error;
-  const probeInstancesBglRes = caps.storageBuffer ? device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
-      kind: "pbr-instances",
-      caps: { ...caps, probeBlend: true }
-    })
-  ) : { ok: true, value: instancesBglRes.value };
-  if (!probeInstancesBglRes.ok) throw probeInstancesBglRes.error;
-  const layouts = [
-    viewBglRes.value,
-    materialBglRes.value,
-    meshArrayBglRes.value,
-    instancesBglRes.value
-  ];
-  const pipelineLayoutRes = device.createPipelineLayout({
-    label: "pbr-pl",
-    bindGroupLayouts: layouts
-  });
-  if (!pipelineLayoutRes.ok) throw pipelineLayoutRes.error;
-  const probeLayouts = [viewBglRes.value, materialBglRes.value, meshArrayBglRes.value, probeInstancesBglRes.value];
-  let probePipelineLayout = null;
-  if (caps.storageBuffer) {
-    const probePipelineLayoutRes = device.createPipelineLayout({
-      label: "pbr-probe-pl",
-      bindGroupLayouts: probeLayouts
-    });
-    if (!probePipelineLayoutRes.ok) throw probePipelineLayoutRes.error;
-    probePipelineLayout = probePipelineLayoutRes.value;
-  }
-  return {
-    pipelineLayout: pipelineLayoutRes.value,
-    viewBgl: viewBglRes.value,
-    materialBgl: materialBglRes.value,
-    meshArrayBgl: meshArrayBglRes.value,
-    instancesBgl: instancesBglRes.value,
-    probeInstancesBgl: probeInstancesBglRes.value,
-    probePipelineLayout,
-    bindGroupLayouts: layouts
-  };
-}
-var SKIN_MATERIAL_SHADER_ID = "forgeax::pbr-skin";
-var SHADOW_CASTER_SHADER_ID = "forgeax::default-shadow-caster";
-var AUTHORED_STANDARD_ID_RE = /::(?:standard|pbr-skin)(?:-|$)/;
-function isStandardPbrSkinMaterialShader(shaderId) {
-  return shaderId === SKIN_MATERIAL_SHADER_ID || shaderId === "forgeax::default-standard-pbr-skin" || shaderId !== void 0 && /::pbr-skin(?:-|$)/.test(shaderId);
-}
-function shadowCasterVariantSet(storageBuffer, skinned, gpuDrivenSceneIndex = false, alphaMask = false, vertexColorAvailable = false) {
-  const skinningDisabled = !skinned;
-  const defines = {
-    ALPHA_MASK: alphaMask,
-    GPU_DRIVEN_SCENE_INDEX_AVAILABLE: gpuDrivenSceneIndex,
-    GPU_DRIVEN_SCENE_INDEX_EXPLICIT: false,
-    SKINNING_DISABLED: skinningDisabled,
-    STORAGE_BUFFER_AVAILABLE: storageBuffer
-  };
-  if (vertexColorAvailable) defines.VERTEX_COLOR_AVAILABLE = true;
-  return Object.entries(defines).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([name, value]) => `${name}=${String(value)}`).join("+");
-}
-function resolvePipelineGroup2Contract(source) {
-  const withoutComments = source.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/\/\/.*$/gmu, "");
-  const bindings = [
-    ...withoutComments.matchAll(/@group\s*\(\s*2\s*\)\s*@binding\s*\(\s*(\d+)\s*\)/gu)
-  ].map((match) => Number(match[1]));
-  const hasSkinBindings = bindings.includes(1) || bindings.includes(2);
-  const hasClusterBindings = bindings.some((binding) => binding >= 3);
-  if (hasSkinBindings && hasClusterBindings) return "skin-cluster";
-  if (hasSkinBindings) return "skin";
-  if (hasClusterBindings) return "cluster";
-  return "mesh";
-}
-function isStandardPbrMaterialShader(shaderId) {
-  return shaderId === "forgeax::default-standard-pbr" || shaderId === SKIN_MATERIAL_SHADER_ID || shaderId === "forgeax::default-standard-pbr-skin" || shaderId !== void 0 && AUTHORED_STANDARD_ID_RE.test(shaderId);
-}
-function isCanonicalStandardPbrMaterialShader(shaderId) {
-  return shaderId === "forgeax::default-standard-pbr" || shaderId === SKIN_MATERIAL_SHADER_ID || shaderId === "forgeax::default-standard-pbr-skin";
-}
-function buildPbrSkinLayouts(device, caps, pbr) {
-  const skinMeshArrayBglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
-      kind: "pbr-skin-mesh-array",
-      caps
-    })
-  );
-  if (!skinMeshArrayBglRes.ok) throw skinMeshArrayBglRes.error;
-  const layouts = [
-    pbr.viewBgl,
-    pbr.materialBgl,
-    skinMeshArrayBglRes.value,
-    pbr.instancesBgl
-  ];
-  const pipelineLayoutRes = device.createPipelineLayout({
-    label: "pbr-skin-pl",
-    bindGroupLayouts: layouts
-  });
-  if (!pipelineLayoutRes.ok) throw pipelineLayoutRes.error;
-  const probeLayouts = [pbr.viewBgl, pbr.materialBgl, skinMeshArrayBglRes.value, pbr.probeInstancesBgl];
-  let probePipelineLayout = null;
-  if (caps.storageBuffer) {
-    const probePipelineLayoutRes = device.createPipelineLayout({
-      label: "pbr-skin-probe-pl",
-      bindGroupLayouts: probeLayouts
-    });
-    if (!probePipelineLayoutRes.ok) throw probePipelineLayoutRes.error;
-    probePipelineLayout = probePipelineLayoutRes.value;
-  }
-  return {
-    pipelineLayout: pipelineLayoutRes.value,
-    viewBgl: pbr.viewBgl,
-    materialBgl: pbr.materialBgl,
-    meshArrayBgl: skinMeshArrayBglRes.value,
-    instancesBgl: pbr.instancesBgl,
-    probeInstancesBgl: pbr.probeInstancesBgl,
-    probePipelineLayout,
-    bindGroupLayouts: layouts
-  };
-}
-function buildGpuDrivenPbrInstancesBindGroupLayout(device, caps) {
-  if (!caps.storageBuffer) {
-    throw new Error("GPU-driven PBR instances layout requires storage-buffer capability");
-  }
-  const result = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, {
-      kind: "pbr-gpu-driven-instances",
-      caps
-    })
-  );
-  if (!result.ok) throw result.error;
-  return result.value;
-}
-function buildGpuDrivenPbrPipelineLayout(device, pbr, gpuDrivenInstancesBgl) {
-  const result = device.createPipelineLayout({
-    label: "pbr-gpu-driven-pl",
-    bindGroupLayouts: [pbr.viewBgl, pbr.materialBgl, pbr.meshArrayBgl, gpuDrivenInstancesBgl]
-  });
-  if (!result.ok) throw result.error;
-  return result.value;
-}
-function buildGpuDrivenPbrSkinPipelineLayout(device, pbrSkin, gpuDrivenInstancesBgl) {
-  const result = device.createPipelineLayout({
-    label: "pbr-skin-gpu-driven-pl",
-    bindGroupLayouts: [
-      pbrSkin.viewBgl,
-      pbrSkin.materialBgl,
-      pbrSkin.meshArrayBgl,
-      gpuDrivenInstancesBgl
-    ]
-  });
-  if (!result.ok) throw result.error;
-  return result.value;
-}
-function createPbrSkinMeshBindGroupEntries(meshBuffer, meshSize, paletteBuffer, paletteWindowBytes) {
-  return [
-    {
-      binding: 0,
-      resource: { kind: "buffer", value: { buffer: meshBuffer, offset: 0, size: meshSize } }
-    },
-    ...[1, 2].map((binding) => ({
-      binding,
-      resource: {
-        kind: "buffer",
-        value: {
-          buffer: paletteBuffer,
-          offset: 0,
-          size: paletteWindowBytes
-        }
-      }
-    }))
-  ];
-}
-function pbrSkinMeshDynamicOffsets(meshOffset, paletteOffset) {
-  return [meshOffset, paletteOffset, paletteOffset];
-}
-var SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET = "";
-function createHdrpBindGroupLayoutDescriptor() {
-  const meshBufType = "read-only-storage";
-  const clusterBufType = "read-only-storage";
-  return {
-    label: "hdrp-unified-bgl-group2",
-    entries: [
-      {
-        binding: 0,
-        // Standard fragment lighting (transmission/refraction and clustered
-        // evaluation) reads the same mesh transform window as the vertex
-        // stage. Keep this visibility in the HDRP descriptor aligned with
-        // the URP mesh-array descriptor; restricting it to vertex makes the
-        // HDRP pipeline invalid when fs_main accesses `meshes[0]`.
-        visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: meshBufType, hasDynamicOffset: true }
-      },
-      // Bindings 1 and 2 stay absent for the URP physical isolation gap.
-      {
-        binding: 3,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: clusterBufType, hasDynamicOffset: false }
-      },
-      {
-        binding: 4,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: clusterBufType, hasDynamicOffset: false }
-      },
-      {
-        binding: 5,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: clusterBufType, hasDynamicOffset: false }
-      },
-      {
-        binding: 6,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: "uniform", hasDynamicOffset: false }
-      },
-      {
-        binding: 7,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: "float", viewDimension: "2d", multisampled: false }
-      },
-      {
-        binding: 8,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        sampler: { type: "filtering" }
-      }
-    ]
-  };
-}
-function createHdrpSkinBindGroupLayoutDescriptor() {
-  const base = createHdrpBindGroupLayoutDescriptor();
-  const baseEntries = base.entries;
-  if (baseEntries === void 0 || baseEntries[0] === void 0) {
-    throw new Error("HDRP base group(2) layout must declare mesh binding 0");
-  }
-  const paletteType = "read-only-storage";
-  return {
-    label: "hdrp-skin-unified-bgl-group2",
-    entries: [
-      baseEntries[0],
-      {
-        binding: 1,
-        visibility: GPU_SHADER_STAGE_VERTEX,
-        buffer: { type: paletteType, hasDynamicOffset: true }
-      },
-      {
-        binding: 2,
-        visibility: GPU_SHADER_STAGE_VERTEX,
-        buffer: { type: paletteType, hasDynamicOffset: true }
-      },
-      ...baseEntries.slice(1)
-    ]
-  };
-}
-function resolveMaterialParamSchema(spec, options) {
-  if (options.materialParamSchema !== void 0) return options.materialParamSchema;
-  if (options.registry !== void 0) {
-    const lookup = options.registry.findMaterialArtifact(spec.shader.id);
-    if (lookup.ok) return lookup.value.paramSchema;
-  }
-  return void 0;
-}
-function buildBindGroupLayoutDescriptor(spec, options) {
-  switch (options.kind) {
-    case "pbr-view": {
-      const caps = options.caps ?? { };
-      return {
-        label: "pbr-view-bgl",
-        entries: buildPbrViewBglEntries(caps)
-      };
-    }
-    case "pbr-mesh-array": {
-      const caps = options.caps ?? { storageBuffer: true };
-      const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
-      return {
-        label: "pbr-mesh-array-bgl",
-        entries: [
-          {
-            binding: 0,
-            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: meshBufType, hasDynamicOffset: true }
-          }
-        ]
-      };
-    }
-    case "pbr-instances": {
-      const caps = options.caps ?? { storageBuffer: true };
-      const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
-      const entries = [
-        {
-          binding: 0,
-          visibility: GPU_SHADER_STAGE_VERTEX,
-          buffer: { type: meshBufType, hasDynamicOffset: false }
-        },
-        ...caps.probeBlend === true ? [
-          {
-            // Per-object fragment lane; the record is always exactly 160B.
-            binding: 1,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: meshBufType, hasDynamicOffset: true }
-          }
-        ] : []
-      ];
-      return {
-        label: caps.probeBlend === true ? "pbr-probe-instances-bgl" : "pbr-instances-bgl",
-        entries: entries.map(
-          (entry) => entry.binding === 0 ? {
-            ...entry,
-            // Standard transmission reads the same per-instance transform in
-            // fs_main to convert glTF unit-space thickness into world metres.
-            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT
-          } : entry
-        )
-      };
-    }
-    case "pbr-gpu-driven-instances": {
-      const caps = options.caps ?? { storageBuffer: true };
-      const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
-      return {
-        label: "pbr-gpu-driven-instances-bgl",
-        entries: [
-          {
-            binding: 0,
-            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: meshBufType, hasDynamicOffset: false }
-          },
-          {
-            // ShadowCaster's scene-index entry still reads the visible row
-            // through binding(1). Keep this alias in the dedicated layout so
-            // the shared visible bind group can serve both the Standard PBR
-            // (binding(2)) and depth-only shadow (binding(1)) consumers.
-            binding: 1,
-            visibility: GPU_SHADER_STAGE_VERTEX,
-            buffer: { type: meshBufType, hasDynamicOffset: false }
-          },
-          {
-            binding: 2,
-            visibility: GPU_SHADER_STAGE_VERTEX,
-            buffer: { type: meshBufType, hasDynamicOffset: false }
-          }
-        ]
-      };
-    }
-    case "pbr-skin-mesh-array": {
-      const caps = options.caps ?? { storageBuffer: true };
-      const meshBufType = caps.storageBuffer ? "read-only-storage" : "uniform";
-      return {
-        label: "pbr-skin-mesh-array-bgl",
-        entries: [
-          {
-            binding: 0,
-            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: meshBufType, hasDynamicOffset: true }
-          },
-          {
-            binding: 1,
-            visibility: GPU_SHADER_STAGE_VERTEX,
-            buffer: { type: meshBufType, hasDynamicOffset: true }
-          },
-          {
-            binding: 2,
-            visibility: GPU_SHADER_STAGE_VERTEX,
-            buffer: { type: meshBufType, hasDynamicOffset: true }
-          }
-        ]
-      };
-    }
-    case "pbr-material-merged": {
-      const resolvedSchema = resolveMaterialParamSchema(spec, options);
-      const effectiveSchema = resolvedSchema ?? STANDARD_PIPELINE_PARAM_SCHEMA;
-      const physicalFields = physicalTextureFields(effectiveSchema);
-      const userRegionSchema = isCanonicalStandardPbrMaterialShader(spec.shader.id) ? STANDARD_PIPELINE_PARAM_SCHEMA : effectiveSchema;
-      const userRegion = buildPbrMaterialUserRegionEntries(userRegionSchema);
-      const afterIbl = [...userRegion, ...appendInjection(userRegion, "ibl")];
-      const afterTransmission = [...afterIbl, ...appendInjection(afterIbl, "transmission")];
-      const merged = [
-        ...options.caps?.transmissionBackdrop === false ? afterIbl : afterTransmission,
-        ...appendTextureInjection(afterTransmission, physicalFields)
-      ];
-      if (options.caps?.storageBuffer ?? true) {
-        merged.push({
-          binding: 46,
-          visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
-          buffer: { type: "read-only-storage", hasDynamicOffset: false }
-        });
-      }
-      return {
-        label: "pbr-material-skylight-bgl",
-        entries: [
-          ...merged,
-          {
-            binding: 47,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            texture: { sampleType: "float", viewDimension: "cube" }
-          }
-        ]
-      };
-    }
-    case "unlit-material": {
-      const resolvedSchema = resolveMaterialParamSchema(spec, options);
-      return {
-        label: "unlit-material-bgl",
-        entries: buildPbrMaterialUserRegionEntries(resolvedSchema)
-      };
-    }
-    case "hdrp-7-slot": {
-      const desc = createHdrpBindGroupLayoutDescriptor();
-      return {
-        label: desc.label ?? "hdrp-unified-bgl-group2",
-        entries: [...desc.entries ?? []]
-      };
-    }
-    case "fullscreen-post": {
-      return {
-        label: "fullscreen-post-bgl",
-        entries: buildFullscreenPostInputEntries(spec)
-      };
-    }
-    case "fullscreen-post-with-params": {
-      return {
-        label: "fullscreen-post-with-params-bgl",
-        entries: [
-          ...buildFullscreenPostInputEntries(spec),
-          {
-            binding: 2,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: "uniform" }
-          }
-        ]
-      };
-    }
-    case "fullscreen-post-with-scene-depth": {
-      return {
-        label: "fullscreen-post-with-scene-depth-bgl",
-        entries: [
-          ...buildFullscreenPostInputEntries(spec),
-          {
-            binding: 2,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: "uniform" }
-          },
-          {
-            binding: 3,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            texture: { sampleType: "depth", viewDimension: "2d" }
-          },
-          {
-            binding: 4,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            sampler: { type: "non-filtering" }
-          }
-        ]
-      };
-    }
-    case "fullscreen-post-with-scene-depth-msaa": {
-      return {
-        label: "fullscreen-post-with-scene-depth-msaa-bgl",
-        entries: [
-          ...buildFullscreenPostInputEntries(spec),
-          {
-            binding: 2,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            buffer: { type: "uniform" }
-          },
-          {
-            binding: 3,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            texture: { sampleType: "depth", viewDimension: "2d", multisampled: true }
-          },
-          {
-            binding: 4,
-            visibility: GPU_SHADER_STAGE_FRAGMENT,
-            sampler: { type: "non-filtering" }
-          }
-        ]
-      };
-    }
-  }
-}
-function buildFullscreenPostInputEntries(spec) {
-  const inputFormat = spec.attachments.depthFormat ?? spec.attachments.colorFormats[0];
-  const sampleType = inputFormat === "depth32float" || inputFormat === "depth24plus" || inputFormat === "depth24plus-stencil8" || inputFormat === "depth16unorm" ? "depth" : inputFormat === "r32float" ? "unfilterable-float" : "float";
-  return [
-    {
-      binding: 0,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      texture: { sampleType, viewDimension: "2d" }
-    },
-    {
-      binding: 1,
-      visibility: GPU_SHADER_STAGE_FRAGMENT,
-      sampler: {
-        type: sampleType === "depth" ? "comparison" : "filtering"
-      }
-    }
-  ];
-}
-
-// src/scene/probe-blend-record.ts
-var PROBE_BLEND_RECORD_BYTE_SIZE = 160;
-var PROBE_BLEND_RECORD_STRIDE = 256;
-var PROBE_BLEND_RECORD_CAPACITY = 64;
-function probeBlendRecordOffset(objectKey) {
-  if (!Number.isInteger(objectKey) || objectKey < 0) {
-    throw new Error("probe blend record requires a non-negative object key");
-  }
-  return (objectKey + 1) * PROBE_BLEND_RECORD_STRIDE;
-}
-
-// src/targets/material-source.ts
-var sourceBindings = /* @__PURE__ */ new WeakMap();
-function sourceToken() {
-  return Object.freeze({});
-}
-function resolveRenderTargetMaterialSource(source) {
-  return sourceBindings.get(source);
-}
-function invalid(field, value, expected) {
-  return {
-    ok: false,
-    error: new RenderTargetDescriptorInvalidError({ field, value, expected })
-  };
-}
-function createRenderTargetMaterialSource(target, descriptor, options) {
-  if (options.aspect !== "color") return invalid("aspect", options.aspect, "color");
-  if (options.dimension !== descriptor.shape) {
-    return invalid("dimension", options.dimension, `dimension matches ${descriptor.shape}`);
-  }
-  const mipCount = descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-  if (!Number.isInteger(options.mipLevel) || options.mipLevel < 0 || options.mipLevel >= mipCount) {
-    return invalid("mipLevel", options.mipLevel, `an admitted mip level below ${mipCount}`);
-  }
-  if (!Number.isInteger(options.generation) || options.generation < 0) {
-    return invalid("generation", options.generation, "a non-negative device generation");
-  }
-  const result = {
-    ok: true,
-    value: Object.freeze({
-      source: sourceToken(),
-      target,
-      generation: options.generation,
-      shape: descriptor.shape,
-      format: descriptor.format,
-      view: Object.freeze({
-        dimension: options.dimension,
-        mipLevel: options.mipLevel,
-        resolveRequired: descriptor.sampleCount === 4
-      })
-    })
-  };
-  sourceBindings.set(result.value.source, result.value);
-  return result;
-}
-
-// src/systems/pass-selector.ts
-function matchPass(tags, selector) {
-  if (Object.keys(selector).length === 0) return true;
-  for (const [key, allowedValues] of Object.entries(selector)) {
-    const passValue = tags[key];
-    if (passValue === void 0) return false;
-    if (allowedValues.length === 0) return false;
-    if (!allowedValues.includes(passValue)) return false;
-  }
-  return true;
-}
-function selectPasses(passes, selector) {
-  if (Object.keys(selector).length === 0) return passes;
-  return passes.filter(
-    (p) => matchPass(p.renderState?.tags ?? {}, selector)
-  );
-}
-
-// src/gpu-driven/prepared-draw.ts
-function failure(code, detail) {
-  return { ok: false, error: new GpuDrivenPreparationError(code, detail) };
-}
-function hasRequiredVertexInputs(expected, actual) {
-  return expected.every(
-    (input) => actual.some(
-      (candidate) => candidate.semantic === input.semantic && candidate.location === input.location && candidate.format === input.format
-    )
-  );
-}
-function hasMaterialResources(snapshot, receipt) {
-  if ((snapshot.material.textureSources?.size ?? 0) > 0 || (snapshot.material.videoTextureFields?.size ?? 0) > 0) {
-    return false;
-  }
-  const textures = snapshot.material.textureHandles;
-  const samplers = snapshot.material.samplerHandles;
-  const authoredTextures = snapshot.material.authoredTextureFields;
-  const authoredSamplers = snapshot.material.authoredSamplerFields;
-  return receipt.resourceSlots.every((slot) => {
-    if (slot.kind === "storage-buffer") return false;
-    if (slot.kind === "texture") {
-      if (!authoredTextures?.has(slot.parameter)) return true;
-      return textures?.has(slot.parameter) === true || snapshot.material.textureSources?.has(slot.parameter) === true || snapshot.material.videoTextureFields?.has(slot.parameter) === true;
-    }
-    if (!authoredSamplers?.has(slot.parameter)) return true;
-    return samplers?.has(slot.parameter) === true;
-  });
-}
-function prepareGpuDrivenDraw(input) {
-  const receipt = input.artifact.receipt;
-  if (receipt === void 0) {
-    return failure("missing-material-receipt", {
-      reason: "material-receipt-missing",
-      owner: "material",
-      expected: "MaterialShaderArtifact.receipt"
-    });
-  }
-  if (receipt.generation !== input.generation) {
-    return failure("stale-generation", {
-      reason: "generation-stale",
-      owner: "generation",
-      expectedGeneration: input.generation,
-      actualGeneration: receipt.generation
-    });
-  }
-  if (receipt.reflection.layoutIdentity !== input.artifact.layoutIdentity) {
-    return failure("reflection-mismatch", {
-      reason: "reflection-receipt-mismatch",
-      owner: "material",
-      expected: input.artifact.layoutIdentity,
-      actual: receipt.reflection.layoutIdentity
-    });
-  }
-  if (receipt.uvSets.some((uv) => uv.set > 0) && input.geometry.vertexInputs.length < 3) {
-    return failure("missing-uv", {
-      reason: "uv-set-missing",
-      owner: "geometry",
-      expected: `${receipt.uvSets.length} material UV sets`,
-      actual: `${input.geometry.vertexInputs.filter((vertex) => vertex.semantic.startsWith("uv")).length} geometry UV sets`
-    });
-  }
-  if (!hasRequiredVertexInputs(receipt.vertexInputs, input.geometry.vertexInputs)) {
-    return failure("vertex-input-mismatch", {
-      reason: "vertex-semantic-mismatch",
-      owner: "geometry",
-      expected: receipt.vertexInputs.map((input2) => input2.semantic).join(","),
-      actual: input.geometry.vertexInputs.map((input2) => input2.semantic).join(",")
-    });
-  }
-  const hasAlphaMask = receipt.alphaMask.cutoff.length > 0 || receipt.alphaMask.source.length > 0;
-  if (hasAlphaMask && (receipt.alphaMask.cutoff.length === 0 || receipt.alphaMask.source.length === 0)) {
-    return failure("alpha-mask-mismatch", {
-      reason: "alpha-mask-receipt-missing",
-      owner: "material",
-      expected: "alphaMask.cutoff and alphaMask.source for a masked Pass"
-    });
-  }
-  if (!hasMaterialResources(input.snapshot, receipt)) {
-    return failure("resource-not-ready", {
-      reason: "material-resource-missing",
-      owner: "material",
-      expected: receipt.resourceSlots.map((slot) => slot.parameter).join(",")
-    });
-  }
-  const deformation = input.snapshot.skin === void 0 ? "rigid" : "skin";
-  if (deformation === "skin") {
-    if (input.skinReceipt === void 0 || receipt.skinPaletteAddress === void 0) {
-      return failure("skin-receipt-mismatch", {
-        reason: "skin-address-missing",
-        owner: "skin",
-        expected: "skinPaletteAddress and skinReceipt"
-      });
-    }
-    if (input.skinReceipt.identity !== input.snapshot.skin?.identity || input.skinReceipt.generation !== input.snapshot.skin?.generation || input.skinReceipt.group !== receipt.skinPaletteAddress.group || input.skinReceipt.binding !== receipt.skinPaletteAddress.binding) {
-      return failure("skin-receipt-mismatch", {
-        reason: "skin-address-missing",
-        owner: "skin",
-        expected: `${receipt.skinPaletteAddress.group}:${receipt.skinPaletteAddress.binding}@${input.snapshot.skin?.generation ?? "<missing>"}`,
-        actual: `${input.skinReceipt.group}:${input.skinReceipt.binding}@${input.skinReceipt.generation}`
-      });
-    }
-  }
-  return {
-    ok: true,
-    value: {
-      identity: {
-        material: input.artifact.material,
-        geometry: input.geometry.identity,
-        deformation
-      },
-      receiptGeneration: receipt.generation,
-      receiptIdentity: receipt.receiptIdentity,
-      directEntry: receipt.directEntry,
-      sceneIndexEntry: receipt.sceneIndexEntry,
-      materialRow: receipt.materialRow,
-      resourceSlots: receipt.resourceSlots,
-      uvSets: receipt.uvSets,
-      vertexInputs: receipt.vertexInputs,
-      alphaMask: receipt.alphaMask,
-      skinPaletteAddress: receipt.skinPaletteAddress,
-      topology: input.draw.topology,
-      indexed: input.draw.kind === "indexed",
-      first: input.draw.first,
-      count: input.draw.count,
-      baseVertex: input.draw.baseVertex
-    }
-  };
-}
-
-// src/extract/gpu-driven.ts
-function gpuDrivenDrawKey(worldEntity, materialHandle, drawItemIndex) {
-  return `${worldEntity}:${materialHandle}:${drawItemIndex}`;
-}
-function gpuDrivenShadowDrawKey(worldEntity, materialHandle, drawItemIndex, passIndex) {
-  return `${gpuDrivenDrawKey(worldEntity, materialHandle, drawItemIndex)}:${passIndex}`;
-}
-function gpuDrivenMaterialArtifactKey(input) {
-  return [
-    input.material,
-    input.deformation,
-    input.receiptIdentity ?? "<legacy-receipt>",
-    input.receiptGeneration
-  ].join("|");
-}
-function gpuDrivenSourceDrawItemIndex(draw, compactIndex) {
-  return draw.drawItemIndex ?? compactIndex;
-}
-function resolvePreparedGpuDrivenDraw(input) {
-  return prepareGpuDrivenDraw(input);
-}
-function gpuDrivenMaterialResourceClass(material) {
-  const textures = [...material.textureHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
-  const samplers = [...material.samplerHandles?.entries() ?? []].map(([name, handle]) => [name, Number(handle)]).sort(([left], [right]) => left.localeCompare(right));
-  return JSON.stringify({
-    textures,
-    samplers
-  });
-}
-function hasCpuOnlyMaterialResources(material) {
-  return (material.textureSources?.size ?? 0) > 0 || (material.videoTextureFields?.size ?? 0) > 0;
-}
-function buildGpuDrivenDraws(input) {
-  const legacy = "submeshes" in input;
-  if (!legacy && input.mesh === void 0) return [];
-  const parsedMesh = legacy ? void 0 : input.mesh;
-  if (!legacy && parsedMesh === void 0) return [];
-  const indexed = legacy ? input.indexed : parsedMesh?.indices !== void 0;
-  const submeshes = legacy ? input.submeshes : parsedMesh?.submeshes ?? [];
-  const layoutProjection = parsedMesh === void 0 ? void 0 : deriveVertexLayoutProjection(parsedMesh.attributes);
-  const geometry = {
-    identity: parsedMesh === void 0 ? "<no-mesh>" : `${parsedMesh.guid ?? "<no-guid>"}:${layoutProjection?.digest ?? ""}`,
-    vertexInputs: (layoutProjection?.attributes ?? []).map((attribute) => ({
-      semantic: attribute.key,
-      location: attribute.shaderLocation,
-      format: attribute.format
-    })),
-    topology: submeshes[0]?.topology ?? "triangle-list",
-    indexed
-  };
-  let nonIndexedFirst = 0;
-  return submeshes.flatMap((submesh, drawItemIndex) => {
-    const drawMaterial = input.materials[submesh.materialSlot] ?? input.fallbackMaterial;
-    const first = indexed ? submesh.indexOffset : nonIndexedFirst;
-    nonIndexedFirst += submesh.vertexCount;
-    if (drawMaterial.transparent === true) return [];
-    const draw = {
-      drawItemIndex,
-      kind: indexed ? "indexed" : "non-indexed",
-      first,
-      count: indexed ? submesh.indexCount : submesh.vertexCount,
-      baseVertex: 0,
-      materialSlot: submesh.materialSlot,
-      topology: submesh.topology,
-      pipelineClass: `${drawMaterial.materialShaderId ?? "forgeax::default-unlit"}|${submesh.topology}|${JSON.stringify(drawMaterial.renderState ?? null)}`,
-      materialResourceClass: gpuDrivenMaterialResourceClass(drawMaterial)
-    };
-    const lodRanges = !legacy ? input.lodMeshes?.map((lodMesh) => {
-      if (lodMesh === void 0) return void 0;
-      const lower = lodMesh.submeshes[drawItemIndex];
-      if (lower === void 0) return void 0;
-      const lowerIndexed = lodMesh.indices !== void 0;
-      const lowerFirst = lowerIndexed ? lower.indexOffset : lodMesh.submeshes.slice(0, drawItemIndex).reduce((offset, entry) => offset + entry.vertexCount, 0);
-      return {
-        first: lowerFirst,
-        count: lowerIndexed ? lower.indexCount : lower.vertexCount,
-        baseVertex: 0
-      };
-    }) : void 0;
-    const withLodRanges = lodRanges?.length !== 0 && lodRanges?.every((range) => range !== void 0) ? { lodRanges } : {};
-    const prepared = legacy ? input.prepare?.(draw, drawMaterial) : hasCpuOnlyMaterialResources(drawMaterial) ? void 0 : (() => {
-      const materialShaderId = drawMaterial.materialShaderId;
-      const vertexColorAvailable = geometry.vertexInputs.some(
-        (input2) => input2.semantic === "color"
-      );
-      const sceneIndexProgramKey = Object.entries(
-        drawMaterial.materialSceneIndexProgramKeys ?? {}
-      ).find(
-        ([passName, program]) => program.pass === "forward" && drawMaterial.materialProgramKeys?.[passName] === materialShaderId
-      )?.[1]?.specializationKey;
-      const artifact = materialShaderId === void 0 ? void 0 : input.getMaterialShaderArtifact?.(sceneIndexProgramKey ?? materialShaderId, {
-        vertexColorAvailable,
-        deformation: input.baseSnapshot.skin === void 0 ? "rigid" : "skin",
-        pass: "forward",
-        address: "scene-index"
-      });
-      const requiresReceipt = isCanonicalStandardPbrMaterialShader(materialShaderId) || sceneIndexProgramKey !== void 0;
-      if (artifact === void 0) {
-        return input.getMaterialShaderArtifact !== void 0 && requiresReceipt ? new GpuDrivenPreparationError("missing-material-receipt", {
-          reason: "material-receipt-missing",
-          owner: "material",
-          expected: `artifact for ${materialShaderId}`
-        }) : void 0;
-      }
-      const receipt = artifact.receipt;
-      if (receipt === void 0) {
-        return new GpuDrivenPreparationError("missing-material-receipt", {
-          reason: "material-receipt-missing",
-          owner: "material",
-          expected: `receipt for ${materialShaderId}`
-        });
-      }
-      const skinReceipt = input.baseSnapshot.skin !== void 0 && receipt.skinPaletteAddress !== void 0 ? {
-        identity: input.baseSnapshot.skin.identity,
-        generation: input.baseSnapshot.skin.generation,
-        group: receipt.skinPaletteAddress.group,
-        binding: receipt.skinPaletteAddress.binding,
-        byteOffset: input.baseSnapshot.skin.byteOffset
-      } : void 0;
-      const selectedArtifact = artifact === void 0 || sceneIndexProgramKey === void 0 || materialShaderId === void 0 ? artifact : {
-        ...artifact,
-        material: materialShaderId,
-        specializationKey: sceneIndexProgramKey
-      };
-      const result = resolvePreparedGpuDrivenDraw({
-        snapshot: { ...input.baseSnapshot, material: drawMaterial },
-        artifact: selectedArtifact ?? artifact,
-        geometry: { ...geometry, topology: draw.topology, indexed: draw.kind === "indexed" },
-        generation: receipt.generation,
-        draw,
-        ...skinReceipt === void 0 ? {} : { skinReceipt }
-      });
-      return result.ok ? result.value : result.error;
-    })();
-    if (prepared instanceof GpuDrivenPreparationError) {
-      return [{ ...draw, preparationError: prepared, ...withLodRanges }];
-    }
-    return [
-      prepared === void 0 ? { ...draw, ...withLodRanges } : { ...draw, prepared, ...withLodRanges }
-    ];
-  });
-}
-
-export { COOKIE_MATRIX_BYTES, COOKIE_SLICE_CAPACITY, COOKIE_SLICE_SIZE, DeviceScope, EXTENDED_LIGHTING_REQUIRED_SAMPLED_TEXTURES, EXTENDED_LIGHTING_TOPOLOGY, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDEX, GPU_BUFFER_USAGE_INDIRECT, GPU_BUFFER_USAGE_MAP_READ, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_STORAGE, GPU_BUFFER_USAGE_UNIFORM, GPU_BUFFER_USAGE_VERTEX, GPU_SHADER_STAGE_COMPUTE, GPU_SHADER_STAGE_FRAGMENT, GPU_SHADER_STAGE_VERTEX, IES_SLICE_CAPACITY, IES_SLICE_HEIGHT, IES_SLICE_WIDTH, LifecycleTransaction, PROBE_BLEND_RECORD_BYTE_SIZE, PROBE_BLEND_RECORD_CAPACITY, PROBE_BLEND_RECORD_STRIDE, SHADOW_CASTER_SHADER_ID, SKIN_MATERIAL_SHADER_ID, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, buildBindGroupLayoutDescriptor, buildGpuDrivenDraws, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, buildPbrMaterialUserRegionEntries, buildPbrPipelineLayouts, buildPbrSkinLayouts, classifySceneDataCoverage, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, createPbrSkinMeshBindGroupEntries, createRenderTargetMaterialSource, createTemporalCoverage, deriveExtendedLightingCapability, extendedLightingSampledTextureCapacityAvailable, getOpaqueResourceIdentity, getTextureIdentity, gpuDrivenDrawKey, gpuDrivenMaterialArtifactKey, gpuDrivenShadowDrawKey, gpuDrivenSourceDrawItemIndex, hasRequiredVertexInputs, instanceCollectionCacheKey, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, isStandardPbrSkinMaterialShader, makeZeroCameraFallbackSnapshot, matchPass, materialBindGroupLayoutIdentity, pbrSkinMeshDynamicOffsets, physicalTextureFields, probeBlendRecordOffset, resolvePipelineGroup2Contract, resolveRenderTargetMaterialSource, scanSceneDataCoverage, selectPasses, shadowCasterVariantSet, validateGraphTargetCaptureReadback, worldEntityKey };
-//# sourceMappingURL=chunk-3RTCJTH4.mjs.map
-//# sourceMappingURL=chunk-3RTCJTH4.mjs.map