@forgeax/engine-render 0.1.4 → 0.1.6

package/dist/chunk-DJIMFYX6.mjs

@@ -1,1439 +0,0 @@
-import { defineComponent } from '@forgeax/engine-ecs';
-import { err, ok, TextError, unpackSlot } from '@forgeax/engine-types';
-import { TONEMAP_SHADER_MODE } from '@forgeax/engine-shader';
-import { PROCEDURAL_FLOATS_PER_VERTEX } from '@forgeax/engine-geometry';
-import { resetFontConcurrency, trackFontConcurrency, layoutGlyphText, conservativeCubeAabb, bakeGlyphMesh } from '@forgeax/engine-graphics-extras';
-import { ResourceInvalidValueError } from '@forgeax/engine-ecs/projection';
-export { ResourceInvalidValueError, SpawnLightInvalidBoundsError, SpriteInstancesCountMismatchError, SpriteInstancesMutuallyExclusiveWithInstancesError, SpriteInstancesRequiresSpriteShaderError } from '@forgeax/engine-ecs/projection';
-
-// src/components/glyph-text.ts
-var GlyphText = defineComponent("GlyphText", {
-  // The layout/render owner re-resolves the font asset on the target world;
-  // authoring text and style remain portable simulation state.
-  fontHandle: {
-    type: "shared<FontAsset>",
-    default: 0
-  },
-  text: { type: "string", default: "" },
-  fontSize: { type: "f32", default: 16 },
-  // color carries an explicit layer-2 default [1,1,1,1] (opaque white); the
-  // array layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
-  color: { type: "array<f32, 4>", default: new Float32Array([1, 1, 1, 1]) }
-});
-var SpriteAnimation = defineComponent("SpriteAnimation", {
-  frameCount: { type: "u32" },
-  frameDuration: { type: "f32" },
-  currentFrame: { type: "u32", transient: true },
-  accumDt: { type: "f32", transient: true },
-  regions: { type: "array<f32>" },
-  playbackMode: { type: "u32" }
-});
-var SpriteInstances = defineComponent("SpriteInstances", {
-  transforms: { type: "array<f32>" },
-  regions: { type: "array<f32>" }
-});
-
-// src/components/sprite-playback-mode.ts
-var SPRITE_PLAYBACK_MODE_LOOP = 0;
-var SPRITE_PLAYBACK_MODE_CLAMP = 1;
-function spritePlaybackModeFromU32(value) {
-  return value === SPRITE_PLAYBACK_MODE_CLAMP ? "clamp" : "loop";
-}
-var SpriteRegionOverride = defineComponent("SpriteRegionOverride", {
-  region: { type: "array<f32, 4>" }
-});
-function encodeSortScope(scope) {
-  switch (scope) {
-    case "layer":
-      return 0;
-    case "per-cell":
-      return 1;
-  }
-}
-function decodeSortScope(raw) {
-  return raw === 1 ? "per-cell" : "layer";
-}
-var TileLayer = defineComponent("TileLayer", {
-  tiles: { type: "array<u32>" },
-  layerOrder: { type: "i32", default: 0 },
-  dirty: { type: "u8", default: 0 },
-  sortScope: { type: "u8", default: 0 }
-});
-function markTileLayerDirty(world, layerEntity) {
-  return world.set(layerEntity, TileLayer, { dirty: 1 });
-}
-var Tilemap = defineComponent("Tilemap", {
-  cols: { type: "u32", default: 0 },
-  rows: { type: "u32", default: 0 },
-  // tileSize carries an explicit layer-2 default [1,1] (unit cell); the array
-  // layer-3 fallback is all-zero, so the default MUST be explicit (D-5).
-  tileSize: { type: "array<f32, 2>", default: new Float32Array([1, 1]) },
-  chunkSize: { type: "u32", default: 16 },
-  tileset: { type: "string" }
-});
-
-// src/errors/render.ts
-var FogOwnerConflictError = class extends Error {
-  code = "fog-owner-conflict";
-  expected = "resourceOwner contains zero or one Fog entity";
-  hint = "remove every Fog entity except one from the resourceOwner World, then retry draw";
-  detail;
-  constructor(resourceOwner, entities, omitted) {
-    super(
-      `Fog owner conflict in resourceOwner ${resourceOwner}: ${entities.length + omitted} entities`
-    );
-    this.name = "FogOwnerConflictError";
-    this.detail = {
-      resourceOwner,
-      entities: [...entities],
-      omitted
-    };
-  }
-};
-var FogParametersInvalidError = class extends Error {
-  code = "fog-parameters-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(entity, field, expected, actual) {
-    super(`Fog.${field} is invalid on entity ${entity}`);
-    this.name = "FogParametersInvalidError";
-    this.expected = expected;
-    this.hint = `set Fog.${field} to ${expected} on entity ${entity}, then retry draw`;
-    this.detail = { entity, field, expected, actual };
-  }
-};
-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 HdrpCapsInsufficientError = class extends Error {
-  code = "hdrp-caps-insufficient";
-  expected;
-  hint;
-  detail;
-  constructor(capName, actual, required) {
-    const expected = `${capName} >= ${required}`;
-    const hint = `${capName} = ${actual} (need >= ${required}); this device does not have enough storage buffer slots for HDRP cluster-forward rendering. Fall back to URP by not calling installPipeline(hdrpAsset)`;
-    super(`HDRP caps insufficient: ${capName} = ${actual} (need >= ${required})`);
-    this.name = "HdrpCapsInsufficientError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { capName, actual, required };
-  }
-};
-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 GbufferRtAllocFailedError = class extends Error {
-  code = "gbuffer-rt-alloc-failed";
-  expected;
-  hint;
-  detail;
-  constructor(attachmentIndex, requestedBytes) {
-    const expected = "g-buffer color target allocation succeeded";
-    const hint = `g-buffer color target (attachment ${attachmentIndex}, ${requestedBytes} bytes) allocation failed. Common causes: (a) GPU memory pressure; (b) framebuffer resolution too large; (c) RHI backend limits hit. Check device.limits and reduce frame resolution.`;
-    super(`g-buffer RT alloc failed: attachment[${attachmentIndex}] = ${requestedBytes} bytes`);
-    this.name = "GbufferRtAllocFailedError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { attachmentIndex, requestedBytes };
-  }
-};
-var GbufferAttachmentCountMismatchError = class extends Error {
-  code = "gbuffer-attachment-count-mismatch";
-  expected;
-  hint;
-  detail;
-  constructor(actual) {
-    const _expected = 3;
-    const _expectedStr = `exactly ${_expected} g-buffer color attachments`;
-    const hint = `HDRP deferred expects ${_expected} g-buffer color attachments, got ${actual}. Check hdrp-pipeline internal schema or custom g-buffer override.`;
-    super(`g-buffer attachment count mismatch: got ${actual}, expected ${_expected}`);
-    this.name = "GbufferAttachmentCountMismatchError";
-    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 VertexStorageBufferUnavailableError = class extends Error {
-  code = "vertex-storage-buffer-unavailable";
-  expected;
-  hint;
-  constructor() {
-    const expected = "device.caps supports vertex-stage storage buffer (maxStorageBuffersPerShaderStage >= 1)";
-    const hint = "this device does not support vertex-stage storage buffers; skinning requires vertex-stage storage buffer access (OOS-uniform-palette fallback not implemented)";
-    super("vertex-stage storage buffer unavailable \u2014 skinning cannot operate");
-    this.name = "VertexStorageBufferUnavailableError";
-    this.expected = expected;
-    this.hint = hint;
-  }
-};
-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 RenderFeaturePassOrderConflictError = class extends Error {
-  code = "render-feature-pass-order-conflict";
-  expected;
-  hint;
-  detail;
-  constructor(featureIdentity, order, passIdentity, dependencyIdentity) {
-    const expected = `feature pass '${passIdentity}' follows dependency '${dependencyIdentity}'`;
-    const hint = `reorder '${featureIdentity}' passes so '${passIdentity}' follows '${dependencyIdentity}'`;
-    super(`render feature '${featureIdentity}' pass order conflict`);
-    this.name = "RenderFeaturePassOrderConflictError";
-    this.expected = expected;
-    this.hint = hint;
-    this.detail = { featureIdentity, order, passIdentity, dependencyIdentity };
-  }
-};
-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 TaaCapsInsufficientError = class extends Error {
-  code = "taa-caps-insufficient";
-  expected = "rgba16floatRenderable and maxColorAttachments >= 2";
-  hint = "select a device with rgba16float render targets and at least two color attachments, then rebuild the renderer";
-  detail;
-  constructor(rgba16floatRenderable, maxColorAttachments) {
-    super(
-      `TAA capabilities insufficient: rgba16floatRenderable=${rgba16floatRenderable}, maxColorAttachments=${maxColorAttachments}`
-    );
-    this.name = "TaaCapsInsufficientError";
-    this.detail = {
-      rgba16floatRenderable,
-      maxColorAttachments,
-      recovery: "enable-temporal-capabilities"
-    };
-  }
-};
-var TemporalUnsupportedError = class extends Error {
-  code = "temporal-unsupported";
-  expected;
-  hint = "call resolveTemporal exactly once after temporal raster and pass single-sample rgba16float scene and temporal targets";
-  detail;
-  constructor(reason, expected, actual) {
-    super(`temporal pipeline unsupported: ${reason}; expected ${expected}, got ${actual}`);
-    this.name = "TemporalUnsupportedError";
-    this.expected = expected;
-    this.detail = { reason, actual, recovery: "fix-temporal-pipeline-topology" };
-  }
-};
-var AtmosphereParameterInvalidError = class extends Error {
-  code = "atmosphere-parameter-invalid";
-  expected;
-  hint;
-  detail;
-  constructor(field, value, min, max, minExclusive = false) {
-    const lower = minExclusive ? `>${min}` : `>=${min}`;
-    super(`Atmosphere.${field} must be ${lower} and <=${max}; got ${value}`);
-    this.name = "AtmosphereParameterInvalidError";
-    this.expected = `${field} ${lower} and <=${max}`;
-    this.hint = `set Atmosphere.${field} to a finite value in the accepted range; got ${value}`;
-    this.detail = { field, value, min, max, minExclusive };
-  }
-};
-var AtmosphereCardinalityInvalidError = class extends Error {
-  code = "atmosphere-cardinality-invalid";
-  expected = "exactly one Atmosphere component in the resourceOwner World";
-  hint = "remove extra Atmosphere entities and keep one analytic source";
-  detail;
-  constructor(count, entities) {
-    super(`Atmosphere cardinality exceeded: ${count} entities (max 1)`);
-    this.name = "AtmosphereCardinalityInvalidError";
-    this.detail = { count, max: 1, entities: [...entities] };
-  }
-};
-var AtmosphereSunMissingError = class extends Error {
-  code = "atmosphere-sun-missing";
-  expected = "Atmosphere and DirectionalLight share one entity";
-  hint = "add a valid DirectionalLight to the Atmosphere entity";
-  detail;
-  constructor(atmosphereEntity) {
-    super(`Atmosphere entity ${atmosphereEntity} has no co-located DirectionalLight`);
-    this.name = "AtmosphereSunMissingError";
-    this.detail = { atmosphereEntity };
-  }
-};
-var EnvironmentSourceConflictError = class extends Error {
-  code = "environment-source-conflict";
-  expected = "exactly one image or atmosphere environment source";
-  hint = "remove either the image environment or the Atmosphere source";
-  detail;
-  constructor(atmosphereEntities, imageEntities) {
-    super("image and Atmosphere environment sources cannot coexist");
-    this.name = "EnvironmentSourceConflictError";
-    this.detail = {
-      atmosphereEntities: [...atmosphereEntities],
-      imageEntities: [...imageEntities]
-    };
-  }
-};
-var AtmosphereCapsInsufficientError = class extends Error {
-  code = "atmosphere-caps-insufficient";
-  expected;
-  hint = "select a backend with the required HDR render and sample capabilities";
-  detail;
-  constructor(capability, actual, required) {
-    super(`Atmosphere capability ${capability} is insufficient: ${actual}; required ${required}`);
-    this.name = "AtmosphereCapsInsufficientError";
-    this.expected = `${capability} >= ${required}`;
-    this.detail = { capability, actual, required };
-  }
-};
-var AtmosphereProducerFailedError = class extends Error {
-  code = "atmosphere-producer-failed";
-  expected = "candidate atmosphere generation builds, executes, and submits atomically";
-  hint = "retain the last-known-good generation, inspect the stage, and retry after repair";
-  detail;
-  constructor(stage, reason, generation) {
-    super(`Atmosphere producer ${stage} failed: ${reason}`);
-    this.name = "AtmosphereProducerFailedError";
-    this.detail = { stage, reason, ...generation === void 0 ? {} : { generation } };
-  }
-};
-function materialDrawDiagnostic(error) {
-  const detail = error.error.detail;
-  const generation = detail.publicationGeneration;
-  return {
-    key: `${detail.guid}::${detail.specializationKey}::${generation ?? "unknown"}`,
-    code: error.error.code,
-    materialGuid: detail.guid,
-    specializationKey: detail.specializationKey,
-    ...generation === void 0 ? {} : { publicationGeneration: generation },
-    expected: error.error.expected,
-    ...detail.actual === void 0 ? {} : { actual: detail.actual },
-    hint: error.error.hint,
-    retryable: error.error.retryable,
-    recoveryActions: error.error.recoveryActions
-  };
-}
-var MeshSsboCeilingReachedError = class extends Error {
-  code = "mesh-ssbo-ceiling-reached";
-  expected;
-  hint;
-  detail;
-  constructor(requested, capacity, ceiling) {
-    super(`mesh SSBO request ${requested} exceeds device ceiling ${ceiling}`);
-    this.name = "MeshSsboCeilingReachedError";
-    this.expected = `mesh SSBO capacity remains within ${ceiling} bytes`;
-    this.hint = "reduce per-frame renderable count or split the workload across frames";
-    this.detail = { requested, capacity, ceiling };
-  }
-};
-var MeshSsboCapacityExceededError = class extends Error {
-  code = "mesh-ssbo-capacity-exceeded";
-  expected;
-  hint;
-  detail;
-  constructor(requested, capacity, ceiling) {
-    super(`mesh SSBO capacity ${capacity} cannot satisfy request ${requested}`);
-    this.name = "MeshSsboCapacityExceededError";
-    this.expected = `mesh SSBO capacity >= ${requested} slots`;
-    this.hint = "reduce per-frame renderable count or split the workload across frames";
-    this.detail = { requested, capacity, ceiling };
-  }
-};
-var Atmosphere = defineComponent("Atmosphere", {
-  turbidity: { type: "f32", default: 2 },
-  rayleigh: { type: "f32", default: 1 },
-  mieCoefficient: { type: "f32", default: 5e-3 },
-  mieDirectionalG: { type: "f32", default: 0.8 },
-  sunAngularRadius: { type: "f32", default: 4675e-6 }
-});
-var ATMOSPHERE_CHECKS = [
-  { field: "turbidity", min: 1, max: 20 },
-  { field: "rayleigh", min: 0, max: 4 },
-  { field: "mieCoefficient", min: 0, max: 0.1 },
-  { field: "mieDirectionalG", min: 0, max: 0.999 },
-  { field: "sunAngularRadius", min: 0, max: 0.02, minExclusive: true }
-];
-function validateAtmosphereData(data) {
-  for (const check of ATMOSPHERE_CHECKS) {
-    const reflectedDefault = Atmosphere.fields[check.field]?.default;
-    const rawValue = data[check.field] ?? reflectedDefault;
-    const value = typeof rawValue === "number" ? rawValue : Number.NaN;
-    if (!Number.isFinite(value)) {
-      return err(
-        new AtmosphereParameterInvalidError(
-          check.field,
-          value,
-          check.min,
-          check.max,
-          check.minExclusive ?? false
-        )
-      );
-    }
-    if ((check.minExclusive ? value <= check.min : value < check.min) || value > check.max) {
-      return err(
-        new AtmosphereParameterInvalidError(
-          check.field,
-          value,
-          check.min,
-          check.max,
-          check.minExclusive ?? false
-        )
-      );
-    }
-  }
-  return ok(void 0);
-}
-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 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 Fog = defineComponent("Fog", {
-  color: { type: "array<f32, 3>", default: new Float32Array([0.5, 0.5, 0.5]) },
-  density: { type: "f32", default: 0.01 },
-  heightFalloff: { type: "f32", default: 0 },
-  maxOpacity: { type: "f32", default: 1 }
-});
-var SKYBOX_MODE_CUBEMAP = 0;
-function skyboxModeFromF32(value) {
-  switch (value) {
-    case SKYBOX_MODE_CUBEMAP:
-      return "cubemap";
-  }
-  return "cubemap";
-}
-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 Instances = defineComponent("Instances", {
-  transforms: { type: "array<f32>" }
-});
-var Layer = defineComponent("Layer", {
-  value: { type: "i32", default: 0 }
-});
-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 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 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/materials.ts
-var SPRITE_PREMULTIPLIED_ALPHA_BLEND = {
-  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
-  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
-};
-var STANDARD_MODULE = "forgeax_material::standard";
-var UNLIT_MODULE = "forgeax_material::unlit";
-function materialTextureValue(value) {
-  if (value === void 0) return void 0;
-  if (typeof value === "string") return value;
-  if (typeof value === "number") {
-    return { texture: value };
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
-  return value;
-}
-function authoredColorParameter(name, type, colorSpace, optional = false) {
-  return {
-    name,
-    type,
-    ...type === "color" && colorSpace === "srgb" ? {} : { colorSpace },
-    ...optional ? { optional: true } : {}
-  };
-}
-function standardParameters(colorSpace) {
-  return [
-    authoredColorParameter("baseColor", "color", colorSpace),
-    { name: "metallic", type: "f32" },
-    { name: "roughness", type: "f32" },
-    { name: "metallicChannel", type: "f32", optional: true },
-    { name: "roughnessChannel", type: "f32", optional: true },
-    { name: "aoChannel", type: "f32", optional: true },
-    { name: "extraChannel", type: "f32", optional: true },
-    authoredColorParameter("emissive", "vec3", colorSpace, true),
-    { name: "emissiveIntensity", type: "f32", optional: true },
-    { name: "occlusionStrength", type: "f32", optional: true },
-    { name: "alphaCutoff", type: "f32", optional: true },
-    { name: "clearcoat", type: "f32", optional: true },
-    { name: "clearcoatRoughness", type: "f32", optional: true },
-    authoredColorParameter("specularTint", "vec3", colorSpace, true),
-    { name: "baseColorTexture", type: "texture", optional: true },
-    { name: "metallicRoughnessTexture", type: "texture", optional: true },
-    { name: "normalTexture", type: "texture", optional: true },
-    { name: "specularTintTexture", type: "texture", optional: true },
-    { name: "emissiveTexture", type: "texture", optional: true },
-    { name: "occlusionTexture", type: "texture", optional: true }
-  ];
-}
-function unlitParameters(colorSpace) {
-  return [
-    authoredColorParameter("baseColor", "color", colorSpace),
-    { name: "alphaCutoff", type: "f32", optional: true },
-    { name: "baseColorTexture", type: "texture", optional: true }
-  ];
-}
-function pass(name, module, renderState, fragmentEntry, queue) {
-  const lightMode = name === "shadow-caster" ? "ShadowCaster" : name === "deferred" ? "Deferred" : "Forward";
-  const authoredState = renderState ?? {};
-  const authoredTags = authoredState.tags;
-  return {
-    name,
-    program: {
-      module,
-      ...fragmentEntry === void 0 ? {} : { fragmentEntry }
-    },
-    renderState: {
-      ...authoredState,
-      tags: { LightMode: lightMode, ...authoredTags },
-      ...queue === void 0 ? {} : { queue }
-    }
-  };
-}
-function unlit(rgba, opts) {
-  if (opts?.alphaCutoff !== void 0 && (opts.alphaCutoff < 0 || opts.alphaCutoff > 1)) {
-    throw new Error(`Materials.unlit: alphaCutoff must be in [0, 1], got ${opts.alphaCutoff}`);
-  }
-  const values = { baseColor: rgba };
-  if (opts?.baseColorTexture !== void 0) {
-    values.baseColorTexture = materialTextureValue(opts.baseColorTexture);
-  }
-  if (opts?.alphaCutoff !== void 0) values.alphaCutoff = opts.alphaCutoff;
-  const passes = [
-    pass("forward", UNLIT_MODULE, opts?.renderState, void 0, opts?.queue)
-  ];
-  if (opts?.castShadow !== false) passes.push(pass("shadow-caster", UNLIT_MODULE, void 0));
-  return {
-    kind: "material",
-    ...opts?.colorSpace === void 0 || opts.colorSpace === "srgb" ? {} : { colorSpace: opts.colorSpace },
-    passes,
-    parameters: unlitParameters(opts?.colorSpace ?? "srgb"),
-    values
-  };
-}
-function validateChannel(name, value) {
-  if (value !== void 0 && (!Number.isInteger(value) || value < 0 || value > 3)) {
-    throw new Error(`Materials.standard: ${name} must be an integer in [0, 3], got ${value}`);
-  }
-}
-function standard(opts) {
-  const occlusionStrength = opts.occlusionStrength ?? 1;
-  if (occlusionStrength < 0 || occlusionStrength > 1) {
-    throw new Error(
-      `Materials.standard: occlusionStrength must be in [0, 1], got ${occlusionStrength}`
-    );
-  }
-  if (opts.alphaCutoff !== void 0 && (opts.alphaCutoff < 0 || opts.alphaCutoff > 1)) {
-    throw new Error(`Materials.standard: alphaCutoff must be in [0, 1], got ${opts.alphaCutoff}`);
-  }
-  validateChannel("metallicChannel", opts.metallicChannel);
-  validateChannel("roughnessChannel", opts.roughnessChannel);
-  const values = {
-    baseColor: opts.baseColor,
-    metallic: opts.metallic ?? 0,
-    roughness: opts.roughness ?? 0.5,
-    occlusionStrength,
-    specularTint: opts.specularTint ?? [1, 1, 1]
-  };
-  if (opts.metallicChannel !== void 0) values.metallicChannel = opts.metallicChannel;
-  if (opts.roughnessChannel !== void 0) values.roughnessChannel = opts.roughnessChannel;
-  if (opts.clearcoat !== void 0) values.clearcoat = opts.clearcoat;
-  if (opts.clearcoatRoughness !== void 0) values.clearcoatRoughness = opts.clearcoatRoughness;
-  if (opts.emissive !== void 0) values.emissive = opts.emissive;
-  if (opts.emissiveIntensity !== void 0) values.emissiveIntensity = opts.emissiveIntensity;
-  if (opts.emissiveTexture !== void 0)
-    values.emissiveTexture = materialTextureValue(opts.emissiveTexture);
-  if (opts.baseColorTexture !== void 0)
-    values.baseColorTexture = materialTextureValue(opts.baseColorTexture);
-  if (opts.metallicRoughnessTexture !== void 0) {
-    values.metallicRoughnessTexture = materialTextureValue(opts.metallicRoughnessTexture);
-  }
-  if (opts.normalTexture !== void 0)
-    values.normalTexture = materialTextureValue(opts.normalTexture);
-  if (opts.occlusionTexture !== void 0)
-    values.occlusionTexture = materialTextureValue(opts.occlusionTexture);
-  if (opts.specularTintTexture !== void 0) {
-    values.specularTintTexture = materialTextureValue(opts.specularTintTexture);
-  }
-  if (opts.alphaCutoff !== void 0) values.alphaCutoff = opts.alphaCutoff;
-  const passes = [
-    pass("forward", STANDARD_MODULE, opts.renderState, "fs_main", opts.queue),
-    pass("deferred", STANDARD_MODULE, opts.renderState, "fs_gbuffer", opts.queue)
-  ];
-  if (opts.castShadow !== false) passes.push(pass("shadow-caster", STANDARD_MODULE, void 0));
-  return {
-    kind: "material",
-    ...opts.colorSpace === void 0 || opts.colorSpace === "srgb" ? {} : { colorSpace: opts.colorSpace },
-    passes,
-    parameters: standardParameters(opts.colorSpace ?? "srgb"),
-    values
-  };
-}
-var Materials = { unlit, standard };
-
-// src/assets/resolve-render-asset.ts
-function resolveRenderAsset(world, handle) {
-  return world.sharedRefs.resolve(handle);
-}
-
-// src/glyph-text-layout-system.ts
-var bakeCache = /* @__PURE__ */ new WeakMap();
-var materialCache = /* @__PURE__ */ new WeakMap();
-var liveGlyphHandles = /* @__PURE__ */ new WeakMap();
-function resetGlyphBakeCache() {
-  bakeCache = /* @__PURE__ */ new WeakMap();
-  materialCache = /* @__PURE__ */ new WeakMap();
-  liveGlyphHandles = /* @__PURE__ */ new WeakMap();
-}
-function worldBakeCache(world) {
-  let cache = bakeCache.get(world);
-  if (cache === void 0) {
-    cache = /* @__PURE__ */ new Map();
-    bakeCache.set(world, cache);
-  }
-  return cache;
-}
-function worldMaterialCache(world) {
-  let cache = materialCache.get(world);
-  if (cache === void 0) {
-    cache = /* @__PURE__ */ new Map();
-    materialCache.set(world, cache);
-  }
-  return cache;
-}
-function releaseGlyphProducers(world, entity) {
-  const slot = unpackSlot(entity);
-  const bake = bakeCache.get(world)?.get(slot);
-  if (bake?.handle === entity) {
-    world.sharedRefs.release(asMeshHandle(bake.record.meshHandleId));
-    bakeCache.get(world)?.delete(slot);
-  }
-  const material = materialCache.get(world)?.get(slot);
-  if (material !== void 0) {
-    world.sharedRefs.release(asMaterialHandle(material));
-    materialCache.get(world)?.delete(slot);
-  }
-}
-function clearRejectedGlyphState(world, entity) {
-  const slot = unpackSlot(entity);
-  const bake = bakeCache.get(world)?.get(slot);
-  if (bake?.handle !== entity) return;
-  if (world.get(entity, MeshFilter).ok) world.removeComponent(entity, MeshFilter);
-  if (world.get(entity, MeshRenderer).ok) world.removeComponent(entity, MeshRenderer);
-  releaseGlyphProducers(world, entity);
-}
-var MSDF_TEXT_BLEND = {
-  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
-  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
-};
-function glyphTextLayoutSystem(world, gpuStore) {
-  resetFontConcurrency();
-  const entities = collectGlyphEntities(world);
-  const live = liveGlyphHandles.get(world) ?? /* @__PURE__ */ new Set();
-  live.clear();
-  for (const entity of entities) live.add(entity);
-  liveGlyphHandles.set(world, live);
-  for (const entry of worldBakeCache(world).values()) {
-    if (!live.has(entry.handle)) releaseGlyphProducers(world, entry.handle);
-  }
-  let firstError = null;
-  for (const entity of entities) {
-    const error = processEntity(world, gpuStore, entity);
-    if (error !== null && firstError === null) firstError = error;
-  }
-  if (firstError !== null) return err(firstError);
-  return ok(void 0);
-}
-function collectGlyphEntities(world) {
-  const query = world.query({ read: [GlyphText] });
-  if (!query.ok) return [];
-  const entities = [];
-  for (const row of query.value) entities.push(row.entity);
-  return entities;
-}
-function processEntity(world, gpuStore, entity) {
-  const gtRes = world.get(entity, GlyphText);
-  if (!gtRes.ok) return null;
-  const gt = gtRes.value;
-  if (gt.fontHandle === 0) return null;
-  try {
-    trackFontConcurrency(gt.fontHandle);
-  } catch (e) {
-    if (e instanceof TextError) {
-      clearRejectedGlyphState(world, entity);
-      return e;
-    }
-    throw e;
-  }
-  const fontRes = resolveRenderAsset(world, asFontHandle(gt.fontHandle));
-  if (!fontRes.ok) return null;
-  const font = fontRes.value;
-  const signature = signatureOf(gt);
-  const entityCache = worldBakeCache(world);
-  const slot = unpackSlot(entity);
-  const cachedEntry = entityCache.get(slot);
-  if (cachedEntry !== void 0 && cachedEntry.handle !== entity) {
-    world.sharedRefs.release(asMeshHandle(cachedEntry.record.meshHandleId));
-    const staleMaterial = worldMaterialCache(world).get(slot);
-    if (staleMaterial !== void 0) {
-      world.sharedRefs.release(asMaterialHandle(staleMaterial));
-      worldMaterialCache(world).delete(slot);
-    }
-    entityCache.delete(slot);
-  }
-  const cached = cachedEntry?.handle === entity ? cachedEntry.record : void 0;
-  if (cached !== void 0) {
-    ensureGlyphMeshMaterialSlots(world, asMeshHandle(cached.meshHandleId));
-    if (cached.signature === signature) return null;
-    const layout2 = layoutGlyphText(font, gt.text, gt.fontSize);
-    const meshHandle = asMeshHandle(cached.meshHandleId);
-    const submeshes = [
-      {
-        indexOffset: 0,
-        indexCount: layout2.indices.length,
-        vertexCount: layout2.vertices.length / PROCEDURAL_FLOATS_PER_VERTEX,
-        topology: "triangle-list",
-        materialSlot: 0
-      }
-    ];
-    const mesh = world.sharedRefs.resolve(meshHandle);
-    if (!mesh.ok) return null;
-    if (!updateGlyphMesh(gpuStore, meshHandle, layout2.vertices, layout2.indices, submeshes)) {
-      return null;
-    }
-    const aabb = conservativeCubeAabb(layout2.radius);
-    Object.assign(mesh.value, {
-      vertices: layout2.vertices,
-      indices: layout2.indices,
-      submeshes,
-      materialSlots: [{ slotName: "Default" }],
-      aabb
-    });
-    const materialId2 = resolveTextMaterial(world, gt, font, slot);
-    if (materialId2 !== cached.materialHandleId) {
-      world.set(entity, MeshRenderer, {
-        materials: [materialId2]
-      });
-    }
-    entityCache.set(slot, {
-      handle: entity,
-      record: {
-        meshHandleId: cached.meshHandleId,
-        signature,
-        materialHandleId: materialId2
-      }
-    });
-    return null;
-  }
-  const existingFilter = world.get(entity, MeshFilter);
-  if (existingFilter.ok) {
-    ensureGlyphMeshMaterialSlots(
-      world,
-      asMeshHandle(existingFilter.value.assetHandle)
-    );
-    return null;
-  }
-  const layout = layoutGlyphText(font, gt.text, gt.fontSize);
-  const bake = bakeGlyphMesh(world, layout);
-  if (!bake.ok) return null;
-  const materialId = resolveTextMaterial(world, gt, font, slot);
-  world.addComponent(entity, { component: MeshFilter, data: { assetHandle: bake.value.handle } });
-  world.addComponent(entity, {
-    component: MeshRenderer,
-    data: { materials: [materialId] }
-  });
-  entityCache.set(slot, {
-    handle: entity,
-    record: {
-      meshHandleId: handleId(bake.value.handle),
-      signature,
-      materialHandleId: materialId
-    }
-  });
-  return null;
-}
-function updateGlyphMesh(gpuStore, meshHandle, vertices, indices, submeshes) {
-  const updated = gpuStore.updateMesh(meshHandle, vertices, indices, 0, submeshes);
-  if (updated.ok) return true;
-  if (updated.error.code === "mesh-shape-mismatch") {
-    const replaced = gpuStore.replaceMesh(meshHandle, vertices, indices, 0, submeshes);
-    if (replaced.ok) return true;
-    return replaced.error.code === "mesh-not-resident" || replaced.error.code === "rhi-not-available";
-  }
-  return updated.error.code === "mesh-not-resident" || updated.error.code === "rhi-not-available";
-}
-function ensureGlyphMeshMaterialSlots(world, meshHandle) {
-  const mesh = world.sharedRefs.resolve(meshHandle);
-  if (mesh.ok && !Array.isArray(mesh.value.materialSlots)) {
-    Object.assign(mesh.value, { materialSlots: [{ slotName: "Default" }] });
-  }
-}
-function resolveTextMaterial(world, gt, font, slot) {
-  const cache = worldMaterialCache(world);
-  const material = {
-    kind: "material",
-    passes: [
-      {
-        name: "text",
-        program: { module: "forgeax::msdf-text" },
-        renderState: {
-          ...{
-            blend: MSDF_TEXT_BLEND,
-            cullMode: "none",
-            depthWriteEnabled: false,
-            depthCompare: "less-equal"
-          },
-          tags: { LightMode: "Forward" },
-          queue: 3e3
-        }
-      }
-    ],
-    values: {
-      tintColor: [gt.color[0] ?? 1, gt.color[1] ?? 1, gt.color[2] ?? 1, gt.color[3] ?? 1],
-      distanceRange: [
-        font.common.distanceRange,
-        font.common.atlasWidth,
-        font.common.atlasHeight,
-        0
-      ],
-      baseColorTexture: materialTextureValue({ texture: font.atlas })
-    },
-    parameters: [
-      { name: "tintColor", type: "color", default: [1, 1, 1, 1] },
-      { name: "distanceRange", type: "vec4", default: [4, 512, 512, 0] },
-      { name: "baseColorTexture", type: "texture" },
-      { name: "metallicRoughnessTexture", type: "texture", optional: true },
-      { name: "normalTexture", type: "texture", optional: true }
-    ]
-  };
-  const id = world.allocSharedRef("MaterialAsset", material);
-  const previous = cache.get(slot);
-  cache.set(slot, id);
-  if (previous !== void 0 && previous !== id) {
-    world.sharedRefs.release(asMaterialHandle(previous));
-  }
-  return id;
-}
-function signatureOf(gt) {
-  return `${gt.fontHandle}|${gt.fontSize}|${gt.text}|${gt.color[0]},${gt.color[1]},${gt.color[2]},${gt.color[3]}`;
-}
-function asFontHandle(raw) {
-  return raw;
-}
-function asMeshHandle(id) {
-  return id;
-}
-function asMaterialHandle(id) {
-  return id;
-}
-function handleId(handle) {
-  return handle;
-}
-var TRANSPARENT_SORT_CONFIG_KEY = "TransparentSortConfig";
-var TRANSPARENT_SORT_MODE_LAYER_Z = 0;
-var TRANSPARENT_SORT_MODE_LAYER_Y = 1;
-var TRANSPARENT_SORT_MODE_LAYER_YZ = 2;
-var TRANSPARENT_SORT_MODE_DISTANCE = 3;
-var DEFAULT_CONFIG = Object.freeze({
-  mode: TRANSPARENT_SORT_MODE_LAYER_Z,
-  yzAlpha: 1
-});
-var VALID_MODES = /* @__PURE__ */ new Set([
-  TRANSPARENT_SORT_MODE_LAYER_Z,
-  TRANSPARENT_SORT_MODE_LAYER_Y,
-  TRANSPARENT_SORT_MODE_LAYER_YZ,
-  TRANSPARENT_SORT_MODE_DISTANCE
-]);
-var EXPECTED_MODE = "mode \u2208 {0, 1, 2, 3}";
-var HINT_MODE = "0=layer-z, 1=layer-y, 2=layer-yz, 3=distance";
-function getTransparentSortConfig(world) {
-  if (!world.hasResource(TRANSPARENT_SORT_CONFIG_KEY)) {
-    return DEFAULT_CONFIG;
-  }
-  return world.getResource(TRANSPARENT_SORT_CONFIG_KEY);
-}
-function setTransparentSortConfig(world, cfg) {
-  if (!VALID_MODES.has(cfg.mode)) {
-    return err(
-      new ResourceInvalidValueError(EXPECTED_MODE, HINT_MODE, {
-        receivedMode: cfg.mode,
-        receivedKey: TRANSPARENT_SORT_CONFIG_KEY
-      })
-    );
-  }
-  world.insertResource(TRANSPARENT_SORT_CONFIG_KEY, {
-    mode: cfg.mode,
-    yzAlpha: cfg.yzAlpha
-  });
-  return ok(void 0);
-}
-
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, AtmosphereCapsInsufficientError, AtmosphereCardinalityInvalidError, AtmosphereParameterInvalidError, AtmosphereProducerFailedError, AtmosphereSunMissingError, BLOOM_DISABLED, BLOOM_ENABLED, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, Camera, DirectionalLight, EnvironmentSourceConflictError, EquirectProjectionFailedError, Fog, FogOwnerConflictError, FogParametersInvalidError, GbufferAttachmentCountMismatchError, GbufferRtAllocFailedError, GlyphText, HdrpCapsInsufficientError, HdrpDeferredCapsInsufficientError, HdrpIndexListOverflowError, HdrpLightBudgetExceededError, Instances, Layer, MaterialSkinAttrMissingError, Materials, MeshFilter, MeshRenderer, MeshSsboCapacityExceededError, MeshSsboCeilingReachedError, ObservationUnavailableError, PointLight, PointLightShadow, PointShadowAtlasBoundsViolationError, PointShadowAtlasUninitializedError, PostProcessParams, RenderFeatureCapabilityMissingError, RenderFeatureDrawRecordingFailedError, RenderFeaturePassOrderConflictError, RenderFeaturePreparationFailedError, RenderFeaturePreparedStateMismatchError, RenderFeatureRegistrationConflictError, RenderFeatureStageFailedError, SKYBOX_MODE_CUBEMAP, SPRITE_PLAYBACK_MODE_CLAMP, SPRITE_PLAYBACK_MODE_LOOP, SPRITE_PREMULTIPLIED_ALPHA_BLEND, SceneInstance, ShadowInvalidConfigError, SkinMaterialMismatchError, SkinPaletteOverflowError, SkyboxBackground, Skylight, SortKey, SpotLight, SpriteAnimation, SpriteInstances, SpriteRegionOverride, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, TRANSPARENT_SORT_CONFIG_KEY, TRANSPARENT_SORT_MODE_DISTANCE, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ, TRANSPARENT_SORT_MODE_LAYER_Z, TaaCapsInsufficientError, TemporalUnsupportedError, TileLayer, Tilemap, VertexStorageBufferUnavailableError, VideoUploadUnsupportedError, Visibility, VisibilityStateValue, antialiasFromF32, bloomEnabledFromF32, cameraProjectionFromF32, decodeSortScope, encodeSortScope, ensureGlyphMeshMaterialSlots, getTransparentSortConfig, glyphTextLayoutSystem, markTileLayerDirty, materialDrawDiagnostic, materialTextureValue, orthographic, perspective, resetGlyphBakeCache, resolveRenderAsset, setTransparentSortConfig, skyboxModeFromF32, spritePlaybackModeFromU32, tonemapFromF32, tonemapToU32, validateAtmosphereData, visibilityStateFromU32 };
-//# sourceMappingURL=chunk-DJIMFYX6.mjs.map
-//# sourceMappingURL=chunk-DJIMFYX6.mjs.map