@forgeax/engine-render 0.1.33 → 0.1.35

package/dist/chunk-NB2S7ZRX.mjs

@@ -1,1783 +0,0 @@
-import { err, ok } from '@forgeax/engine-types';
-import { cubeArrayDepthDescriptor, comparisonSamplerDescriptor, cubeArrayDepthFaceView } from '@forgeax/engine-rhi';
-
-// src/pipeline/standard-output/auto-exposure/inspection.ts
-var AutoExposureInvalidParameterError = class extends Error {
-  constructor(detail) {
-    super(`auto-exposure-invalid-parameter: ${detail.field}`);
-    this.detail = detail;
-    this.name = "AutoExposureInvalidParameterError";
-  }
-  detail;
-  code = "auto-exposure-invalid-parameter";
-  expected = ERROR_POLICY[this.code].expected;
-  hint = ERROR_POLICY[this.code].hint;
-};
-var AutoExposureCapabilityUnavailableError = class extends Error {
-  constructor(detail) {
-    super(`auto-exposure-capability-unavailable: ${detail.capability}`);
-    this.detail = detail;
-    this.name = "AutoExposureCapabilityUnavailableError";
-  }
-  detail;
-  code = "auto-exposure-capability-unavailable";
-  expected = ERROR_POLICY[this.code].expected;
-  hint = ERROR_POLICY[this.code].hint;
-};
-var AutoExposureStaleGenerationError = class extends Error {
-  constructor(detail) {
-    super(
-      `auto-exposure-stale-generation: ${detail.actualGeneration} != ${detail.expectedGeneration}`
-    );
-    this.detail = detail;
-    this.name = "AutoExposureStaleGenerationError";
-  }
-  detail;
-  code = "auto-exposure-stale-generation";
-  expected = ERROR_POLICY[this.code].expected;
-  hint = ERROR_POLICY[this.code].hint;
-};
-var AutoExposureStageFailedError = class extends Error {
-  constructor(detail) {
-    super(`auto-exposure-stage-failed: ${detail.operation}`);
-    this.detail = detail;
-    this.name = "AutoExposureStageFailedError";
-  }
-  detail;
-  code = "auto-exposure-stage-failed";
-  expected = ERROR_POLICY[this.code].expected;
-  hint = ERROR_POLICY[this.code].hint;
-};
-var ERROR_POLICY = {
-  "auto-exposure-invalid-parameter": {
-    expected: "camera auto-exposure parameters are finite and within their declared ranges",
-    hint: "inspect the field and provide a finite value before rebuilding the camera output"
-  },
-  "auto-exposure-capability-unavailable": {
-    expected: "the auto-exposure stage has the required device capability",
-    hint: "inspect live capabilities and retry the same camera generation"
-  },
-  "auto-exposure-stale-generation": {
-    expected: "the prepared auto-exposure state matches the camera target generation",
-    hint: "discard stale prepared state and rebuild from the latest camera snapshot"
-  },
-  "auto-exposure-stage-failed": {
-    expected: "the auto-exposure stage completes its declared operation",
-    hint: "inspect the structured cause, preserve lastKnownGood, and retry the stage"
-  }
-};
-function createAutoExposureError(input) {
-  if (input instanceof AutoExposureInvalidParameterError || input instanceof AutoExposureCapabilityUnavailableError || input instanceof AutoExposureStaleGenerationError || input instanceof AutoExposureStageFailedError) {
-    return input;
-  }
-  switch (input.code) {
-    case "auto-exposure-invalid-parameter":
-      return new AutoExposureInvalidParameterError(input.detail);
-    case "auto-exposure-capability-unavailable":
-      return new AutoExposureCapabilityUnavailableError(input.detail);
-    case "auto-exposure-stale-generation":
-      return new AutoExposureStaleGenerationError(input.detail);
-    case "auto-exposure-stage-failed":
-      return new AutoExposureStageFailedError(input.detail);
-  }
-}
-function cloneExposure(exposure) {
-  if (exposure.kind === "manual") return { ...exposure };
-  return {
-    ...exposure,
-    rangeEv: [exposure.rangeEv[0], exposure.rangeEv[1]],
-    rates: [exposure.rates[0], exposure.rates[1]]
-  };
-}
-function cloneFailure(error) {
-  if (error === void 0) return void 0;
-  return Object.freeze({
-    ...error,
-    detail: Object.freeze({ ...error.detail })
-  });
-}
-function createAutoExposureInspection(input) {
-  const base = {
-    requested: cloneExposure(input.requested),
-    actual: input.actual,
-    actualState: input.actualState ?? (input.actual === null ? "gpu-resident" : "accepted"),
-    fallback: input.fallback,
-    lastKnownGood: input.lastKnownGood,
-    targetGeneration: input.targetGeneration,
-    reset: Object.freeze([...input.reset]),
-    cost: Object.freeze({ ...input.cost }),
-    receipt: Object.freeze({ ...input.receipt })
-  };
-  if (input.recentFailure === void 0) return Object.freeze(base);
-  const recentFailure = cloneFailure(createAutoExposureError(input.recentFailure));
-  if (recentFailure === void 0) return Object.freeze(base);
-  return Object.freeze({ ...base, recentFailure });
-}
-
-// src/errors/render.ts
-var LifecycleConstructionError = class extends Error {
-  code = "lifecycle-construction-failed";
-  expected = "all DeviceScope resources establish and terminate in order";
-  hint = "inspect detail and cleanupFailures, then recover or rebuild the DeviceScope";
-  detail;
-  constructor(detail) {
-    super(`lifecycle-construction-failed: ${detail.resourceKind} lifecycle transaction failed`);
-    this.name = "LifecycleConstructionError";
-    this.detail = detail;
-  }
-};
-var LightResourceUnavailableError = class extends Error {
-  code = "light-resource-unavailable";
-  expected;
-  hint;
-  detail;
-  constructor(detail, expected, actual, hint) {
-    super(`light-resource-unavailable: ${detail.feature} ${actual}`);
-    this.name = "LightResourceUnavailableError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = detail;
-  }
-};
-function createLightResourceUnavailable(input) {
-  return new LightResourceUnavailableError(
-    {
-      entity: input.entity,
-      feature: input.feature,
-      generation: input.generation,
-      sourceKey: input.sourceKey,
-      reason: input.reason
-    },
-    input.expected,
-    input.actual,
-    input.hint
-  );
-}
-var TemporalFrameSubmitError = class extends Error {
-  code = "temporal-frame-submit-rejected";
-  expected = "the staged frame is accepted by queue.submit before temporal facts advance";
-  hint = "inspect the queue submission and retry the frame after the device is available";
-  detail;
-  constructor(reason) {
-    super(`temporal-frame-submit-rejected: ${reason}`);
-    this.name = "TemporalFrameSubmitError";
-    this.detail = { reason };
-  }
-};
-var ShadowInvalidConfigError = class extends Error {
-  code = "shadow-invalid-config";
-  expected;
-  hint;
-  detail;
-  constructor(field, actual, minOrBound, maxOrComparator, reason) {
-    const bound = typeof minOrBound === "number" ? typeof maxOrComparator === "number" ? { kind: "range", min: minOrBound, max: maxOrComparator } : {
-      kind: "lower-bound",
-      operator: maxOrComparator === ">" ? ">" : ">=",
-      value: minOrBound
-    } : minOrBound;
-    const resolvedReason = reason ?? shadowBoundReason(bound);
-    const expected = shadowBoundExpected(field, bound);
-    const hint = `set ${field} to ${resolvedReason}; got ${actual}`;
-    super(`shadow component .${field} is invalid: ${resolvedReason}; got ${actual}`);
-    this.name = "ShadowInvalidConfigError";
-    this.hint = hint;
-    this.expected = expected;
-    this.detail = { field, actual, bound, reason: resolvedReason };
-  }
-};
-function shadowBoundExpected(field, bound) {
-  switch (bound.kind) {
-    case "range":
-      return `${field} in [${bound.min}, ${bound.max}]`;
-    case "lower-bound":
-      return `${field} ${bound.operator} ${bound.value}`;
-    case "allowed-values":
-      return `${field} in {${bound.values.join(", ")}}`;
-  }
-}
-function shadowBoundReason(bound) {
-  switch (bound.kind) {
-    case "range":
-      return `a value in [${bound.min}, ${bound.max}]`;
-    case "lower-bound":
-      return `a value ${bound.operator} ${bound.value}`;
-    case "allowed-values":
-      return `one of [${bound.values.join(", ")}]`;
-  }
-}
-var EquirectProjectionFailedError = class extends Error {
-  code = "equirect-projection-failed";
-  expected;
-  hint;
-  detail;
-  constructor(handle) {
-    const expected = `equirect handle ${handle} projects to a GPU cubemap + IBL precompute`;
-    const hint = `equirect handle ${handle} referenced by Skylight/SkyboxBackground failed projection; declare Skylight{equirect} with a valid HDR equirect source and check device.caps.rgba16floatRenderable. The projection is internal (no user upload call); the record arm does not retry`;
-    super(`equirect handle ${handle} cubemap projection failed`);
-    this.name = "EquirectProjectionFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { handle };
-  }
-};
-var StandardLightBudgetExceededError = class extends Error {
-  code = "standard-light-budget-exceeded";
-  expected;
-  hint;
-  detail;
-  constructor(actual, budget) {
-    const expected = `light count <= ${budget}`;
-    const hint = `${actual} finite local lights exceed Standard budget ${budget}; reduce the local-light set or select a profile with a supported budget`;
-    super(`Standard light budget exceeded: ${actual} > ${budget}`);
-    this.name = "StandardLightBudgetExceededError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { actual, budget };
-  }
-};
-var StandardClusterIndexOverflowError = class extends Error {
-  code = "standard-cluster-index-overflow";
-  expected;
-  hint;
-  detail;
-  constructor(actual, capacity) {
-    const expected = `light index list entries <= ${capacity}`;
-    const hint = `cluster binner overflow: writeCount ${actual} exceeds capacity ${capacity}; reduce finite local lights or choose a supported cluster layout`;
-    super(`Standard cluster index list overflow: ${actual} > ${capacity}`);
-    this.name = "StandardClusterIndexOverflowError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { actual, capacity };
-  }
-};
-var StandardClusterTransportUnavailableError = class extends Error {
-  code = "standard-cluster-transport-unavailable";
-  expected = "all requested local lights have a proven Cluster transport";
-  hint;
-  detail;
-  constructor(requested, hint = "enable a proven Cluster storage transport before drawing") {
-    super(`Standard Cluster transport unavailable for ${requested} local lights`);
-    this.name = "StandardClusterTransportUnavailableError";
-    this.hint = hint;
-    this.detail = { requested, admitted: 0 };
-  }
-};
-var StandardProfileInvalidError = class extends Error {
-  code = "standard-profile-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(message, detail) {
-    super(message);
-    this.name = "StandardProfileInvalidError";
-    this.detail = detail ?? { field: "profile", actual: message };
-    if (this.detail.field === "clusterGrid") {
-      this.expected = "clusterGrid.{x,y,z} each positive integer in [1, 64]";
-      this.hint = "set clusterGrid.x, clusterGrid.y, and clusterGrid.z to positive integers in [1, 64]";
-    } else {
-      this.expected = "StandardProfile contains only supported fields and values";
-      this.hint = "repair the Standard profile fields and retry setProfile";
-    }
-  }
-};
-var PointShadowAtlasUninitializedError = class extends Error {
-  code = "point-shadow-atlas-uninitialized";
-  expected;
-  hint;
-  constructor() {
-    const expected = "ShadowAtlas.ensure() invoked before faceView()";
-    const hint = "Gate faceView on isAllocated() or call ensure() once in the per-frame extract step before iterating face views";
-    super("ShadowAtlas.faceView called before ensure(); the cube_array texture is not allocated");
-    this.name = "PointShadowAtlasUninitializedError";
-    this.expected = expected;
-    this.hint = hint;
-  }
-};
-var PointShadowAtlasBoundsViolationError = class extends Error {
-  code = "point-shadow-atlas-bounds-violation";
-  expected;
-  hint;
-  detail;
-  constructor(axis, value, max) {
-    const expected = `0 <= ${axis} < ${max}`;
-    const hint = axis === "layer" ? `clamp PointLight.shadowAtlasLayer to [0, ${max}); the cap on layers equals PointLightShadow cardinality (4)` : `clamp face index to [0, ${max}); cube faces are indexed 0..5 in +X/-X/+Y/-Y/+Z/-Z order`;
-    super(`ShadowAtlas.faceView ${axis} out of range: ${value} (must be in [0, ${max}))`);
-    this.name = "PointShadowAtlasBoundsViolationError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { axis, value, max };
-  }
-};
-var VideoUploadUnsupportedError = class extends Error {
-  code = "video-upload-unsupported";
-  expected;
-  hint;
-  constructor() {
-    const expected = "at least one video upload path available: a host HTMLVideoElement (general copyExternalImageToTexture path) or GPUExternalTexture capability (high-perf path)";
-    const hint = "this backend exposes no usable video upload path; render a static texture instead, or switch to a WebGPU backend that supports video texture upload";
-    super("video upload unsupported \u2014 no general or high-perf path available");
-    this.name = "VideoUploadUnsupportedError";
-    this.expected = expected;
-    this.hint = hint;
-  }
-};
-var VertexColorVariantConflictError = class extends Error {
-  code = "vertex-color-variant-conflict";
-  expected;
-  hint;
-  detail;
-  constructor(authoredValue, projected) {
-    const expected = `VERTEX_COLOR_AVAILABLE=${projected ? "true" : "false"}`;
-    const hint = "derive the shader variant from the mesh VertexLayoutProjection; COLOR_0 presence is a geometry fact";
-    super(`authored vertex-color variant ${authoredValue} disagrees with projected ${expected}`);
-    this.name = "VertexColorVariantConflictError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { authored: true, authoredValue, projected };
-  }
-};
-var SkinPaletteOverflowError = class extends Error {
-  code = "skin-palette-overflow";
-  expected;
-  hint;
-  detail;
-  constructor(requestedBytes, limit) {
-    const expected = `skinned joint palette (${requestedBytes} B) fits within device.limits.maxStorageBufferBindingSize (${limit} B)`;
-    const hint = "palette buffer exceeds device maxStorageBufferBindingSize; reduce skinned entity count or split into multiple palette buffers (OOS-skin-palette-batch)";
-    super(`skin palette buffer needs ${requestedBytes} B, exceeds device limit ${limit} B`);
-    this.name = "SkinPaletteOverflowError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { requestedBytes, limit };
-  }
-};
-var SkinMaterialMismatchError = class extends Error {
-  code = "skin-material-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(entity, actualShader) {
-    const expected = "Skin entity's first material program module === 'forgeax::pbr-skin'";
-    const hint = `entity ${entity} has Skin but the first material program module is ${actualShader ?? "<empty>"}; load the mesh via the gltf importer (cooker auto-routes 'forgeax::pbr-skin' for skinned primitives), or remove the Skin component to render the entity unskinned with Materials.standard / Materials.unlit`;
-    super(
-      `Skin / material mismatch on entity ${entity}: expected forgeax::pbr-skin, got ${actualShader ?? "<empty>"}`
-    );
-    this.name = "SkinMaterialMismatchError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { entity, actualShader };
-  }
-};
-var MaterialSkinAttrMissingError = class extends Error {
-  code = "material-skin-attr-missing";
-  expected;
-  hint;
-  detail;
-  constructor(entity, missing2) {
-    const expected = "pbr-skin material requires mesh.attributes.skinIndex + skinWeight";
-    const hint = `entity ${entity} uses forgeax::pbr-skin but its MeshAsset is missing ${missing2}; switch the entity to a skinned glTF mesh authored with JOINTS_0 + WEIGHTS_0, or change the material to a non-skin shader via Materials.standard / Materials.unlit`;
-    super(
-      `material/skin attribute mismatch on entity ${entity}: pbr-skin material with mesh missing ${missing2}`
-    );
-    this.name = "MaterialSkinAttrMissingError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { entity, missing: missing2 };
-  }
-};
-var TransmissionCapabilityMissingError = class extends Error {
-  code = "transmission-capability-missing";
-  expected = "the renderer exposes the transmission capability for this material";
-  hint = "disable transmission or provide the renderer capability before drawing";
-  detail;
-  constructor(material, stage, evidence) {
-    super(`transmission capability is missing for material '${material}'`);
-    this.name = "TransmissionCapabilityMissingError";
-    this.detail = { material, capability: "transmission", stage, ...evidence };
-  }
-};
-var renderFeatureRecoveryHintByRecovery = {
-  "next-frame": (featureIdentity, stage) => `correct '${featureIdentity}' ${stage} data and retry on the next frame`,
-  "renderer-recover": (featureIdentity, _stage) => `wait for renderer recovery before retrying '${featureIdentity}'`,
-  registration: (featureIdentity, _stage) => `correct '${featureIdentity}' registration before retrying`
-};
-var RenderFeatureRegistrationConflictError = class extends Error {
-  code = "render-feature-registration-conflict";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, conflictingOrder) {
-    const expected = `feature identity '${featureIdentity}' is unique`;
-    const hint = `rename '${featureIdentity}' or remove the duplicate feature before registration`;
-    super(`render feature registration conflict for '${featureIdentity}'`);
-    this.name = "RenderFeatureRegistrationConflictError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, conflictingOrder };
-  }
-};
-var RenderFeatureStageFailedError = class extends Error {
-  code = "render-feature-stage-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, stage, recovery, cause) {
-    const expected = `feature '${featureIdentity}' completes its ${stage} stage without an error`;
-    const hint = renderFeatureRecoveryHintByRecovery[recovery](featureIdentity, stage);
-    super(`render feature '${featureIdentity}' failed during ${stage}`);
-    this.name = "RenderFeatureStageFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = {
-      featureIdentity,
-      order,
-      stage,
-      recovery,
-      ...cause === void 0 ? {} : { cause }
-    };
-  }
-};
-var RenderFeatureCapabilityMissingError = class extends Error {
-  code = "render-feature-capability-missing";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, capability) {
-    const expected = `device capability '${capability}' is available for feature '${featureIdentity}'`;
-    const hint = `disable '${featureIdentity}' or use a device with '${capability}' capability`;
-    super(`render feature '${featureIdentity}' requires missing capability '${capability}'`);
-    this.name = "RenderFeatureCapabilityMissingError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, capability };
-  }
-};
-var RenderFeaturePreparationFailedError = class extends Error {
-  code = "render-feature-preparation-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, operation, resourceKind, resourceName, reason, recovery) {
-    const expected = `${resourceKind} '${resourceName}' is prepared during ${operation}`;
-    const hint = `repair '${resourceName}' and retry feature '${featureIdentity}' on ${recovery}`;
-    super(`render feature '${featureIdentity}' preparation failed for '${resourceName}'`);
-    this.name = "RenderFeaturePreparationFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = {
-      featureIdentity,
-      order,
-      stage: "prepare",
-      operation,
-      resourceKind,
-      resourceName,
-      reason,
-      recovery
-    };
-  }
-};
-var RenderFeaturePreparedStateMismatchError = class extends Error {
-  code = "render-feature-prepared-state-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    const expected = `${detail.resourceKind} state is compatible for '${detail.operation}'`;
-    const hint = `repair '${detail.reason}' for feature '${detail.featureIdentity}' and retry`;
-    super(`render feature '${detail.featureIdentity}' prepared state mismatch`);
-    this.name = "RenderFeaturePreparedStateMismatchError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = detail;
-  }
-};
-var RenderFeatureDrawRecordingFailedError = class extends Error {
-  code = "render-feature-draw-recording-failed";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, operation, resourceKind, reason, backendReason, recovery) {
-    const expected = `${resourceKind} recording succeeds for '${operation}'`;
-    const hint = `repair '${reason}' and retry feature '${featureIdentity}' after ${recovery}`;
-    super(`render feature '${featureIdentity}' draw recording failed`);
-    this.name = "RenderFeatureDrawRecordingFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = {
-      featureIdentity,
-      order,
-      stage: "record",
-      operation,
-      resourceKind,
-      reason,
-      backendReason,
-      recovery
-    };
-  }
-};
-var ObservationUnavailableError = class extends Error {
-  code = "observation-unavailable";
-  expected;
-  hint;
-  detail;
-  constructor(reason, hint) {
-    let recovery;
-    if (reason === "copy-src") recovery = "enable-copy-src";
-    else if (reason === "resource" || reason === "readback-failed") recovery = "retry-readback";
-    else recovery = "draw-current-frame";
-    super(`current-frame observation unavailable: ${reason}`);
-    this.name = "ObservationUnavailableError";
-    this.expected = "a fresh producer-owned rgba16float current-frame observation";
-    this.hint = hint;
-    this.detail = { reason, recovery };
-  }
-};
-var SceneDataUnavailableError = class extends Error {
-  code = "scene-data-unavailable";
-  expected = "the requested semantic scene data is available for the active plan";
-  hint;
-  detail;
-  constructor(detail) {
-    const hint = detail.recovery === "enable-capability" ? "enable rgba16floatRenderable and retry the current frame" : detail.recovery === "renderer-recover" ? "wait for renderer recovery, then retry the frame" : "restore the producer coverage and retry on the next frame";
-    super(`scene data '${detail.schema}' unavailable for '${detail.featureIdentity}'`);
-    this.name = "SceneDataUnavailableError";
-    this.hint = hint;
-    this.detail = Object.freeze({
-      ...detail,
-      missingContributorIds: Object.freeze([...detail.missingContributorIds].slice(0, 32)),
-      omittedMissingContributorCount: Math.max(
-        detail.omittedMissingContributorCount,
-        Math.max(0, detail.missingContributorIds.length - 32)
-      )
-    });
-  }
-};
-var FrameReceiptStaleError = class extends Error {
-  code = "frame-receipt-stale";
-  expected = "the observation receipt belongs to the active device generation";
-  hint = "draw a new frame and call observe with its returned FrameReceipt";
-  detail;
-  constructor(detail) {
-    super("frame receipt belongs to a retired device generation");
-    this.name = "FrameReceiptStaleError";
-    this.detail = detail;
-  }
-};
-var RendererContractFailureError = class extends Error {
-  code = "renderer-contract-failed";
-  expected = "renderer owner contracts remain valid at the public boundary";
-  hint = "repair the owner contract and retry the operation";
-  detail;
-  constructor(operation, cause) {
-    super(`renderer ${operation} contract failed: ${cause}`);
-    this.name = "RendererContractFailureError";
-    this.detail = { operation, cause };
-  }
-};
-var EnvironmentSourceConflictError = class extends Error {
-  code = "environment-source-conflict";
-  expected = "exactly one environment source owns the frame";
-  hint = "remove all but one image or atmosphere environment owner";
-  detail;
-  constructor(owners) {
-    super("environment source owners conflict");
-    this.name = "EnvironmentSourceConflictError";
-    this.detail = { owners: owners.map((owner) => Object.freeze({ ...owner })) };
-  }
-};
-var FogCardinalityError = class extends Error {
-  code = "fog-cardinality";
-  expected = "zero or one Fog owner contributes to a frame";
-  hint = "remove extra Fog owners so the resource owner has at most one";
-  detail;
-  constructor(count) {
-    super(`Fog owner cardinality is ${count}`);
-    this.name = "FogCardinalityError";
-    this.detail = { count };
-  }
-};
-var TaaCapsInsufficientError = class extends Error {
-  code = "taa-caps-insufficient";
-  expected = "the backend exposes the capabilities required by TAA";
-  hint = "select a backend with the required TAA capabilities or disable TAA on Camera";
-  detail;
-  constructor(required, available) {
-    super("TAA capabilities are insufficient");
-    this.name = "TaaCapsInsufficientError";
-    this.detail = { required: [...required], available: [...available] };
-  }
-};
-var EnvironmentGenerationFailedError = class extends Error {
-  code = "environment-generation-failed";
-  expected = "the selected environment generation completes its owner stage";
-  hint = "inspect the stage and sourceKey, then retry after correcting the environment";
-  detail;
-  constructor(sourceKey, stage) {
-    super(`environment generation failed during ${stage}`);
-    this.name = "EnvironmentGenerationFailedError";
-    this.detail = { sourceKey, stage };
-  }
-};
-var AtmosphereInvalidParameterError = class extends Error {
-  code = "atmosphere-invalid-parameter";
-  expected;
-  hint;
-  detail;
-  constructor(field, value, range) {
-    super(`Atmosphere.${field} is invalid`);
-    this.name = "AtmosphereInvalidParameterError";
-    this.detail = { field, value };
-    const rangeText = Number.isFinite(range.max) ? `[${range.min}, ${range.max}]` : `>= ${range.min}`;
-    this.expected = `Atmosphere.${field} must be finite and ${rangeText}`;
-    this.hint = `set Atmosphere.${field} to a finite value ${rangeText}`;
-  }
-};
-var DynamicResolutionInvalidParameterError = class extends Error {
-  code = "dynamic-resolution-invalid-parameter";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`DynamicResolution.${detail.field} is invalid`);
-    this.name = "DynamicResolutionInvalidParameterError";
-    this.expected = `DynamicResolution.${detail.field} must be ${detail.expected}`;
-    this.hint = `set DynamicResolution.${detail.field} to a value that is ${detail.expected}`;
-    this.detail = detail;
-  }
-};
-var DynamicResolutionRequiresTaaError = class extends Error {
-  code = "dynamic-resolution-requires-taa";
-  expected = "DynamicResolution requires Camera.antialias to be 'taa'";
-  hint = "set Camera.antialias to 'taa' or remove DynamicResolution before retrying";
-  detail;
-  constructor(detail) {
-    super("DynamicResolution requires TAA");
-    this.name = "DynamicResolutionRequiresTaaError";
-    this.detail = detail;
-  }
-};
-var DynamicResolutionTimingUnavailableError = class extends Error {
-  code = "dynamic-resolution-timing-unavailable";
-  expected = "adaptive resolution receives a completed GPU timing sample";
-  hint = "use fixed minScale=maxScale or retry after timestamp support is available";
-  detail;
-  constructor(detail) {
-    super(`DynamicResolution timing is unavailable for generation ${detail.generation}`);
-    this.name = "DynamicResolutionTimingUnavailableError";
-    this.detail = detail;
-  }
-};
-var OwnerStageFailedError = class extends Error {
-  code = "owner-stage-failed";
-  expected = "the owner completes its current frame stage";
-  hint = "inspect the owner and stage, keep the last-known-good frame, and retry";
-  detail;
-  constructor(owner, stage) {
-    super(`${owner} owner failed during ${stage}`);
-    this.name = "OwnerStageFailedError";
-    this.detail = { owner, stage };
-  }
-};
-var RENDERER_OPERATION_ERROR_POLICY = {
-  "world-lease-invalid": {
-    expected: "every render World is represented by a live lease owned by this Renderer",
-    hint: "attach the World to this Renderer and use the returned lease"
-  },
-  "frame-input-invalid": {
-    expected: "the frame input references attached leases and a valid immutable RenderProfile",
-    hint: "repair the frame input and retry draw or setProfile"
-  },
-  "scene-projection-failed": {
-    expected: "the attached World projects into the renderer-owned RenderScene",
-    hint: "inspect the structured cause, repair the World publication, and retry draw"
-  },
-  "asset-binding-failed": {
-    expected: "all frame assets resolve to valid renderer-owned bindings",
-    hint: "inspect the structured cause, rebuild or cold-cook the asset, and retry draw"
-  },
-  "feature-plan-failed": {
-    expected: "every installed RenderFeature produces a valid declarative plan",
-    hint: "inspect the feature cause, repair its plan, and retry draw"
-  },
-  "graph-build-failed": {
-    expected: "the Standard graph builds from the active profile and feature plans",
-    hint: "inspect the graph cause, repair the profile or plan, and retry"
-  },
-  "device-operation-failed": {
-    expected: "the active device generation completes the renderer-owned operation",
-    hint: "inspect renderer state and the structured cause, then retry or recover"
-  },
-  "surface-unavailable": {
-    expected: "the presentation surface accepts the requested lifecycle operation",
-    hint: "inspect renderer state, then restore the surface or create a new Renderer"
-  },
-  "renderer-state-invalid": {
-    expected: "the Renderer is in a state that accepts the requested operation",
-    hint: "inspect renderer state and choose retry, restoreSurface, recover, or stop"
-  },
-  "recovery-failed": {
-    expected: "one recovery attempt publishes a complete replacement device generation",
-    hint: "inspect the structured cause and retry recover after the host-selected delay"
-  },
-  "cleanup-failed": {
-    expected: "Renderer disposal completes every registered cleanup in reverse ownership order",
-    hint: "inspect the ordered cleanup causes; the Renderer remains disposed and must not be reused"
-  }
-};
-var RendererOperationError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(code, detail) {
-    const policy = RENDERER_OPERATION_ERROR_POLICY[code];
-    super(`${code}: ${policy.expected}`);
-    this.name = "RendererOperationError";
-    this.code = code;
-    this.expected = policy.expected;
-    this.hint = policy.hint;
-    this.detail = detail;
-  }
-};
-var PointsLinesInvalidStyleError = class extends Error {
-  code = "points-lines-invalid-style";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`invalid ${detail.component} style at ${detail.field}`);
-    this.name = "PointsLinesInvalidStyleError";
-    this.expected = detail.expected;
-    this.hint = `repair entity ${detail.entity} ${detail.component}.${detail.field} and retry admission`;
-    this.detail = detail;
-  }
-};
-var PointsLinesTopologyMismatchError = class extends Error {
-  code = "points-lines-topology-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`Points/Lines topology mismatch at submesh ${detail.submesh}`);
-    this.name = "PointsLinesTopologyMismatchError";
-    this.expected = `submesh ${detail.submesh} topology is ${detail.expected}`;
-    this.hint = `rebuild entity ${detail.entity} with ${detail.expected} geometry before retrying Points/Lines admission`;
-    this.detail = detail;
-  }
-};
-var PointsLinesStyleUnsupportedError = class extends Error {
-  code = "points-lines-style-unsupported";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`unsupported Points/Lines ${detail.field} member ${detail.member}`);
-    this.name = "PointsLinesStyleUnsupportedError";
-    this.expected = `${detail.field} is one of ${detail.supported.join(", ")}`;
-    this.hint = `use a supported Points/Lines ${detail.field} member or wait for a later milestone`;
-    this.detail = detail;
-  }
-};
-var PointsLinesMaterialUnsupportedError = class extends Error {
-  code = "points-lines-material-unsupported";
-  expected = "one engine-owned unlit forward MaterialAsset pass";
-  hint;
-  detail;
-  constructor(detail) {
-    super(`Points/Lines material is unsupported on entity ${detail.entity}`);
-    this.name = "PointsLinesMaterialUnsupportedError";
-    this.hint = `use Materials.unlit without a shadow-caster pass for entity ${detail.entity}`;
-    this.detail = detail;
-  }
-};
-var PointsLinesBudgetExceededError = class extends Error {
-  code = "points-lines-budget-exceeded";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`Points/Lines ${detail.unit} budget exceeded`);
-    this.name = "PointsLinesBudgetExceededError";
-    this.expected = `${detail.unit} <= ${detail.limit}`;
-    this.hint = `reduce Points/Lines ${detail.unit} or split the entity into bounded equivalent batches`;
-    this.detail = detail;
-  }
-};
-var PointsLinesPrepareFailedError = class extends Error {
-  code = "points-lines-prepare-failed";
-  expected = "the complete Points/Lines candidate validates before publication";
-  hint;
-  detail;
-  constructor(detail) {
-    super(`Points/Lines prepare failed at generation ${detail.generation}`);
-    this.name = "PointsLinesPrepareFailedError";
-    this.hint = detail.lastKnownGood ? "retain the last known good candidate, repair the producer, and retry prepare" : "repair the producer and retry prepare; the failed first candidate produces zero draw";
-    this.detail = detail;
-  }
-};
-var RenderTargetDescriptorInvalidError = class extends Error {
-  code = "render-target-descriptor-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`render-target-descriptor-invalid: ${detail.field} does not satisfy ${detail.expected}`);
-    this.name = "RenderTargetDescriptorInvalidError";
-    this.expected = detail.expected;
-    this.hint = `set RenderTargetDescriptor.${detail.field} to the expected value, then retry create or resize`;
-    this.detail = detail;
-  }
-};
-var RenderTargetCapabilityMissingError = class extends Error {
-  code = "render-target-capability-missing";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(
-      `render-target-capability-missing: ${detail.capability} does not admit ${detail.requested}`
-    );
-    this.name = "RenderTargetCapabilityMissingError";
-    this.expected = `${detail.capability} admits ${detail.requested}`;
-    this.hint = `choose an admitted target descriptor or use a backend providing ${detail.capability}`;
-    this.detail = detail;
-  }
-};
-var RenderTargetStateInvalidError = class extends Error {
-  code = "render-target-state-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`render-target-state-invalid: ${detail.operation} cannot use ${detail.reason}`);
-    this.name = "RenderTargetStateInvalidError";
-    this.expected = `target state permits ${detail.operation}`;
-    this.hint = "use the Renderer that created the target, then initialize, recover, or stop using the destroyed token";
-    this.detail = detail;
-  }
-};
-var RenderTargetOperationFailedError = class extends Error {
-  code = "render-target-operation-failed";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    super(`render-target-operation-failed: ${detail.operation} failed during ${detail.stage}`);
-    this.name = "RenderTargetOperationFailedError";
-    this.expected = `${detail.operation} completes ${detail.stage}`;
-    this.hint = "inspect detail.cause, then retry, recover the Renderer, or retain the last-known-good generation";
-    this.detail = detail;
-  }
-};
-var RenderIntentInvalidError = class extends Error {
-  code = "render-intent-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(component, value) {
-    super(`render-intent-invalid: ${component}.updateIntent is not an admitted value`);
-    this.name = "RenderIntentInvalidError";
-    this.expected = `${component}.updateIntent is one of 0, 1, or 2`;
-    this.hint = `set ${component}.updateIntent to 0, 1, or 2`;
-    this.detail = { component, field: "updateIntent", value, allowed: [0, 1, 2] };
-  }
-};
-var VolumeOwnerConflictError = class extends Error {
-  code = "volume-owner-conflict";
-  expected = "exactly one global VolumetricFog owner is authored";
-  hint = "remove additional VolumetricFog owners and retry extraction";
-  detail;
-  constructor(ownerCount) {
-    super(`volume-owner-conflict: received ${ownerCount} owners`);
-    this.name = "VolumeOwnerConflictError";
-    this.detail = { ownerCount };
-  }
-};
-var VolumeDensityShapeMismatchError = class extends Error {
-  code = "volume-density-shape-mismatch";
-  expected = "density is a linear 3D TextureAsset";
-  hint = "bind a verified linear texture with viewDimension 3d";
-  detail;
-  constructor(guid, viewDimension) {
-    super(`volume-density-shape-mismatch: ${viewDimension} density is not 3d`);
-    this.name = "VolumeDensityShapeMismatchError";
-    this.detail = { guid, viewDimension };
-  }
-};
-var VolumeInvalidBoundsError = class extends Error {
-  code = "volume-invalid-bounds";
-  expected = "bounds are finite and max is greater than min on every axis";
-  hint = "set finite non-degenerate volume bounds";
-  detail;
-  constructor(bounds) {
-    super("volume-invalid-bounds: bounds must be finite and non-degenerate");
-    this.name = "VolumeInvalidBoundsError";
-    this.detail = bounds;
-  }
-};
-var VolumeInvalidParametersError = class extends Error {
-  code = "volume-invalid-parameters";
-  expected = "volume parameters remain finite and inside their closed ranges";
-  hint = "repair extinction, albedo, emission, anisotropy, or maxDistance";
-  detail;
-  constructor(input) {
-    const field = input.maxDistance !== void 0 && input.maxDistance <= 0 ? "maxDistance" : "parameters";
-    const value = field === "maxDistance" ? input.maxDistance : input.anisotropy;
-    super(`volume-invalid-parameters: ${field} is outside the authored range`);
-    this.name = "VolumeInvalidParametersError";
-    this.detail = { field, value };
-  }
-};
-var MOTION_BLUR_PARAMS_BYTE_SIZE = 32;
-var DEFAULT_MOTION_BLUR_PARAMS = Object.freeze({
-  shutterAngle: 180,
-  maxRadiusPixels: 32,
-  sampleCount: 8,
-  targetFps: 60
-});
-var MotionBlurValidationError = class extends Error {
-  code = "motion-blur-invalid-params";
-  expected;
-  hint;
-  detail;
-  constructor(detail) {
-    const integer = detail.integer === true ? "integer " : "";
-    const expected = `${detail.field} ${integer}in [${detail.min}, ${detail.max}]`;
-    super(`motion-blur-invalid-params: ${expected}`);
-    this.name = "MotionBlurValidationError";
-    this.expected = expected;
-    this.hint = `set ${detail.field} to an ${integer}value in [${detail.min}, ${detail.max}]`;
-    this.detail = detail;
-  }
-};
-function validateField(field, value, min, max, integer = false) {
-  if (!Number.isFinite(value) || value < min || value > max || integer && !Number.isInteger(value)) {
-    return new MotionBlurValidationError({
-      field,
-      value,
-      min,
-      max,
-      ...integer ? { integer } : {}
-    });
-  }
-  return void 0;
-}
-function validateMotionBlurParams(input) {
-  const value = input ?? {};
-  const shutterAngle = value.shutterAngle ?? DEFAULT_MOTION_BLUR_PARAMS.shutterAngle;
-  const maxRadiusPixels = value.maxRadiusPixels ?? DEFAULT_MOTION_BLUR_PARAMS.maxRadiusPixels;
-  const sampleCount = value.sampleCount ?? DEFAULT_MOTION_BLUR_PARAMS.sampleCount;
-  const targetFps = value.targetFps ?? DEFAULT_MOTION_BLUR_PARAMS.targetFps;
-  const shutterError = validateField("shutterAngle", shutterAngle, 0, 360);
-  if (shutterError !== void 0) return err(shutterError);
-  const radiusError = validateField("maxRadiusPixels", maxRadiusPixels, 0, 64);
-  if (radiusError !== void 0) return err(radiusError);
-  const sampleError = validateField("sampleCount", sampleCount, 4, 16, true);
-  if (sampleError !== void 0) return err(sampleError);
-  const targetFpsError = validateField("targetFps", targetFps, 0, 240, true);
-  if (targetFpsError !== void 0) return err(targetFpsError);
-  return ok(Object.freeze({ shutterAngle, maxRadiusPixels, sampleCount, targetFps }));
-}
-function motionBlurTemporalDemand(params) {
-  return params !== void 0 && params.shutterAngle > 0 && params.maxRadiusPixels > 0;
-}
-function effectiveMotionBlurSampleCount(sampleCount) {
-  if (!Number.isFinite(sampleCount) || sampleCount < 4) return 0;
-  if (sampleCount < 8) return 4;
-  if (sampleCount < 16) return 8;
-  return 16;
-}
-function isMotionBlurIntervalValid(frameDeltaSeconds) {
-  return Number.isFinite(frameDeltaSeconds) && frameDeltaSeconds > 0 && frameDeltaSeconds <= 0.1;
-}
-function motionBlurExposureScale(frameDeltaSeconds, targetFps) {
-  if (!isMotionBlurIntervalValid(frameDeltaSeconds)) return 0;
-  if (!Number.isFinite(targetFps) || targetFps < 0 || targetFps > 240 || !Number.isInteger(targetFps)) {
-    return 0;
-  }
-  if (targetFps === 0) return 1;
-  return 1 / (targetFps * frameDeltaSeconds);
-}
-function motionBlurSampleDelta(sampleTimeSeconds, previousSampleTimeSeconds, fallbackDeltaSeconds) {
-  if (sampleTimeSeconds !== void 0 && !Number.isFinite(sampleTimeSeconds) || previousSampleTimeSeconds !== void 0 && !Number.isFinite(previousSampleTimeSeconds)) {
-    return Number.NaN;
-  }
-  if (Number.isFinite(sampleTimeSeconds) && Number.isFinite(previousSampleTimeSeconds)) {
-    return sampleTimeSeconds - previousSampleTimeSeconds;
-  }
-  return fallbackDeltaSeconds;
-}
-function resolveMotionBlurParams(input) {
-  if (input === void 0) return ok(void 0);
-  return validateMotionBlurParams(input);
-}
-
-// src/gpu-texture-usage.ts
-var GPU_TEXTURE_USAGE_COPY_SRC = 1;
-var GPU_TEXTURE_USAGE_COPY_DST = 2;
-var GPU_TEXTURE_USAGE_TEXTURE_BINDING = 4;
-var GPU_TEXTURE_USAGE_STORAGE_BINDING = 8;
-var GPU_TEXTURE_USAGE_RENDER_ATTACHMENT = 16;
-var GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING = GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | GPU_TEXTURE_USAGE_TEXTURE_BINDING;
-
-// src/shadow-atlas.ts
-var SHADOW_ATLAS_DEFAULT_FACE_SIZE = 512;
-var SHADOW_ATLAS_DEFAULT_LAYERS = 4;
-var ShadowAtlas = class {
-  /** Backing cube_array depth texture. `null` until `ensure()` has run. */
-  texture = null;
-  /**
-   * Whole-atlas cube_array sampling view used by URP shaders that bind the
-   * atlas at `@group(0) @binding(5)`. `null` until `ensure()` has run.
-   */
-  cubeArrayView = null;
-  /** Comparison sampler for `texture_depth_cube_array`. */
-  compareSampler = null;
-  /** Per-face 2D depth view cache, keyed by `layer * 6 + face`. */
-  faceViews = /* @__PURE__ */ new Map();
-  /** Per-face label cache (debug aid). Reused on re-creation. */
-  device;
-  /** Per-face square size in pixels. */
-  faceSize;
-  /** Cube layer count. */
-  layers;
-  constructor(device, options = {}) {
-    this.device = device;
-    this.faceSize = options.faceSize ?? SHADOW_ATLAS_DEFAULT_FACE_SIZE;
-    this.layers = options.layers ?? SHADOW_ATLAS_DEFAULT_LAYERS;
-  }
-  /**
-   * Returns `true` once the atlas texture is allocated. Used by the extract /
-   * record path to gate "no PointLightShadow → no allocation" (AC-09) — the
-   * caller calls {@link ensure} on a frame that has at least one snapshot;
-   * before that, `isAllocated()` stays `false` and tests can assert no GPU
-   * resources were created.
-   */
-  isAllocated() {
-    return this.texture !== null;
-  }
-  /**
-   * Lazy-allocate the atlas texture + cube_array sampling view + comparison
-   * sampler. Idempotent: subsequent calls are zero-cost no-ops once the
-   * resources exist.
-   *
-   * Throws (via the RHI error registry) on allocation failure. This is the
-   * only path that touches the GPU — keeping it inside one method makes the
-   * "zero-shadow scene = zero allocation" gate easy to enforce: the renderer
-   * never calls this method on a frame with no PointLightShadow entities.
-   */
-  ensure() {
-    if (this.texture !== null) return;
-    const usage = GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING;
-    const texDesc = cubeArrayDepthDescriptor(this.faceSize, this.layers, usage);
-    const texRes = this.device.createTexture(texDesc);
-    if (!texRes.ok) throw texRes.error;
-    this.texture = texRes.value;
-    const viewRes = this.device.createTextureView(this.texture, {
-      label: "shadow-atlas-cube-array-view",
-      dimension: "cube-array",
-      aspect: "depth-only",
-      baseArrayLayer: 0,
-      arrayLayerCount: 6 * this.layers,
-      baseMipLevel: 0,
-      mipLevelCount: 1
-    });
-    if (!viewRes.ok) {
-      this.device.destroyTexture(this.texture);
-      this.texture = null;
-      throw viewRes.error;
-    }
-    this.cubeArrayView = viewRes.value;
-    const sampRes = this.device.createSampler(comparisonSamplerDescriptor());
-    if (!sampRes.ok) {
-      this.device.destroyTexture(this.texture);
-      this.texture = null;
-      this.cubeArrayView = null;
-      throw sampRes.error;
-    }
-    this.compareSampler = sampRes.value;
-  }
-  /**
-   * Whole-atlas cube_array sampling view (`texture_depth_cube_array`). Returns
-   * `null` if the atlas is not yet allocated; the caller should gate on a
-   * non-null pointShadow array before calling {@link ensure} + this getter.
-   */
-  getAtlasView() {
-    return this.cubeArrayView;
-  }
-  /**
-   * Comparison sampler (`compare: 'less'`) for cube_array depth sampling.
-   * Returns `null` if the atlas is not yet allocated.
-   */
-  getComparisonSampler() {
-    return this.compareSampler;
-  }
-  /**
-   * Backing texture handle. Returns `null` if the atlas is not yet allocated.
-   */
-  getTexture() {
-    return this.texture;
-  }
-  /**
-   * Lazy 2D depth view selecting `(layer, face)` (the caller passes
-   * `shadowAtlasLayer` from the snapshot and a face index 0..5). Used as the
-   * depth attachment of the shadow-caster render pass for one cube face.
-   *
-   * Caches per `(layer, face)` so the per-frame shadow loop pays zero
-   * `createTextureView` cost after the first allocation. Cache is cleared on
-   * {@link dispose}.
-   *
-   * @throws PointShadowAtlasUninitializedError if the atlas is not yet
-   *   allocated (caller must call {@link ensure} first).
-   * @throws PointShadowAtlasBoundsViolationError if `layer` or `face` is out
-   *   of range.
-   * @throws RhiError if the underlying `createTextureView` fails.
-   */
-  faceView(layer, face) {
-    if (this.texture === null) {
-      throw new PointShadowAtlasUninitializedError();
-    }
-    if (layer < 0 || layer >= this.layers) {
-      throw new PointShadowAtlasBoundsViolationError("layer", layer, this.layers);
-    }
-    if (face < 0 || face >= 6) {
-      throw new PointShadowAtlasBoundsViolationError("face", face, 6);
-    }
-    const key = layer * 6 + face;
-    const cached = this.faceViews.get(key);
-    if (cached !== void 0) return cached;
-    const desc = cubeArrayDepthFaceView(layer, face);
-    const r = this.device.createTextureView(this.texture, desc);
-    if (!r.ok) throw r.error;
-    this.faceViews.set(key, r.value);
-    return r.value;
-  }
-  /**
-   * Release the GPU resources and clear the per-face view cache. Idempotent;
-   * subsequent calls are zero-cost. After dispose, `isAllocated()` returns
-   * `false` and the next `ensure()` re-allocates from scratch.
-   */
-  dispose() {
-    this.faceViews.clear();
-    if (this.texture !== null) {
-      this.device.destroyTexture(this.texture);
-      this.texture = null;
-    }
-    this.cubeArrayView = null;
-    this.compareSampler = null;
-  }
-};
-
-// src/errors/gpu-driven.ts
-var ERROR_POLICY2 = {
-  "missing-material-receipt": {
-    expected: "a producer-owned material program receipt is present",
-    hint: "cook and load the selected material program artifact, then retry preparation",
-    recovery: "rebuild-producer"
-  },
-  "material-abi-not-executable": {
-    expected: "the published material ABI fits the GPU Scene submission layout",
-    hint: "recook the material with a scene-index ABI supported by the GPU-driven owner or keep it on its authored lane",
-    recovery: "route-cpu-lane"
-  },
-  "missing-uv": {
-    expected: "the geometry exposes every UV set named by the material receipt",
-    hint: "repair the geometry UV semantic or route the draw to the CPU semantic lane",
-    recovery: "route-cpu-lane"
-  },
-  "reflection-mismatch": {
-    expected: "the loaded reflection receipt matches the artifact layout identity",
-    hint: "rebuild the material artifact and reflection from one source, then retry",
-    recovery: "rebuild-producer"
-  },
-  "vertex-input-mismatch": {
-    expected: "geometry vertex semantics match the material reflection receipt",
-    hint: "repair the geometry vertex semantic layout or route the draw to the CPU lane",
-    recovery: "route-cpu-lane"
-  },
-  "alpha-mask-mismatch": {
-    expected: "the Alpha Mask cutoff is present in the material receipt",
-    hint: "declare the pass coverage cutoff in the material schema and recook it",
-    recovery: "rebuild-producer"
-  },
-  "resource-not-ready": {
-    expected: "all material resource slots have resolved handles",
-    hint: "resolve the declared texture and sampler resources before recording",
-    recovery: "retry-same-draw"
-  },
-  "stale-generation": {
-    expected: "receipt and prepared inputs belong to the requested generation",
-    hint: "discard stale GPU facts, rebuild the producer receipt, and retry the same draw",
-    recovery: "rebuild-generation"
-  },
-  "skin-receipt-mismatch": {
-    expected: "skinned geometry has a current palette address receipt",
-    hint: "rebuild the Skin palette receipt for this generation before recording",
-    recovery: "rebuild-producer"
-  },
-  "shadow-ownership": {
-    expected: "every declared ShadowCaster pass has one GPU-compatible draw-item owner",
-    hint: "repair the ShadowCaster producer membership or keep the residual on its explicit CPU lane",
-    recovery: "route-cpu-lane"
-  }
-};
-var GpuDrivenPreparationError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  constructor(code, detail) {
-    const policy = ERROR_POLICY2[code];
-    super(`[GpuDrivenPreparationError ${code}] ${policy.expected}`);
-    this.name = "GpuDrivenPreparationError";
-    this.code = code;
-    this.expected = policy.expected;
-    this.hint = policy.hint;
-    this.detail = Object.freeze({
-      ...detail,
-      recovery: detail.recovery ?? policy.recovery
-    });
-  }
-};
-var MATRIX_STRIDE = 16;
-var INITIAL_CAPACITY = 1;
-function instanceUploadRangesForResident(activeIsNew, dirtyRanges, fullRange) {
-  return activeIsNew ? [fullRange] : dirtyRanges;
-}
-function instanceCollectionFailureFacts(cause, recovery, requestedBytes = 0, supportedBytes = void 0, backend = "unknown") {
-  return {
-    requestedBytes,
-    supportedBytes,
-    backend,
-    owner: "renderer.instances",
-    cause,
-    recovery
-  };
-}
-var InstanceCollectionError = class extends Error {
-  code;
-  expected;
-  hint;
-  detail;
-  owner = "renderer.instances";
-  recovery;
-  facts;
-  constructor(code, expected, hint, detail, facts) {
-    super(`${code}: ${expected}`);
-    this.name = "InstanceCollectionError";
-    this.code = code;
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = detail;
-    this.facts = facts ?? instanceCollectionFailureFacts(
-      code,
-      hint,
-      detail?.operation === "create" || detail?.operation === "replace" ? typeof detail.actual === "number" && Number.isFinite(detail.actual) ? detail.actual * Float32Array.BYTES_PER_ELEMENT : 0 : 0
-    );
-    this.recovery = this.facts.recovery;
-  }
-};
-function nextCapacity(required) {
-  let capacity = INITIAL_CAPACITY;
-  while (capacity < required) capacity *= 2;
-  return capacity;
-}
-function invalid(operation, expected, actual, collectionId, context) {
-  const hint = "repair the collection payload and retry the same authoring operation";
-  return new InstanceCollectionError(
-    "instance-collection-invalid",
-    expected,
-    hint,
-    { operation, expected, actual, ...collectionId === void 0 ? {} : { collectionId } },
-    instanceCollectionFailureFacts(
-      context?.cause ?? `invalid-${operation}-authoring`,
-      context?.recovery ?? hint,
-      context?.requestedBytes ?? 0,
-      context?.supportedBytes
-    )
-  );
-}
-function validateTransforms(operation, transforms, collectionId) {
-  if (!(transforms instanceof Float32Array)) {
-    return invalid(operation, "transforms is a Float32Array", typeof transforms, collectionId, {
-      cause: "invalid-transform-type"
-    });
-  }
-  if (transforms.length % MATRIX_STRIDE !== 0) {
-    return invalid(
-      operation,
-      `transforms.length is a multiple of ${MATRIX_STRIDE}`,
-      transforms.length,
-      collectionId,
-      {
-        requestedBytes: transforms.byteLength,
-        cause: "invalid-transform-stride"
-      }
-    );
-  }
-  for (const value of transforms) {
-    if (!Number.isFinite(value)) {
-      return invalid(operation, "every transform value is finite", value, collectionId, {
-        requestedBytes: transforms.byteLength,
-        cause: "invalid-transform-value"
-      });
-    }
-  }
-  return void 0;
-}
-function appendRange(ranges, start, end) {
-  if (start >= end) return;
-  let index = 0;
-  while (index < ranges.length) {
-    const existing = ranges[index];
-    if (existing === void 0 || existing.end >= start) break;
-    index += 1;
-  }
-  while (index < ranges.length) {
-    const existing = ranges[index];
-    if (existing === void 0 || existing.start > end) break;
-    start = Math.min(start, existing.start);
-    end = Math.max(end, existing.end);
-    ranges.splice(index, 1);
-  }
-  ranges.splice(index, 0, { start, end });
-}
-function appendDirtyRange(record, start, end) {
-  appendRange(record.dirtyRanges, start, end);
-}
-function missing(operation, id) {
-  return new InstanceCollectionError(
-    "instance-collection-not-found",
-    `instance collection ${Number(id)} is live and owned by this Renderer`,
-    "create a collection with renderer.instances.create or retain the original collection id",
-    { operation, expected: "a live instance collection id", actual: Number(id), collectionId: id }
-  );
-}
-var InstanceCollectionStore = class {
-  nextId = 1;
-  nextInstanceGeneration = 1;
-  epochValue = 0;
-  disposed = false;
-  records = /* @__PURE__ */ new Map();
-  residency = /* @__PURE__ */ new Map();
-  get epoch() {
-    return this.epochValue;
-  }
-  create(input) {
-    if (this.disposed) {
-      return err(
-        new InstanceCollectionError(
-          "instance-collection-released",
-          "the Renderer-owned instance collection store is live",
-          "create a new Renderer before authoring instance collections"
-        )
-      );
-    }
-    const invalidPayload = validateTransforms("create", input.transforms);
-    if (invalidPayload !== void 0) return err(invalidPayload);
-    const id = this.nextId++;
-    const count = input.transforms.length / MATRIX_STRIDE;
-    const generations = this.allocateGenerations(count);
-    const record = {
-      id,
-      transforms: new Float32Array(input.transforms),
-      generations,
-      count,
-      capacity: nextCapacity(Math.max(INITIAL_CAPACITY, count)),
-      revision: 1,
-      dirtyRanges: count === 0 ? [] : [{ start: 0, end: count }],
-      lastSnapshotRevision: 0,
-      released: false
-    };
-    this.records.set(id, record);
-    this.epochValue += 1;
-    return ok(this.info(record));
-  }
-  replace(id, transforms, generations) {
-    const record = this.live("replace", id);
-    if (!record.ok) return record;
-    const invalidPayload = validateTransforms("replace", transforms, id);
-    if (invalidPayload !== void 0) return err(invalidPayload);
-    const count = transforms.length / MATRIX_STRIDE;
-    const generationResult = generations === void 0 ? ok(this.allocateGenerations(count)) : this.validateReplacementGenerations(generations, count, id);
-    if (!generationResult.ok) return generationResult;
-    const replacementGenerations = generationResult.value;
-    record.value.transforms = new Float32Array(transforms);
-    record.value.generations = replacementGenerations;
-    record.value.count = count;
-    record.value.capacity = Math.max(record.value.capacity, nextCapacity(Math.max(1, count)));
-    record.value.revision += 1;
-    record.value.dirtyRanges = count === 0 ? [] : [{ start: 0, end: count }];
-    record.value.lastSnapshotRevision = record.value.revision - 1;
-    this.epochValue += 1;
-    return ok(this.info(record.value));
-  }
-  update(id, input) {
-    const record = this.live("update", id);
-    if (!record.ok) return record;
-    const invalidPayload = validateTransforms("update", input.transforms, id);
-    if (invalidPayload !== void 0) return err(invalidPayload);
-    if (!Number.isInteger(input.start) || input.start < 0) {
-      return err(
-        invalid("update", "start is a non-negative matrix ordinal", input.start, id, {
-          requestedBytes: input.transforms.byteLength,
-          supportedBytes: record.value.capacity * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
-          cause: "invalid-update-range-start"
-        })
-      );
-    }
-    const span = input.transforms.length / MATRIX_STRIDE;
-    const attemptedEnd = input.start + span;
-    if (attemptedEnd > record.value.count) {
-      return err(
-        invalid(
-          "update",
-          `start + matrix count is <= collection count (${record.value.count})`,
-          attemptedEnd,
-          id,
-          {
-            requestedBytes: attemptedEnd * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
-            supportedBytes: record.value.count * MATRIX_STRIDE * Float32Array.BYTES_PER_ELEMENT,
-            cause: "invalid-update-range-end"
-          }
-        )
-      );
-    }
-    if (record.value.lastSnapshotRevision === record.value.revision) {
-      record.value.dirtyRanges = [];
-    }
-    record.value.transforms.set(input.transforms, input.start * MATRIX_STRIDE);
-    record.value.revision += 1;
-    appendDirtyRange(record.value, input.start, input.start + span);
-    this.epochValue += 1;
-    return ok(this.info(record.value));
-  }
-  inspect(id) {
-    const record = this.live("inspect", id);
-    return record.ok ? ok(this.info(record.value)) : record;
-  }
-  /**
-   * Return detached residency facts for every live collection.
-   *
-   * @internal Record-stage evidence is reported through the two methods below;
-   * callers only receive immutable PODs and never GPU handles.
-   */
-  _inspections() {
-    return Object.freeze(
-      [...this.records.values()].map((record) => this.projectInspection(record))
-    );
-  }
-  /** @internal Renderer record owner reports the accepted collection lane. */
-  _reportResidency(input) {
-    if (!this.records.has(input.collectionId)) return;
-    const previous = this.residency.get(input.collectionId);
-    const sameFrame = previous !== void 0 && previous.frameNumber === input.frameNumber && previous.error === void 0;
-    const uploadRanges = sameFrame ? [...previous.uploadRanges].reduce(
-      (ranges, range) => {
-        appendRange(ranges, range.start, range.end);
-        return ranges;
-      },
-      input.uploadRanges.map((range) => ({ ...range }))
-    ) : input.uploadRanges.map((range) => ({ ...range }));
-    this.residency.set(input.collectionId, {
-      frameNumber: input.frameNumber,
-      residentGeneration: input.residentGeneration,
-      lane: input.lane,
-      uploadRanges,
-      uploadedBytes: sameFrame ? previous.uploadedBytes + input.uploadedBytes : input.uploadedBytes,
-      requestedBytes: input.requestedBytes,
-      supportedBytes: input.supportedBytes,
-      backend: input.backend,
-      error: void 0
-    });
-  }
-  /** @internal Renderer record owner reports a typed admission failure. */
-  _reportFailure(input) {
-    if (!this.records.has(input.collectionId)) return;
-    this.residency.set(input.collectionId, {
-      frameNumber: -1,
-      residentGeneration: void 0,
-      lane: "unavailable",
-      uploadRanges: [],
-      uploadedBytes: 0,
-      requestedBytes: input.facts.requestedBytes,
-      supportedBytes: input.facts.supportedBytes,
-      backend: input.facts.backend,
-      error: {
-        code: input.code,
-        expected: input.expected,
-        hint: input.hint,
-        detail: { ...input.facts }
-      }
-    });
-  }
-  /** @internal A lost device invalidates every renderer-owned GPU resident. */
-  _resetResidency() {
-    this.residency.clear();
-  }
-  snapshot(id) {
-    const record = this.live("inspect", id);
-    if (!record.ok) return record;
-    const value = record.value;
-    value.lastSnapshotRevision = value.revision;
-    const result = {
-      ...this.info(value),
-      transforms: new Float32Array(value.transforms),
-      generations: new Uint32Array(value.generations),
-      dirtyRanges: value.dirtyRanges.map((range) => ({ ...range }))
-    };
-    return ok(result);
-  }
-  /**
-   * Read a detached matrix view without advancing the render-consumption
-   * cursor. Inspection and picking may call this between authoring updates;
-   * the next renderer snapshot must still receive the complete dirty union.
-   */
-  peek(id) {
-    const record = this.live("inspect", id);
-    return record.ok ? ok(this.detachedSnapshot(record.value)) : record;
-  }
-  release(id) {
-    const record = this.records.get(id);
-    if (record === void 0) return err(missing("release", id));
-    if (record.released) {
-      return err(
-        new InstanceCollectionError(
-          "instance-collection-released",
-          `instance collection ${Number(id)} has not already been released`,
-          "do not reuse a released collection id; create a new collection",
-          {
-            operation: "release",
-            expected: "a live instance collection id",
-            actual: Number(id),
-            collectionId: id
-          }
-        )
-      );
-    }
-    record.released = true;
-    this.records.delete(id);
-    this.residency.delete(id);
-    this.epochValue += 1;
-    return ok(void 0);
-  }
-  /** Drop all canonical matrices during Renderer disposal. */
-  dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    for (const record of this.records.values()) record.released = true;
-    this.records.clear();
-    this.residency.clear();
-    this.epochValue += 1;
-  }
-  live(operation, id) {
-    if (!Number.isInteger(id) || id <= 0) {
-      return err(invalid(operation, "collectionId is a positive integer", id, id));
-    }
-    if (this.disposed) {
-      return err(
-        new InstanceCollectionError(
-          "instance-collection-released",
-          "the Renderer-owned instance collection store is live",
-          "create a new Renderer before using instance collections",
-          { operation, expected: "a live collection store", actual: "disposed", collectionId: id }
-        )
-      );
-    }
-    const record = this.records.get(id);
-    return record === void 0 ? err(missing(operation, id)) : ok(record);
-  }
-  detachedSnapshot(record) {
-    return {
-      ...this.info(record),
-      transforms: new Float32Array(record.transforms),
-      generations: new Uint32Array(record.generations),
-      dirtyRanges: record.dirtyRanges.map((range) => ({ ...range }))
-    };
-  }
-  info(record) {
-    return Object.freeze({
-      collectionId: record.id,
-      count: record.count,
-      capacity: record.capacity,
-      revision: record.revision
-    });
-  }
-  allocateGenerations(count) {
-    const generations = new Uint32Array(count);
-    for (let index = 0; index < count; index += 1) {
-      generations[index] = this.nextInstanceGeneration;
-      this.nextInstanceGeneration = this.nextInstanceGeneration + 1 >>> 0 || 1;
-    }
-    return generations;
-  }
-  validateReplacementGenerations(generations, count, collectionId) {
-    if (!(generations instanceof Uint32Array) || generations.length !== count) {
-      return err(
-        invalid(
-          "replace",
-          `generations is a Uint32Array with ${count} entries`,
-          generations instanceof Uint32Array ? generations.length : typeof generations,
-          collectionId,
-          { requestedBytes: generations?.byteLength ?? 0, cause: "invalid-generation-shape" }
-        )
-      );
-    }
-    const seen = /* @__PURE__ */ new Set();
-    for (const generation of generations) {
-      if (generation === 0 || seen.has(generation)) {
-        return err(
-          invalid(
-            "replace",
-            "generations contain unique non-zero identity tokens",
-            generation,
-            collectionId,
-            {
-              requestedBytes: generations.byteLength,
-              cause: "invalid-generation-identity"
-            }
-          )
-        );
-      }
-      seen.add(generation);
-      if (generation >= this.nextInstanceGeneration) {
-        this.nextInstanceGeneration = generation + 1 >>> 0 || 1;
-      }
-    }
-    return ok(new Uint32Array(generations));
-  }
-  projectInspection(record) {
-    const residency = this.residency.get(record.id);
-    return Object.freeze({
-      ...this.info(record),
-      residentGeneration: residency?.residentGeneration,
-      lane: residency?.lane ?? "unresident",
-      dirtyRanges: Object.freeze(record.dirtyRanges.map((range) => ({ ...range }))),
-      uploadRanges: Object.freeze(residency?.uploadRanges.map((range) => ({ ...range })) ?? []),
-      uploadedBytes: residency?.uploadedBytes ?? 0,
-      requestedBytes: residency?.requestedBytes ?? record.count * MATRIX_STRIDE * 4,
-      supportedBytes: residency?.supportedBytes,
-      backend: residency?.backend ?? "unknown",
-      owner: "renderer.instances",
-      error: residency?.error
-    });
-  }
-};
-
-// src/scene/visibility/budget.ts
-var DEFAULT_CONFIGURED_QUERY_BUDGET = 2048;
-var MAX_QUERY_BUDGET = 4096;
-var VISIBILITY_CANDIDATE_COUNT = 1e5;
-var VISIBILITY_OCCLUDED_COUNT = 9e4;
-function createVisibilityBudget(configuredQueryBudget = DEFAULT_CONFIGURED_QUERY_BUDGET) {
-  if (!Number.isSafeInteger(configuredQueryBudget) || configuredQueryBudget <= 0) {
-    throw new RangeError("configuredQueryBudget must be a positive safe integer");
-  }
-  const effectiveQueryBudget = Math.min(configuredQueryBudget, MAX_QUERY_BUDGET);
-  const oneSweepCandidates = oneSweep(VISIBILITY_CANDIDATE_COUNT, effectiveQueryBudget);
-  const oneSweepOccluded = oneSweep(VISIBILITY_OCCLUDED_COUNT, effectiveQueryBudget);
-  const retestSubmits = Math.max(6, oneSweepOccluded);
-  return Object.freeze({
-    configuredQueryBudget,
-    effectiveQueryBudget,
-    oneSweepCandidates,
-    oneSweepOccluded,
-    settleSubmits: 2 * oneSweepCandidates,
-    retestSubmits,
-    expirySubmits: Math.max(8, retestSubmits + oneSweepOccluded)
-  });
-}
-function oneSweep(candidateCount, effectiveQueryBudget) {
-  return Math.ceil(candidateCount / effectiveQueryBudget);
-}
-
-// src/render-contract.ts
-var STANDARD_OUTPUT_TRANSFORM_FEATURE_ID = "forgeax::standard::output-transform";
-var FXAA_POST_PROCESS_ID = "forgeax::post::fxaa";
-var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
-  "record/graph-execute/point-shadow",
-  "record/graph-execute/cluster-binner-upload",
-  "record/graph-execute/g-buffer",
-  "record/graph-execute/g-buffer/geometry-loop",
-  "record/graph-execute/g-buffer/material-bind-groups",
-  "record/graph-execute/g-buffer/pipeline-selection",
-  "record/graph-execute/g-buffer/draw-submit",
-  "record/graph-execute/ssao-calc",
-  "record/graph-execute/ssao-blur",
-  "record/graph-execute/lighting",
-  "record/graph-execute/forward",
-  "record/graph-execute/forward/geometry-loop",
-  "record/graph-execute/forward/material-bind-groups",
-  "record/graph-execute/forward/pipeline-selection",
-  "record/graph-execute/forward/draw-submit",
-  "record/graph-execute/output-transform",
-  "record/graph-execute/present",
-  "record/graph-execute/debug-overlay",
-  "record/graph-execute/shadow",
-  "record/graph-execute/spot-shadow",
-  "record/graph-execute/skybox",
-  "record/graph-execute/main",
-  "record/graph-execute/fxaa",
-  "record/graph-execute/bloom-downsample",
-  "record/graph-execute/bloom-upsample",
-  "record/graph-execute/bloom-composite",
-  "record/graph-execute/ssr-hiz",
-  "record/graph-execute/ssr-trace",
-  "record/graph-execute/ssr-temporal",
-  "record/graph-execute/ssr-reflection-mip",
-  "record/graph-execute/ssr-compose",
-  "record/graph-execute/other"
-];
-var RENDER_HDRP_BINNER_PHASE_CATALOG = [
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy",
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy/light-aabb",
-  "record/scene-state/hdrp-cluster/binner/light-bounds-and-occupancy/cluster-occupancy",
-  "record/scene-state/hdrp-cluster/binner/cluster-reserve",
-  "record/scene-state/hdrp-cluster/binner/input-preparation",
-  "record/scene-state/hdrp-cluster/binner/bin-core",
-  "record/scene-state/hdrp-cluster/binner/light-index-write",
-  "record/scene-state/hdrp-cluster/binner/light-index-write/bounds-read",
-  "record/scene-state/hdrp-cluster/binner/light-index-write/cluster-write"
-];
-var RENDER_HDRP_CLUSTER_PHASE_CATALOG = [
-  "record/scene-state/hdrp-cluster/binner",
-  ...RENDER_HDRP_BINNER_PHASE_CATALOG,
-  "record/scene-state/hdrp-cluster/payload-packing",
-  "record/scene-state/hdrp-cluster/buffer-upload"
-];
-var RENDER_SCENE_STATE_PHASE_CATALOG = [
-  "record/scene-state/fold-buckets",
-  "record/scene-state/lighting-prep",
-  "record/scene-state/ambient-resolution",
-  "record/scene-state/directional-shadow-cache",
-  "record/scene-state/hdrp-cluster",
-  ...RENDER_HDRP_CLUSTER_PHASE_CATALOG
-];
-var RENDER_RECORD_PHASE_CATALOG = [
-  "record/occlusion-query-submit",
-  "record/occlusion-global-advance",
-  "record/scene-state",
-  ...RENDER_SCENE_STATE_PHASE_CATALOG,
-  "record/swapchain",
-  "record/render-graph",
-  "record/target-views",
-  "record/validation",
-  "record/dispatch-plan",
-  "record/uploads",
-  "record/bind-groups",
-  "record/graph-execute",
-  ...RENDER_GRAPH_EXECUTION_PHASE_CATALOG
-];
-var RENDER_PHASE_CATALOG = [
-  "extract",
-  "occlusion-prepare",
-  "bind-groups",
-  "features",
-  "sort",
-  "record",
-  ...RENDER_RECORD_PHASE_CATALOG
-];
-
-export { AtmosphereInvalidParameterError, AutoExposureCapabilityUnavailableError, AutoExposureInvalidParameterError, AutoExposureStageFailedError, AutoExposureStaleGenerationError, DEFAULT_MOTION_BLUR_PARAMS, DynamicResolutionInvalidParameterError, DynamicResolutionRequiresTaaError, DynamicResolutionTimingUnavailableError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FXAA_POST_PROCESS_ID, FogCardinalityError, FrameReceiptStaleError, GPU_TEXTURE_USAGE_COPY_DST, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_STORAGE_BINDING, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GpuDrivenPreparationError, InstanceCollectionError, InstanceCollectionStore, LifecycleConstructionError, MOTION_BLUR_PARAMS_BYTE_SIZE, MaterialSkinAttrMissingError, MotionBlurValidationError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RenderIntentInvalidError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, RenderTargetOperationFailedError, RenderTargetStateInvalidError, RendererContractFailureError, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, SceneDataUnavailableError, ShadowAtlas, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, StandardClusterIndexOverflowError, StandardClusterTransportUnavailableError, StandardLightBudgetExceededError, StandardProfileInvalidError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, createAutoExposureError, createAutoExposureInspection, createLightResourceUnavailable, createVisibilityBudget, effectiveMotionBlurSampleCount, instanceUploadRangesForResident, isMotionBlurIntervalValid, motionBlurExposureScale, motionBlurSampleDelta, motionBlurTemporalDemand, resolveMotionBlurParams, validateMotionBlurParams };
-//# sourceMappingURL=chunk-NB2S7ZRX.mjs.map
-//# sourceMappingURL=chunk-NB2S7ZRX.mjs.map