@forgeax/engine-render 0.1.7 → 0.1.20

package/dist/{chunk-YEJIUW7D.mjs → chunk-TBQJOK2L.mjs}

@@ -1,7 +1,4 @@
-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 {
@@ -15,6 +12,17 @@ var LifecycleConstructionError = class extends Error {
     this.detail = detail;
   }
 };
+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;
@@ -205,6 +213,17 @@ var MaterialSkinAttrMissingError = class extends Error {
     this.detail = { entity, missing };
   }
 };
+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}'`,
@@ -335,6 +354,26 @@ var ObservationUnavailableError = class extends Error {
     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";
@@ -357,6 +396,75 @@ var RendererContractFailureError = class extends Error {
     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 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",
@@ -494,349 +602,246 @@ var PointsLinesPrepareFailedError = class extends Error {
     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";
+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 };
   }
-}
-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;
+};
+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 };
   }
-  throw new RangeError(`Invalid tonemap mode: ${String(mode)}.`);
+};
+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 };
+  }
+};
+
+// src/temporal/scene-data.ts
+var SCENE_DATA_TEMPORAL_V1_SCHEMA = "forgeax::scene-data::temporal-v1";
+var SCENE_DATA_TEMPORAL_V1_DESCRIPTOR = Object.freeze({
+  schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
+  format: "rgba16float",
+  sampleCount: 1,
+  extent: "render-resolution",
+  clearValue: [0, 0, -1, 1],
+  channels: Object.freeze({
+    motionUv: "rg",
+    viewDepth: "b-log2-1-plus-depth",
+    reactive: "a"
+  })
+});
+var targetOwners = /* @__PURE__ */ new WeakMap();
+function registerSceneDataTarget(target, owner) {
+  targetOwners.set(target, owner);
 }
-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).`
-  );
+function sceneDataTargetOwner(target) {
+  return typeof target === "object" && target !== null ? targetOwners.get(target) : void 0;
 }
-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).`
-  );
+function sceneDataTokenMismatch(operation, reason, owner, target) {
+  const detail = reason === "generation-mismatch" ? {
+    featureIdentity: owner.featureIdentity,
+    order: -1,
+    stage: "contribute",
+    operation,
+    resourceKind: "attachment",
+    reason,
+    expectedGeneration: owner.generation,
+    actualGeneration: targetOwners.get(target)?.generation ?? -1,
+    recovery: "renderer-recover"
+  } : reason === "foreign-feature" ? {
+    featureIdentity: owner.featureIdentity,
+    order: -1,
+    stage: "contribute",
+    operation,
+    resourceKind: "attachment",
+    reason,
+    expectedFeatureIdentity: owner.featureIdentity,
+    actualFeatureIdentity: targetOwners.get(target)?.featureIdentity ?? "unknown",
+    recovery: "next-frame"
+  } : reason === "foreign-kind" ? {
+    featureIdentity: owner.featureIdentity,
+    order: -1,
+    stage: "contribute",
+    operation,
+    resourceKind: "attachment",
+    reason,
+    expectedKind: "attachment",
+    actualKind: "pipeline",
+    recovery: "next-frame"
+  } : {
+    featureIdentity: owner.featureIdentity,
+    order: -1,
+    stage: "contribute",
+    operation,
+    resourceKind: "attachment",
+    reason,
+    expectedLayout: "sampled-read-temporal-v1",
+    actualLayout: target?.access ?? "unknown",
+    recovery: "next-frame"
+  };
+  return new RenderFeaturePreparedStateMismatchError(detail);
 }
-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 isSceneDataTarget(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.kind === "scene-data" && candidate.schema === SCENE_DATA_TEMPORAL_V1_SCHEMA && candidate.access === "sampled-read" && candidate.format === "rgba16float" && candidate.sampleCount === 1 && candidate.extent === "render-resolution" && targetOwners.has(value);
 }
