@forgeax/engine-render 0.1.4 → 0.1.7

package/dist/chunk-YEJIUW7D.mjs

@@ -0,0 +1,1152 @@
+import { defineComponent, Entity } from '@forgeax/engine-ecs';
+import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
+import { err, ok } from '@forgeax/engine-types';
+import { projectHierarchy } from '@forgeax/engine-scene';
+
+// 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 ShadowInvalidConfigError = class extends Error {
+  code = "shadow-invalid-config";
+  expected;
+  hint;
+  detail;
+  constructor(field, value, min, maxOrComparator) {
+    const isComparator = maxOrComparator === ">" || maxOrComparator === ">=";
+    const max = !isComparator && typeof maxOrComparator === "number" ? maxOrComparator : void 0;
+    const comparator = isComparator ? maxOrComparator : ">=";
+    const isInteger = field === "cascadeCount" || field === "pcfKernelSize";
+    const isOdd = field === "pcfKernelSize";
+    const hint = max !== void 0 ? isInteger ? `set ${field} to an integer in [${min}, ${max}]; got ${value}` : `set ${field} to a value in [${min}, ${max}]; got ${value}` : isOdd ? `set ${field} to an odd integer ${comparator} ${min}; got ${value}` : `set ${field} to a value ${comparator} ${min}; got ${value}`;
+    const expected = max !== void 0 ? `${field} in [${min}, ${max}]` : `${field} ${comparator} ${min}`;
+    super(
+      max !== void 0 ? `shadow component .${field} must be in [${min}, ${max}], got ${value}` : `shadow component .${field} must be ${comparator} ${min}, got ${value}`
+    );
+    this.name = "ShadowInvalidConfigError";
+    this.hint = hint;
+    this.expected = expected;
+    this.detail = { field, value, min, ...max !== void 0 ? { max } : {} };
+  }
+};
+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 HdrpLightBudgetExceededError = class extends Error {
+  code = "hdrp-light-budget-exceeded";
+  expected;
+  hint;
+  detail;
+  constructor(actual, budget) {
+    const expected = `light count <= ${budget}`;
+    const hint = `${actual} lights exceed HDRP budget ${budget}; truncating to 256. Reduce light count or wait for OOS-hdrp-larger-budget`;
+    super(`HDRP light budget exceeded: ${actual} > ${budget}`);
+    this.name = "HdrpLightBudgetExceededError";
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = { actual, budget };
+  }
+};
+var HdrpIndexListOverflowError = class extends Error {
+  code = "hdrp-index-list-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 lights, shrink cluster grid, or increase LIGHT_INDEX_LIST_CAPACITY`;
+    super(`HDRP index list overflow: ${actual} > ${capacity}`);
+    this.name = "HdrpIndexListOverflowError";
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = { actual, capacity };
+  }
+};
+var HdrpDeferredCapsInsufficientError = class extends Error {
+  code = "hdrp-deferred-caps-insufficient";
+  expected;
+  hint;
+  detail;
+  constructor(actual) {
+    const _expected = 4;
+    const _expectedStr = `maxColorAttachments >= ${_expected}`;
+    const hint = `WebGPU maxColorAttachments = ${actual} (need >= ${_expected}). Upgrade browser to latest Chrome/Edge/Safari, or use URP (forgeax::urp) instead of HDRP.`;
+    super(
+      `HDRP deferred caps insufficient: maxColorAttachments = ${actual} (need >= ${_expected})`
+    );
+    this.name = "HdrpDeferredCapsInsufficientError";
+    this.expected = _expectedStr;
+    this.hint = hint;
+    this.detail = { actual, expected: _expected };
+  }
+};
+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, missing) {
+    const expected = "pbr-skin material requires mesh.attributes.skinIndex + skinWeight";
+    const hint = `entity ${entity} uses forgeax::pbr-skin but its MeshAsset is missing ${missing}; 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 ${missing}`
+    );
+    this.name = "MaterialSkinAttrMissingError";
+    this.expected = expected;
+    this.hint = hint;
+    this.detail = { entity, missing };
+  }
+};
+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) {
+    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 };
+  }
+};
+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 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 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 CAMERA_PROJECTION_PERSPECTIVE = 0;
+var CAMERA_PROJECTION_ORTHOGRAPHIC = 1;
+function cameraProjectionFromF32(value) {
+  return value === CAMERA_PROJECTION_ORTHOGRAPHIC ? "orthographic" : "perspective";
+}
+var TONEMAP_NONE = TONEMAP_SHADER_MODE.none;
+var TONEMAP_REINHARD_EXTENDED = TONEMAP_SHADER_MODE.reinhardExtended;
+var TONEMAP_REINHARD = TONEMAP_SHADER_MODE.reinhard;
+var TONEMAP_LINEAR = TONEMAP_SHADER_MODE.linear;
+var TONEMAP_CINEON = TONEMAP_SHADER_MODE.cineon;
+var TONEMAP_ACES_FILMIC = TONEMAP_SHADER_MODE.acesFilmic;
+var TONEMAP_AGX = TONEMAP_SHADER_MODE.agx;
+var TONEMAP_NEUTRAL = TONEMAP_SHADER_MODE.neutral;
+function tonemapFromF32(value) {
+  switch (value) {
+    case TONEMAP_REINHARD_EXTENDED:
+      return "reinhard-extended";
+    case TONEMAP_REINHARD:
+      return "reinhard";
+    case TONEMAP_LINEAR:
+      return "linear";
+    case TONEMAP_CINEON:
+      return "cineon";
+    case TONEMAP_ACES_FILMIC:
+      return "aces-filmic";
+    case TONEMAP_AGX:
+      return "agx";
+    case TONEMAP_NEUTRAL:
+      return "neutral";
+    default:
+      return "none";
+  }
+}
+function tonemapToU32(mode) {
+  switch (mode) {
+    case "reinhard-extended":
+      return TONEMAP_REINHARD_EXTENDED;
+    case "reinhard":
+      return TONEMAP_REINHARD;
+    case "linear":
+      return TONEMAP_LINEAR;
+    case "cineon":
+      return TONEMAP_CINEON;
+    case "aces-filmic":
+      return TONEMAP_ACES_FILMIC;
+    case "agx":
+      return TONEMAP_AGX;
+    case "neutral":
+      return TONEMAP_NEUTRAL;
+    case "none":
+      return TONEMAP_NONE;
+  }
+  throw new RangeError(`Invalid tonemap mode: ${String(mode)}.`);
+}
+var ANTIALIAS_NONE = 0;
+var ANTIALIAS_FXAA = 1;
+var ANTIALIAS_MSAA = 2;
+var ANTIALIAS_TAA = 3;
+function antialiasFromF32(value) {
+  if (value === ANTIALIAS_NONE) return "none";
+  if (value === ANTIALIAS_FXAA) return "fxaa";
+  if (value === ANTIALIAS_MSAA) return "msaa";
+  if (value === ANTIALIAS_TAA) return "taa";
+  throw new RangeError(
+    `Invalid antialias value: ${value}. Expected ${ANTIALIAS_NONE} (none), ${ANTIALIAS_FXAA} (fxaa), ${ANTIALIAS_MSAA} (msaa), or ${ANTIALIAS_TAA} (taa).`
+  );
+}
+var BLOOM_DISABLED = 0;
+var BLOOM_ENABLED = 1;
+function bloomEnabledFromF32(value) {
+  if (value === BLOOM_DISABLED) return "off";
+  if (value === BLOOM_ENABLED) return "on";
+  throw new RangeError(
+    `Invalid bloom value: ${value}. Expected ${BLOOM_DISABLED} (off) or ${BLOOM_ENABLED} (on).`
+  );
+}
+var Camera = defineComponent("Camera", {
+  fov: { type: "f32" },
+  aspect: { type: "f32" },
+  near: { type: "f32" },
+  far: { type: "f32" },
+  projection: { type: "f32", default: 0 },
+  left: { type: "f32", default: -1 },
+  right: { type: "f32", default: 1 },
+  bottom: { type: "f32", default: -1 },
+  top: { type: "f32", default: 1 },
+  tonemap: { type: "f32", default: 0 },
+  exposure: { type: "f32", default: 1 },
+  whitePoint: { type: "f32", default: 4 },
+  antialias: { type: "f32", default: 0 },
+  historyVersion: { type: "u32", default: 0 },
+  bloom: { type: "f32", default: 0 },
+  bloomThreshold: { type: "f32", default: 1 },
+  bloomIntensity: { type: "f32", default: 1 },
+  bloomBlurRadius: { type: "f32", default: 4 },
+  // feat-20260709 M3 / D-3: clear-color is one inline `array<f32,4>` column.
+  // The earlier 4-scalar form (clearR/G/B/A) was chosen when this was believed
+  // to be the only SoA-safe shape; the Transform (pos/quat/scale) and light
+  // (direction/color) precedents disprove that -- an `array<f32,N>` IS an
+  // inline stride-N SoA column, read on the hot path as `col[i*N+a]` with zero
+  // allocation, so collapsing four scalars into one column removes three field
+  // names a reader must track without changing the storage layout or read
+  // pattern. The default `[0, 0, 0, 0]` is transparent black; explicit alpha
+  // stays visible through the same public array field.
+  clearColor: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 0]) },
+  // feat-20260617-host-engine-contract-and-video-cutscene / M3 / D-4: the
+  // aspect-sync sidecar on the createApp(canvas) path writes
+  // canvas.width / canvas.height into `aspect` every frame when this flag is
+  // true. Reuses the existing `bool` column tier (AnimationPlayer.paused /
+  // AudioSource.playing precedent) -- zero ECS infrastructure change. Default
+  // true so demos that never touch aspect track the canvas automatically
+  // (charter P1 default-is-correct); set false for render-to-texture /
+  // split-screen cameras that drive aspect themselves. Read it via
+  // world.get (readRow narrows bool -> JS boolean); the query-bundle path
+  // returns a raw 0/1 number (the `!== 0` always-true trap).
+  autoAspect: { type: "bool", default: true }
+});
+function cameraPodFromDefaults() {
+  const base = {};
+  for (const [key, field] of Object.entries(Camera.fields)) {
+    if ("default" in field && field.default !== void 0) {
+      base[key] = field.default;
+    }
+  }
+  return base;
+}
+function perspective(opts) {
+  return {
+    // cameraPodFromDefaults() reads autoAspect's schema default (true), so an
+    // omitted opts.autoAspect lands the default-correct value; an explicit
+    // false overrides it below (D-4: factory one-step opt-out, charter P1).
+    ...cameraPodFromDefaults(),
+    fov: opts.fov,
+    aspect: opts.aspect,
+    near: opts.near ?? 0.1,
+    far: opts.far ?? 100,
+    projection: CAMERA_PROJECTION_PERSPECTIVE,
+    ...opts.autoAspect !== void 0 ? { autoAspect: opts.autoAspect } : {}
+  };
+}
+function orthographic(opts) {
+  return {
+    ...cameraPodFromDefaults(),
+    fov: 0,
+    aspect: 1,
+    near: opts.near ?? 0.1,
+    far: opts.far ?? 100,
+    projection: CAMERA_PROJECTION_ORTHOGRAPHIC,
+    left: opts.left,
+    right: opts.right,
+    bottom: opts.bottom,
+    top: opts.top
+  };
+}
+var DirectionalLight = defineComponent("DirectionalLight", {
+  // direction is the ONLY field with no default (D-5): omitting it lands the
+  // array layer-3 all-zero [0,0,0], which the renderer owner rejects -- there is no
+  // universal default direction, so "default is illegal" forces an explicit
+  // non-zero value. color carries an explicit layer-2 default [1,1,1] (white);
+  // the array layer-3 fallback is all-zero, so the default MUST be explicit.
+  direction: { type: "array<f32, 3>" },
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  // Shadow opt-out gate: defaults to true so zero-config spawns get shadows.
+  castShadow: { type: "bool", default: true },
+  // 9 shadow fields migrated from DirectionalLightShadow (feat-20260621 M1).
+  cascadeCount: { type: "f32", default: 4 },
+  splitLambda: { type: "f32", default: 0.75 },
+  cascadeBlend: { type: "f32", default: 0.2 },
+  mapSize: { type: "f32", default: 2048 },
+  depthBias: { type: "f32", default: 5e-3 },
+  normalBias: { type: "f32", default: 0.05 },
+  // Sole shadow coverage knob (feat replaces nearPlane/farPlane). The PSSM
+  // near end derives from the active camera near; shadowDistance is the far
+  // reach. Default 200 world units (matches UE-style "dynamic shadow
+  // distance"; the old farPlane default was 50).
+  shadowDistance: { type: "f32", default: 200 },
+  pcfKernelSize: { type: "f32", default: 3 }
+});
+var Instances = defineComponent("Instances", {
+  transforms: { type: "array<f32>" }
+});
+var Layer = defineComponent("Layer", {
+  value: { type: "i32", default: 0 }
+});
+var Lines = defineComponent(
+  "Lines",
+  {
+    widthPx: { type: "f32", default: 1 }
+  },
+  {
+    meta: {
+      quickStart: "Attach Lines to render line-list MeshAsset pairs in screen pixels.",
+      diagnostics: "Inspect widthPx at the points-lines admission boundary.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive widthPx values.",
+      boundaries: "Lines owns raster width only; MeshFilter and MeshRenderer own geometry and material."
+    }
+  }
+);
+var MeshFilter = defineComponent("MeshFilter", {
+  assetHandle: { type: "shared<MeshAsset>" }
+});
+var MeshRenderer = defineComponent("MeshRenderer", {
+  materials: { type: "array<shared<MaterialAsset>>", default: [] }
+});
+var PointLight = defineComponent("PointLight", {
+  // color carries an explicit layer-2 default [1,1,1] (white); the array
+  // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  range: { type: "f32", default: 10 }
+});
+var PointLightShadow = defineComponent("PointLightShadow", {
+  mapSize: { type: "f32", default: 512 },
+  depthBias: { type: "f32", default: 5e-3 },
+  normalBias: { type: "f32", default: 0.05 },
+  nearPlane: { type: "f32", default: 0.1 },
+  farPlane: { type: "f32", default: 25 },
+  pcfKernelSize: { type: "f32", default: 3 }
+});
+var PointShapeValue = Object.freeze({
+  square: 0,
+  circle: 1
+});
+function pointShapeFromU32(value) {
+  switch (value) {
+    case PointShapeValue.square:
+      return "square";
+    case PointShapeValue.circle:
+      return "circle";
+    default:
+      return void 0;
+  }
+}
+var Points = defineComponent(
+  "Points",
+  {
+    sizePx: { type: "f32", default: 4 },
+    shape: { type: "enum", default: PointShapeValue.square, labels: PointShapeValue }
+  },
+  {
+    meta: {
+      quickStart: "Attach Points to render point-list MeshAsset vertices in screen pixels.",
+      diagnostics: "Inspect sizePx and decode shape with pointShapeFromU32.",
+      recovery: "Use points-lines-invalid-style for non-finite or non-positive sizePx values.",
+      boundaries: "Points owns raster size and shape only; MeshFilter and MeshRenderer own geometry and material."
+    }
+  }
+);
+var schema = {
+  shader: "string",
+  data: "buffer"
+};
+var PostProcessParams = defineComponent("PostProcessParams", schema);
+var SceneInstance = defineComponent(
+  "SceneInstance",
+  {
+    source: { type: "shared<SceneAsset>" },
+    mapping: { type: "array<entity>" },
+    // The unique slot is the ECS storage seam for the instance's structured
+    // runtime payload; keep the nested semantic visible to schema consumers.
+    state: { type: "unique<SceneInstanceState>", shape: "nested" }
+  },
+  { transient: true }
+);
+var SKYBOX_MODE_CUBEMAP = 0;
+var SkyboxBackground = defineComponent("SkyboxBackground", {
+  // The GPU skybox projection is render-owned presentation state; restore
+  // keeps the portable mode/rotation controls and lets the owner re-resolve
+  // the environment asset on the target world.
+  equirect: { type: "shared<EquirectAsset>", simulationTransient: true },
+  mode: { type: "f32", default: SKYBOX_MODE_CUBEMAP },
+  rotation: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) }
+});
+var Skylight = defineComponent("Skylight", {
+  // The GPU equirect-to-cubemap projection is render-owned presentation
+  // state. Record/restore preserves the portable lighting controls while the
+  // render owner resolves this asset again on the target world.
+  equirect: { type: "shared<EquirectAsset>", simulationTransient: true },
+  // color carries an explicit layer-2 default [1,1,1] (white); the array
+  // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  rotation: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) }
+});
+var SortKey = defineComponent("SortKey", {
+  value: { type: "f32", default: 0 }
+});
+var SpotLight = defineComponent("SpotLight", {
+  // direction has no default (D-5): omitting it lands the array layer-3
+  // all-zero, which validate() rejects. color carries an explicit layer-2
+  // default [1,1,1] (white); the array layer-3 fallback is all-zero.
+  direction: { type: "array<f32, 3>" },
+  color: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  intensity: { type: "f32", default: 1 },
+  range: { type: "f32", default: 10 },
+  innerConeDeg: { type: "f32", default: 0 },
+  outerConeDeg: { type: "f32", default: 45 },
+  // Shadow opt-out gate: defaults to true so zero-config spawns cast shadows.
+  castShadow: { type: "bool", default: true },
+  // 6 shadow fields aligned with DirectionalLight (plan-strategy D-6).
+  mapSize: { type: "f32", default: 2048 },
+  depthBias: { type: "f32", default: 5e-3 },
+  normalBias: { type: "f32", default: 0.05 },
+  nearPlane: { type: "f32", default: 0.1 },
+  farPlane: { type: "f32", default: 50 },
+  pcfKernelSize: { type: "f32", default: 3 }
+});
+var VisibilityStateValue = Object.freeze({
+  inherited: 0,
+  hidden: 1,
+  visible: 2
+});
+function visibilityStateFromU32(value) {
+  switch (value) {
+    case VisibilityStateValue.inherited:
+      return "inherited";
+    case VisibilityStateValue.hidden:
+      return "hidden";
+    case VisibilityStateValue.visible:
+      return "visible";
+    default:
+      return void 0;
+  }
+}
+var Visibility = defineComponent(
+  "Visibility",
+  {
+    state: {
+      type: "enum",
+      default: VisibilityStateValue.inherited,
+      labels: VisibilityStateValue
+    }
+  },
+  {
+    meta: {
+      quickStart: "Attach Visibility to author render participation intent.",
+      diagnostics: "Compare the ECS state with resolveVisibility and renderer.visibilityStats.",
+      recovery: "Use structured ECS write errors and repair the owning scene relation.",
+      boundaries: "Visibility does not own camera, picking, lifecycle, assets, or VFX shadow policy."
+    }
+  }
+);
+
+// src/pipeline/standard-profile.ts
+var STANDARD_PIPELINE_ID = "forgeax::standard";
+var STANDARD_LIGHT_COUNTS = [1, 32, 256];
+var DEFAULT_CLUSTER_GRID = { x: 16, y: 9, z: 24 };
+var CLUSTER_GRID_STRIDE_U32 = 2;
+var LIGHT_INDEX_LIST_CAPACITY = 1048576;
+var MAX_LIGHTS = 256;
+var DEFAULT_STANDARD_PROFILE = Object.freeze({
+  pipelineId: STANDARD_PIPELINE_ID,
+  lightCount: 32,
+  lighting: "direct",
+  shadows: "filtered",
+  pbr: true,
+  ibl: true,
+  ssao: false,
+  bloom: true,
+  tone: "aces-filmic",
+  antialias: "fxaa",
+  sky: true,
+  fallback: "native",
+  postStages: ["transparent-blend", "bloom", "tone", "fxaa", "output"]
+});
+function resolveStandardLane(profile, capabilities) {
+  if (!capabilities.compute || !capabilities.storageBuffer) return "cpu-webgl2";
+  return profile.lighting;
+}
+
+// src/render-contract.ts
+var STANDARD_TONEMAP_FEATURE_ID = "forgeax::standard::tonemap";
+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/tonemap",
+  "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-bright",
+  "record/graph-execute/bloom-blur-h",
+  "record/graph-execute/bloom-blur-v",
+  "record/graph-execute/bloom-composite",
+  "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/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",
+  "bind-groups",
+  "features",
+  "sort",
+  "record",
+  ...RENDER_RECORD_PHASE_CATALOG
+];
+function invalidStyle(input, component, field, value, expected) {
+  return err(new PointsLinesInvalidStyleError({ entity: input.entity, component, field, value, expected }));
+}
+function topologyMismatch(input, submesh, expected, actual) {
+  return err(new PointsLinesTopologyMismatchError({ entity: input.entity, submesh, expected, actual }));
+}
+function checkStyle(input) {
+  const hasPoints = input.points !== void 0;
+  const hasLines = input.lines !== void 0;
+  if (hasPoints && hasLines) {
+    return invalidStyle(
+      input,
+      "Points/Lines",
+      "components",
+      "Points + Lines",
+      "exactly one style component"
+    );
+  }
+  if (!hasPoints && !hasLines) {
+    return invalidStyle(input, "Points/Lines", "components", void 0, "one style component");
+  }
+  if (hasPoints) {
+    const sizePx = input.points?.sizePx ?? 4;
+    const shapeValue = input.points?.shape ?? PointShapeValue.square;
+    const shape = pointShapeFromU32(shapeValue);
+    if (!Number.isFinite(sizePx) || sizePx <= 0) {
+      return invalidStyle(input, "Points", "sizePx", sizePx, "finite sizePx > 0");
+    }
+    if (shape === void 0) {
+      return invalidStyle(input, "Points", "shape", shapeValue, "shape is 'square' or 'circle'");
+    }
+    return ok({ component: "Points", shape, sizePx });
+  }
+  const widthPx = input.lines?.widthPx ?? 1;
+  if (!Number.isFinite(widthPx) || widthPx <= 0) {
+    return invalidStyle(input, "Lines", "widthPx", widthPx, "finite widthPx > 0");
+  }
+  return ok({ component: "Lines", widthPx });
+}
+function checkTopology(input, component) {
+  const expected = component === "Points" ? "point-list" : "line-list";
+  let pointCount = 0;
+  let segmentCount = 0;
+  const acceptedSubmeshes = [];
+  let sawNonEmpty = false;
+  for (const [submeshIndex, submesh] of input.mesh.submeshes.entries()) {
+    const indexed = input.mesh.indices !== void 0 && submesh.indexCount > 0;
+    const elementCount = indexed ? submesh.indexCount : submesh.vertexCount;
+    if (elementCount === 0) continue;
+    sawNonEmpty = true;
+    if (component === "Lines" && submesh.topology === "line-strip") {
+      return err(
+        new PointsLinesStyleUnsupportedError({
+          lane: "admission",
+          field: "topology",
+          member: "line-strip",
+          supported: ["line-list"]
+        })
+      );
+    }
+    if (submesh.topology !== expected) {
+      return topologyMismatch(input, submeshIndex, expected, submesh.topology);
+    }
+    if (component === "Lines" && elementCount % 2 !== 0) {
+      return topologyMismatch(input, submeshIndex, "line-list pairs", "line-list odd tail");
+    }
+    acceptedSubmeshes.push(submeshIndex);
+    if (component === "Points") pointCount += elementCount;
+    else segmentCount += elementCount / 2;
+  }
+  if (!sawNonEmpty) return topologyMismatch(input, 0, expected, "empty-range");
+  return ok({ pointCount, segmentCount, submeshes: acceptedSubmeshes });
+}
+function checkMaterial(input) {
+  const passes = input.material.passes ?? [];
+  const unlitModules = /* @__PURE__ */ new Set(["forgeax_material::unlit", "forgeax::default-unlit"]);
+  if (passes.length !== 1 || passes[0] === void 0) {
+    const pass2 = passes.find(
+      (candidate) => candidate.name === "deferred" || candidate.name === "shadow-caster"
+    ) ?? passes[0];
+    return err(
+      new PointsLinesMaterialUnsupportedError({
+        entity: input.entity,
+        material: input.materialId ?? "<anonymous>",
+        pass: pass2?.name ?? "<empty>",
+        module: pass2?.program.module ?? "<empty>",
+        reason: "points-lines admission requires one unlit forward pass"
+      })
+    );
+  }
+  const pass = passes[0];
+  const lightMode = pass.renderState?.tags?.LightMode;
+  if (!unlitModules.has(pass.program.module) || pass.name !== "forward" || lightMode === "ShadowCaster") {
+    return err(
+      new PointsLinesMaterialUnsupportedError({
+        entity: input.entity,
+        material: input.materialId ?? "<anonymous>",
+        pass: pass.name,
+        module: pass.program.module,
+        reason: "points-lines admission requires an engine-owned unlit forward pass"
+      })
+    );
+  }
+  return ok(void 0);
+}
+function admitPointsLines(input) {
+  const style = checkStyle(input);
+  if (!style.ok) return style;
+  const topology = checkTopology(input, style.value.component);
+  if (!topology.ok) return topology;
+  const material = checkMaterial(input);
+  if (!material.ok) return material;
+  if (style.value.component === "Points" && input.limits?.maxPoints !== void 0) {
+    if (topology.value.pointCount > input.limits.maxPoints) {
+      return err(
+        new PointsLinesBudgetExceededError({
+          lane: "admission",
+          requested: topology.value.pointCount,
+          limit: input.limits.maxPoints,
+          unit: "points"
+        })
+      );
+    }
+  }
+  if (style.value.component === "Lines" && input.limits?.maxSegments !== void 0) {
+    if (topology.value.segmentCount > input.limits.maxSegments) {
+      return err(
+        new PointsLinesBudgetExceededError({
+          lane: "admission",
+          requested: topology.value.segmentCount,
+          limit: input.limits.maxSegments,
+          unit: "segments"
+        })
+      );
+    }
+  }
+  return ok({ ...style.value, ...topology.value });
+}
+function resolveVisibility(world, hierarchy = projectHierarchy(world)) {
+  const query = world.query({ read: [Entity], optional: [Visibility] });
+  let intentCount = 0;
+  let hasAnyHiddenIntent = false;
+  if (query.ok) {
+    for (const row of query.value) {
+      const visibility = row.get(Visibility);
+      if (visibility === void 0) continue;
+      intentCount += 1;
+      if (visibility.state === VisibilityStateValue.hidden) {
+        hasAnyHiddenIntent = true;
+      }
+    }
+  }
+  let resolveEntity;
+  let hasIntent;
+  const ensureResolver = () => {
+    if (resolveEntity !== void 0) return;
+    const intentByEntity = /* @__PURE__ */ new Map();
+    if (query.ok) {
+      for (const row of query.value) {
+        const raw = row.get(Visibility);
+        const intent = raw === void 0 ? void 0 : visibilityStateFromU32(raw.state);
+        if (intent !== void 0) {
+          intentByEntity.set(row.entity, intent);
+        }
+      }
+    }
+    hasIntent = (entity) => intentByEntity.has(entity);
+    const resolved = /* @__PURE__ */ new Map();
+    const resolving = /* @__PURE__ */ new Set();
+    resolveEntity = (entity) => {
+      const existing = resolved.get(entity);
+      if (existing !== void 0) return existing;
+      if (resolving.has(entity)) return void 0;
+      const intent = intentByEntity.get(entity) ?? "inherited";
+      resolving.add(entity);
+      let result;
+      if (intent === "hidden") {
+        result = { intent, effective: "hidden", source: "self" };
+      } else if (intent === "visible") {
+        result = { intent, effective: "visible", source: "self" };
+      } else {
+        const parent = hierarchy.getParent(entity);
+        const parentResult = parent === void 0 ? void 0 : resolveEntity?.(parent);
+        result = parentResult === void 0 ? { intent, effective: "visible", source: "default" } : { intent, effective: parentResult.effective, source: "parent" };
+      }
+      resolving.delete(entity);
+      resolved.set(entity, result);
+      return result;
+    };
+  };
+  return {
+    diagnostics: hierarchy.diagnostics,
+    hasAnyIntent: intentCount > 0,
+    hasAnyHiddenIntent,
+    get(entity) {
+      ensureResolver();
+      return hasIntent?.(entity) ? resolveEntity?.(entity) : void 0;
+    },
+    effective(entity) {
+      ensureResolver();
+      return resolveEntity?.(entity)?.effective ?? "visible";
+    }
+  };
+}
+
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CLUSTER_GRID_STRIDE_U32, Camera, DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, DirectionalLight, EquirectProjectionFailedError, FrameReceiptStaleError, HdrpDeferredCapsInsufficientError, HdrpIndexListOverflowError, HdrpLightBudgetExceededError, Instances, LIGHT_INDEX_LIST_CAPACITY, Layer, LifecycleConstructionError, Lines, MAX_LIGHTS, MaterialSkinAttrMissingError, MeshFilter, MeshRenderer, ObservationUnavailableError, PointLight, PointLightShadow, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointShapeValue, Points, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PostProcessParams, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RendererContractFailureError, RendererOperationError, SKYBOX_MODE_CUBEMAP, STANDARD_LIGHT_COUNTS, STANDARD_PIPELINE_ID, STANDARD_TONEMAP_FEATURE_ID, SceneInstance, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, SkyboxBackground, Skylight, SortKey, SpotLight, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, VertexColorVariantConflictError, VideoUploadUnsupportedError, Visibility, VisibilityStateValue, admitPointsLines, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, orthographic, perspective, pointShapeFromU32, resolveStandardLane, resolveVisibility, tonemapFromF32, tonemapToU32, visibilityStateFromU32 };
+//# sourceMappingURL=chunk-YEJIUW7D.mjs.map
+//# sourceMappingURL=chunk-YEJIUW7D.mjs.map