-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 sceneDataTargetAsAttachment(_target) {
+  throw new TypeError("SceneDataTarget is sampled-read-only and cannot be used as an attachment");
 }
-function orthographic(opts) {
+function sceneDataError(error) {
+  return error;
+}
+function availability(options) {
+  if (options.recovering) return { status: "unavailable", reason: "renderer-recovering" };
+  if (!options.rgba16floatRenderable)
+    return { status: "unavailable", reason: "capability-missing" };
+  if (options.producerPresent === false)
+    return { status: "unavailable", reason: "producer-missing" };
+  if (options.coverageComplete === false)
+    return { status: "unavailable", reason: "coverage-incomplete" };
   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
+    status: "available",
+    completeness: options.reactiveFallback ? "exact-with-reactive-fallback" : "exact"
   };
 }
-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;
-  }
+function createTarget(owner) {
+  const target = Object.freeze({
+    kind: "scene-data",
+    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
+    access: "sampled-read",
+    format: "rgba16float",
+    sampleCount: 1,
+    extent: "render-resolution"
+  });
+  registerSceneDataTarget(target, {
+    featureIdentity: owner.featureIdentity,
+    planIdentity: owner.planIdentity,
+    generation: owner.generation
+  });
+  return target;
 }
-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;
-  }
+function tokenError(catalog, operation) {
+  return sceneDataTokenMismatch(
+    operation,
+    "foreign-kind",
+    {
+      featureIdentity: catalog.featureIdentity,
+      planIdentity: catalog.planIdentity,
+      generation: catalog.generation
+    },
+    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."
+function unavailableError(options, reason) {
+  const recovery = reason === "capability-missing" ? "enable-capability" : reason === "renderer-recovering" ? "renderer-recover" : "next-frame";
+  return new SceneDataUnavailableError({
+    featureIdentity: options.featureIdentity,
+    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
+    lane: options.lane ?? "direct",
+    reason,
+    missingContributorIds: options.missingContributorIds ?? [],
+    omittedMissingContributorCount: 0,
+    recovery
+  });
+}
+function createSceneDataCatalog(options) {
+  const state = availability(options);
+  const owner = {
+    featureIdentity: options.featureIdentity,
+    planIdentity: options.planIdentity,
+    generation: options.generation
+  };
+  const missing = [...options.missingContributorIds ?? []];
+  const inspectionBase = {
+    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
+    generation: options.generation,
+    planIdentity: options.planIdentity,
+    lane: options.lane ?? "direct",
+    missingContributorIds: Object.freeze(missing.slice(0, 32)),
+    omittedMissingContributorCount: Math.max(0, missing.length - 32)
+  };
+  return {
+    schema: SCENE_DATA_TEMPORAL_V1_SCHEMA,
+    generation: options.generation,
+    planIdentity: options.planIdentity,
+    availability: state,
+    require(schema) {
+      if (schema !== SCENE_DATA_TEMPORAL_V1_SCHEMA || state.status !== "available") {
+        if (state.status === "unavailable") throw unavailableError(options, state.reason);
+        throw tokenError(options, "require scene-data target");
+      }
+      return createTarget(options);
+    },
+    validate(target, generation = options.generation) {
+      const targetOwner = sceneDataTargetOwner(target);
+      if (targetOwner === void 0) {
+        return err(
+          sceneDataTokenMismatch("validate scene-data target", "foreign-feature", owner, target)
+        );
+      }
+      if (targetOwner.planIdentity !== owner.planIdentity || targetOwner.featureIdentity !== owner.featureIdentity) {
+        return err(
+          sceneDataTokenMismatch("validate scene-data target", "foreign-feature", owner, target)
+        );
+      }
+      if (generation !== owner.generation || targetOwner.generation !== owner.generation) {
+        return err(
+          sceneDataTokenMismatch(
+            "validate scene-data target",
+            "generation-mismatch",
+            owner,
+            target
+          )
+        );
+      }
+      if (target.access !== "sampled-read") {
+        return err(
+          sceneDataTokenMismatch("validate scene-data target", "layout-mismatch", owner, target)
+        );
+      }
+      return ok(target);
+    },
+    inspect() {
+      return Object.freeze(
+        state.status === "available" ? { ...inspectionBase, status: state.status, completeness: state.completeness } : { ...inspectionBase, status: state.status, reason: state.reason }
+      );
     }
-  }
-);
+  };
+}
 
 // src/pipeline/standard-profile.ts
 var STANDARD_PIPELINE_ID = "forgeax::standard";
@@ -845,6 +850,14 @@ 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 STANDARD_POST_STAGE_NAMES = [
+  "transparent-blend",
+  "bloom",
+  "output-transform",
+  "fxaa",
+  "post-effect",
+  "present"
+];
 var DEFAULT_STANDARD_PROFILE = Object.freeze({
   pipelineId: STANDARD_PIPELINE_ID,
   lightCount: 32,
@@ -858,15 +871,18 @@ var DEFAULT_STANDARD_PROFILE = Object.freeze({
   antialias: "fxaa",
   sky: true,
   fallback: "native",
-  postStages: ["transparent-blend", "bloom", "tone", "fxaa", "output"]
+  postStages: STANDARD_POST_STAGE_NAMES
 });
+function resolveVolumetricFogProfile(profile) {
+  return profile.volumetricFog ?? { quality: "high", depth: 64, tileSize: 4 };
+}
 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 STANDARD_OUTPUT_TRANSFORM_FEATURE_ID = "forgeax::standard::output-transform";
 var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   "record/graph-execute/point-shadow",
   "record/graph-execute/cluster-binner-upload",
@@ -883,7 +899,8 @@ var RENDER_GRAPH_EXECUTION_PHASE_CATALOG = [
   "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/output-transform",
+  "record/graph-execute/present",
   "record/graph-execute/debug-overlay",
   "record/graph-execute/shadow",
   "record/graph-execute/spot-shadow",
@@ -942,211 +959,7 @@ var RENDER_PHASE_CATALOG = [
   "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
+export { AtmosphereInvalidParameterError, CLUSTER_GRID_STRIDE_U32, DEFAULT_CLUSTER_GRID, DEFAULT_STANDARD_PROFILE, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, EquirectProjectionFailedError, FogCardinalityError, FrameReceiptStaleError, HdrpDeferredCapsInsufficientError, HdrpIndexListOverflowError, HdrpLightBudgetExceededError, LIGHT_INDEX_LIST_CAPACITY, LifecycleConstructionError, MAX_LIGHTS, MaterialSkinAttrMissingError, ObservationUnavailableError, OwnerStageFailedError, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PointsLinesBudgetExceededError, PointsLinesInvalidStyleError, PointsLinesMaterialUnsupportedError, PointsLinesPrepareFailedError, PointsLinesStyleUnsupportedError, PointsLinesTopologyMismatchError, RENDER_PHASE_CATALOG, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, RendererContractFailureError, RendererOperationError, SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, STANDARD_LIGHT_COUNTS, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, STANDARD_PIPELINE_ID, STANDARD_POST_STAGE_NAMES, SceneDataUnavailableError, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, TaaCapsInsufficientError, TemporalFrameSubmitError, TransmissionCapabilityMissingError, VertexColorVariantConflictError, VideoUploadUnsupportedError, VolumeDensityShapeMismatchError, VolumeInvalidBoundsError, VolumeInvalidParametersError, VolumeOwnerConflictError, createSceneDataCatalog, isSceneDataTarget, registerSceneDataTarget, resolveStandardLane, resolveVolumetricFogProfile, sceneDataError, sceneDataTargetAsAttachment, sceneDataTargetOwner, sceneDataTokenMismatch };
+//# sourceMappingURL=chunk-TBQJOK2L.mjs.map
+//# sourceMappingURL=chunk-TBQJOK2L.mjs.map