@forgeax/engine-runtime 0.1.2

package/dist/index.mjs

@@ -0,0 +1,814 @@
+import { constructRenderer } from '@forgeax/engine-render/internal/construct-renderer';
+import { EngineEnvironmentError, collectSubtree, SceneInstance } from '@forgeax/engine-render/internal';
+export { EngineEnvironmentError } from '@forgeax/engine-render/internal';
+export { acquireCanvasContext } from '@forgeax/engine-rhi-webgpu';
+import { animationClipContribution, animationGraphContribution } from '@forgeax/engine-animation';
+import { err, ok, handleSlot } from '@forgeax/engine-types';
+export { AssetError, MATERIAL_PARAM_TYPES } from '@forgeax/engine-types';
+import { defineComponent, Time, componentDefinition } from '@forgeax/engine-ecs';
+import { sceneAssetContribution, externalizeSceneAsset, worldGetSceneInstanceState, worldGetSceneAssetForInstance, SCENE_COLLECT_PROFILE } from '@forgeax/engine-scene';
+import { fontContribution } from '@forgeax/engine-font';
+import { meshAssetContribution } from '@forgeax/engine-geometry';
+import { tilesetContribution, videoContribution } from '@forgeax/engine-graphics-extras';
+import { textureContribution, equirectContribution } from '@forgeax/engine-image';
+import { materialContribution, samplerContribution, renderPipelineContribution } from '@forgeax/engine-render';
+import { skeletonContribution, skinContribution } from '@forgeax/engine-skinning';
+import { particleEffectContribution } from '@forgeax/engine-vfx';
+import { SpriteAnimationInvalidError, fillComponentDefaults } from '@forgeax/engine-ecs/projection';
+export { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
+import { err as err$1, ok as ok$1 } from '@forgeax/engine-rhi';
+export { RhiError } from '@forgeax/engine-rhi';
+import { SpriteAnimation, spritePlaybackModeFromU32, SpriteRegionOverride } from '@forgeax/engine-render/authoring';
+export { quat } from '@forgeax/engine-math';
+import { classifyEntityField } from '@forgeax/engine-ecs/externalization';
+import { componentSchema } from '@forgeax/engine-ecs/internal';
+
+// src/createRenderer.ts
+
+// src/createRenderer.ts
+async function createRenderer(canvas, options, bundler) {
+  if (options !== void 0 && "rhi" in options && options.rhi === void 0) {
+    throw new EngineEnvironmentError("no usable rendering backend");
+  }
+  const rendererOptions = options === void 0 ? void 0 : {
+    ...options.rhi === void 0 ? {} : { rhi: options.rhi },
+    ...options.rawDeviceForContextConfigure === void 0 ? {} : { rawDeviceForContextConfigure: options.rawDeviceForContextConfigure },
+    ...options.features === void 0 ? {} : { features: options.features },
+    ...options.profiler === void 0 ? {} : { profiler: options.profiler },
+    ...options.membershipTiming === void 0 ? {} : { membershipTiming: options.membershipTiming },
+    ...options.rhiInstrumentation === void 0 ? {} : { rhiInstrumentation: options.rhiInstrumentation }
+  };
+  try {
+    return await constructRenderer(canvas, rendererOptions, bundler);
+  } catch (cause) {
+    if (isStructuredRenderError(cause)) throw cause;
+    if (cause instanceof EngineEnvironmentError) throw cause;
+    const detail = cause instanceof Error ? cause : new Error(String(cause));
+    throw new EngineEnvironmentError("renderer construction failed", { webgpuError: detail });
+  }
+}
+function isStructuredRenderError(value) {
+  if (!(value instanceof Error)) return false;
+  const candidate = value;
+  return typeof candidate.code === "string" && typeof candidate.expected === "string" && typeof candidate.hint === "string" && candidate.detail !== void 0;
+}
+var audioContribution = {
+  kind: { kind: "audio" },
+  consumer: "AudioBackend",
+  decoder: {
+    async decode({ envelope, artifacts }) {
+      const payload = envelope.payload;
+      if (payload !== null && typeof payload === "object") {
+        const source = payload;
+        let bytes = source.bytes instanceof Uint8Array ? source.bytes : Array.isArray(source.bytes) ? Uint8Array.from(source.bytes) : void 0;
+        const body = envelope.artifacts.body ?? envelope.artifacts.source;
+        if (body !== void 0) {
+          const bodyBytes = await artifacts.read(body);
+          if (!bodyBytes.ok) return bodyBytes;
+          bytes = bodyBytes.value;
+        }
+        if (source.kind === "audio" && typeof source.mediaType === "string" && source.mediaType.startsWith("audio/") && bytes !== void 0 && bytes.byteLength > 0) {
+          return ok({
+            kind: "audio",
+            sourceKey: typeof source.sourceKey === "string" && source.sourceKey.length > 0 ? source.sourceKey : envelope.guid,
+            mediaType: source.mediaType,
+            bytes
+          });
+        }
+      }
+      return err({
+        code: "asset-package-invalid",
+        expected: "an audio payload with non-empty source bytes and audio mediaType",
+        hint: "recook the audio source with a browser-supported media type",
+        detail: { guid: envelope.guid, reason: "audio owner validation failed" }
+      });
+    }
+  }
+};
+defineComponent("AudioSource", {
+  clip: { type: "shared<AudioClipAsset>" },
+  playing: { type: "bool", default: false },
+  loop: { type: "bool", default: false },
+  volume: { type: "f32", default: 1 },
+  spatialBlend: { type: "f32", default: 0 },
+  bus: { type: "string", default: "sfx" }
+});
+defineComponent("AudioListener", {});
+var typedDefaultAssetDecoderContributions = [
+  meshAssetContribution,
+  materialContribution,
+  sceneAssetContribution,
+  textureContribution,
+  equirectContribution,
+  samplerContribution,
+  fontContribution,
+  renderPipelineContribution,
+  tilesetContribution,
+  videoContribution,
+  skeletonContribution,
+  skinContribution,
+  animationClipContribution,
+  animationGraphContribution,
+  audioContribution,
+  particleEffectContribution
+];
+var defaultAssetDecoderContributions = Object.freeze(
+  typedDefaultAssetDecoderContributions
+);
+
+// src/asset-kind.ts
+function builtinAssetKind(kind) {
+  const token = { kind };
+  return Object.freeze(token);
+}
+
+// src/dev-import-transport.ts
+function createDevImportTransport(binding) {
+  return {
+    async fetchPack(guid, scope) {
+      const active = binding;
+      if (active === void 0 || active.status !== "ready" || scope === void 0 || scope.status !== "ready" || scope.scopeId !== active.scopeId || scope.generation !== active.generation) {
+        return { ok: false };
+      }
+      try {
+        const base = active.importUrlBase.replace(/\/+$/, "");
+        const response = await fetch(`${base}/${encodeURIComponent(guid)}`, { method: "POST" });
+        if (!response.ok) {
+          try {
+            const fail = await response.json();
+            console.warn(
+              `[forgeax] import failed for ${guid} (HTTP ${response.status}): ${fail.code ?? "import-failed"} - ${fail.reason ?? ""}` + (fail.hint ? ` | hint: ${fail.hint}` : "")
+            );
+          } catch {
+          }
+          return { ok: false };
+        }
+        try {
+          const body = await response.json();
+          if (Array.isArray(body)) return { ok: true, entries: body };
+        } catch {
+        }
+        return { ok: true };
+      } catch {
+        return { ok: false };
+      }
+    }
+  };
+}
+function spriteAnimationTickSystem(world) {
+  const dt = world.getResource(Time).delta;
+  const entities = collectAnimEntities(world);
+  let firstError = null;
+  for (const entity of entities) {
+    const entryError = tickEntity(world, entity, dt);
+    if (entryError !== null && firstError === null) {
+      firstError = entryError;
+    }
+  }
+  if (firstError !== null) {
+    return err(firstError);
+  }
+  return ok(void 0);
+}
+function collectAnimEntities(world) {
+  const queryResult = world.query({ with: [SpriteAnimation] });
+  if (!queryResult.ok) return [];
+  const entities = [];
+  for (const row of queryResult.value) entities.push(row.entity);
+  return entities;
+}
+function tickEntity(world, entity, dt) {
+  const snapRes = world.get(entity, SpriteAnimation);
+  if (!snapRes.ok) {
+    return null;
+  }
+  const snap = snapRes.value;
+  const frameCount = snap.frameCount;
+  const frameDuration = snap.frameDuration;
+  const regions = snap.regions;
+  if (regions.length !== frameCount * 4) {
+    return new SpriteAnimationInvalidError({
+      field: "regions-length",
+      regionsLength: regions.length,
+      frameCount
+    });
+  }
+  if (!(frameDuration > 0)) {
+    return new SpriteAnimationInvalidError({
+      field: "frame-duration",
+      frameDuration
+    });
+  }
+  const advanced = advanceFrame(
+    snap.currentFrame,
+    snap.accumDt + dt,
+    frameDuration,
+    frameCount,
+    snap.playbackMode
+  );
+  const writeAnim = world.set(entity, SpriteAnimation, {
+    currentFrame: advanced.currentFrame,
+    accumDt: advanced.accumDt
+  });
+  if (!writeAnim.ok) return null;
+  const sliceStart = advanced.currentFrame * 4;
+  const region = new Float32Array([
+    regions[sliceStart] ?? 0,
+    regions[sliceStart + 1] ?? 0,
+    regions[sliceStart + 2] ?? 0,
+    regions[sliceStart + 3] ?? 0
+  ]);
+  writeOverride(world, entity, region);
+  return null;
+}
+function advanceFrame(currentFrameIn, accumDtIn, frameDuration, frameCount, playbackModeRaw) {
+  let currentFrame = currentFrameIn;
+  let accumDt = accumDtIn;
+  const playback = spritePlaybackModeFromU32(playbackModeRaw);
+  while (accumDt >= frameDuration) {
+    accumDt -= frameDuration;
+    switch (playback) {
+      case "loop": {
+        currentFrame = (currentFrame + 1) % frameCount;
+        break;
+      }
+      case "clamp": {
+        if (currentFrame < frameCount - 1) {
+          currentFrame += 1;
+        }
+        break;
+      }
+    }
+  }
+  return { currentFrame, accumDt };
+}
+function writeOverride(world, entity, region) {
+  const added = world.addComponent(entity, {
+    component: SpriteRegionOverride,
+    data: { region }
+  });
+  if (!added.ok && added.error.code === "component-already-present") {
+    world.set(entity, SpriteRegionOverride, { region });
+  }
+}
+
+// src/scene-collect-errors.ts
+var SceneCollectEntityRefOutOfClosureError = class extends Error {
+  code = "scene-collect-entity-ref-out-of-closure";
+  expected;
+  hint = "Expand roots to include the target entity, or remove the reference.";
+  detail;
+  constructor(entity, field, target) {
+    super(
+      `entity ${entity} field ${field} references entity ${target} outside the collected roots`
+    );
+    this.name = "SceneCollectEntityRefOutOfClosureError";
+    this.expected = `entity ${entity} field ${field} to reference an entity inside the collected roots`;
+    this.detail = { entity, field, target };
+  }
+};
+var SceneCollectAssetGuidUnresolvedError = class extends Error {
+  code = "scene-collect-asset-guid-unresolved";
+  expected;
+  hint = "Provide a GUID through the active scene asset port before collecting shared asset fields.";
+  detail;
+  constructor(field, handle) {
+    super(`shared asset field ${field} has no GUID for handle ${handle}`);
+    this.name = "SceneCollectAssetGuidUnresolvedError";
+    this.expected = `shared asset field ${field} to resolve through the active scene asset port`;
+    this.detail = { field, handle };
+  }
+};
+function excludedComponentNames() {
+  return /* @__PURE__ */ new Set(["Entity", "ChildOf", "Children"]);
+}
+function normalize(value) {
+  if (Array.isArray(value) || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Int32Array || value instanceof Float64Array || value instanceof Uint8Array || value instanceof Int16Array || value instanceof Uint16Array) {
+    return Array.from(value);
+  }
+  return value;
+}
+function valuesEqual(a, b) {
+  return JSON.stringify(normalize(a)) === JSON.stringify(normalize(b));
+}
+function baselineFields(comp, sourceRaw) {
+  const filled = fillComponentDefaults(comp, sourceRaw ?? {});
+  const out = {};
+  const fields = componentDefinition(comp).fields;
+  for (const fieldName of Object.keys(componentSchema(comp))) {
+    if (fields[fieldName]?.transient) continue;
+    out[fieldName] = filled[fieldName];
+  }
+  return out;
+}
+function liveFields(world, entity, comp) {
+  const res = world.get(entity, comp);
+  if (!res.ok) return void 0;
+  const val = res.value;
+  const out = {};
+  const fields = componentDefinition(comp).fields;
+  const schema = componentSchema(comp);
+  for (const fieldName of Object.keys(schema)) {
+    if (fields[fieldName]?.transient) continue;
+    const fieldType = schema[fieldName];
+    if (fieldType === "entity" || fieldType === "array<entity>") continue;
+    out[fieldName] = normalize(val[fieldName]);
+  }
+  return out;
+}
+function foldMountOverrides(world, assets, state) {
+  const sourceRes = assets.resolve(
+    world,
+    state.source
+  );
+  if (!sourceRes.ok) return [];
+  const source = sourceRes.value;
+  const sourceByLid = /* @__PURE__ */ new Map();
+  for (const node of source.entities) {
+    sourceByLid.set(node.localId, node);
+  }
+  const excluded = excludedComponentNames();
+  const registered = world.components.entries();
+  const overrides = [];
+  const members = [];
+  for (const [entity, lid] of state.entityToLocalId) {
+    members.push([entity, lid]);
+  }
+  members.sort((a, b) => a[1] - b[1]);
+  for (const [entity, lid] of members) {
+    const sourceNode = sourceByLid.get(lid);
+    const sourceComps = sourceNode?.components ?? {};
+    for (const [compName, compToken] of registered) {
+      if (excluded.has(compName)) continue;
+      if (componentDefinition(compToken).policy.transient) continue;
+      const comp = compToken;
+      if (Object.keys(componentSchema(comp)).length === 0) continue;
+      const live = liveFields(world, entity, comp);
+      if (live === void 0) continue;
+      const sourceRaw = sourceComps[compName];
+      if (sourceRaw === void 0) {
+        overrides.push({
+          localId: lid,
+          comp: compName,
+          value: live
+        });
+        continue;
+      }
+      const baseline = baselineFields(comp, sourceRaw);
+      for (const fieldName of Object.keys(live)) {
+        if (!valuesEqual(live[fieldName], baseline[fieldName])) {
+          overrides.push({
+            localId: lid,
+            comp: compName,
+            field: fieldName,
+            value: live[fieldName]
+          });
+        }
+      }
+    }
+  }
+  return overrides;
+}
+
+// src/collect-scene-asset.ts
+function _isArrayLike(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function _normalizeArray(value) {
+  return Array.from(value);
+}
+function classifyFieldSchema(fieldType) {
+  if (fieldType === void 0) return void 0;
+  if (fieldType.startsWith("shared<")) return { kind: "shared", scalar: true };
+  if (fieldType.startsWith("array<shared<")) return { kind: "shared", scalar: false };
+  return void 0;
+}
+function _handleToGuid(world, assets, handle, field) {
+  if (handle === 0) return ok$1(void 0);
+  const assetRes = assets.resolve(world, handle);
+  if (!assetRes.ok) return err$1(new SceneCollectAssetGuidUnresolvedError(field, handle));
+  const guid = assets.guidOf(assetRes.value);
+  if (guid === void 0) return err$1(new SceneCollectAssetGuidUnresolvedError(field, handle));
+  return ok$1(guid);
+}
+function _serializeSharedFieldValue(world, assets, classification, value, field) {
+  if (classification.scalar) {
+    if (typeof value !== "number") return ok$1(value);
+    return _handleToGuid(world, assets, value, field);
+  }
+  if (!Array.isArray(value)) return ok$1(value);
+  const mapped = [];
+  for (const elem of value) {
+    if (typeof elem !== "number") {
+      mapped.push(elem);
+      continue;
+    }
+    const g = _handleToGuid(world, assets, elem, field);
+    if (!g.ok) return g;
+    mapped.push(g.value ?? 0);
+  }
+  return ok$1(mapped);
+}
+function _serializeOverrideValueHandles(world, assets, ov) {
+  const comp = world.components.resolve(ov.comp);
+  const schema = comp === void 0 ? void 0 : componentSchema(comp);
+  if (ov.field !== void 0) {
+    const classification = schema ? classifyFieldSchema(schema[ov.field]) : void 0;
+    if (!classification || classification.kind !== "shared") return ok$1(ov.value);
+    const conv = _serializeSharedFieldValue(world, assets, classification, ov.value, ov.field);
+    if (!conv.ok) return conv;
+    return ok$1(conv.value ?? 0);
+  }
+  if (typeof ov.value !== "object" || ov.value === null || Array.isArray(ov.value)) {
+    return ok$1(ov.value);
+  }
+  const src = ov.value;
+  const out = {};
+  for (const fieldName of Object.keys(src)) {
+    const classification = schema ? classifyFieldSchema(schema[fieldName]) : void 0;
+    if (!classification || classification.kind !== "shared") {
+      out[fieldName] = src[fieldName];
+      continue;
+    }
+    const conv = _serializeSharedFieldValue(
+      world,
+      assets,
+      classification,
+      src[fieldName],
+      fieldName
+    );
+    if (!conv.ok) return conv;
+    if (classification.scalar && conv.value === void 0) continue;
+    out[fieldName] = conv.value;
+  }
+  return ok$1(out);
+}
+function serializeSceneAssetToPack(sceneAsset, components, guid) {
+  const externalized = externalizeSceneAsset(sceneAsset, (componentName) => {
+    const component = components.get(componentName);
+    return component === void 0 ? void 0 : componentSchema(component);
+  });
+  if (!externalized.ok) {
+    const value = externalized.error.value;
+    return err$1(
+      new SceneCollectAssetGuidUnresolvedError(
+        externalized.error.field,
+        typeof value === "string" || typeof value === "number" ? value : String(value)
+      )
+    );
+  }
+  return ok$1({
+    schemaVersion: "2.0.0",
+    kind: "internal-text-package",
+    assets: [
+      {
+        guid: guid ?? crypto.randomUUID(),
+        kind: "scene",
+        payload: externalized.value.payload,
+        refs: externalized.value.refs.map((reference) => reference.guid),
+        artifacts: {}
+      }
+    ]
+  });
+}
+function rootsToSceneAsset(assets, world, roots) {
+  const collectProfile = SCENE_COLLECT_PROFILE;
+  const visited = /* @__PURE__ */ new Set();
+  for (const root of roots) collectSubtree(world, root, visited);
+  if (visited.size === 0) return ok$1({ kind: "scene", entities: [] });
+  const rootRawSet = /* @__PURE__ */ new Set();
+  for (const r of roots) rootRawSet.add(r);
+  const anchorEntities = /* @__PURE__ */ new Set();
+  for (const er of visited) {
+    if (world.get(er, SceneInstance).ok) anchorEntities.add(er);
+  }
+  const anchorsSorted = [...anchorEntities].sort((a, b) => a - b);
+  const memberEntities = /* @__PURE__ */ new Set();
+  const memberOrigin = /* @__PURE__ */ new Map();
+  for (const er of anchorsSorted) {
+    if (rootRawSet.has(er)) continue;
+    const sr = worldGetSceneInstanceState(world, er);
+    if (!sr.ok) continue;
+    for (const [me, lid] of sr.value.entityToLocalId) {
+      const mr = me;
+      if (visited.has(mr) && !anchorEntities.has(mr) && !memberEntities.has(mr)) {
+        memberEntities.add(mr);
+        memberOrigin.set(mr, { anchorRaw: er, memberLocalId: lid });
+      }
+    }
+  }
+  for (const er of anchorEntities) {
+    if (memberEntities.has(er) && !rootRawSet.has(er)) anchorEntities.delete(er);
+  }
+  const childOfTk0 = world.components.resolve("ChildOf");
+  const childrenTk0 = world.components.resolve("Children");
+  const carrierAllowed = /* @__PURE__ */ new Set(["Transform", "Children", "ChildOf", "Entity"]);
+  const carrierForAnchor = /* @__PURE__ */ new Map();
+  const carrierToAnchor = /* @__PURE__ */ new Map();
+  const isMountCarrier = (p, anchorRaw) => {
+    if (rootRawSet.has(p)) return false;
+    if (anchorEntities.has(p) || memberEntities.has(p)) return false;
+    if (!visited.has(p)) return false;
+    for (const [compName, compToken] of world.components.entries()) {
+      if (carrierAllowed.has(compName)) continue;
+      if (world.get(p, compToken).ok) return false;
+    }
+    if (childrenTk0) {
+      const cr = world.get(p, childrenTk0);
+      if (cr.ok) {
+        const kids = cr.value.entities;
+        if (kids) {
+          let visitedKidCount = 0;
+          let sawAnchor = false;
+          for (let i = 0; i < kids.length; i++) {
+            const k = kids[i];
+            if (!visited.has(k)) continue;
+            visitedKidCount += 1;
+            if (k === anchorRaw) sawAnchor = true;
+          }
+          if (!sawAnchor || visitedKidCount !== 1) return false;
+        }
+      }
+    }
+    return true;
+  };
+  if (childOfTk0) {
+    for (const anchorRaw of anchorsSorted) {
+      if (!anchorEntities.has(anchorRaw)) continue;
+      if (rootRawSet.has(anchorRaw)) continue;
+      const cr = world.get(anchorRaw, childOfTk0);
+      if (!cr.ok) continue;
+      const pRaw = cr.value.parent;
+      if (pRaw === void 0) continue;
+      if (!carrierToAnchor.has(pRaw) && isMountCarrier(pRaw, anchorRaw)) {
+        carrierForAnchor.set(anchorRaw, pRaw);
+        carrierToAnchor.set(pRaw, anchorRaw);
+      }
+    }
+  }
+  const orderedEntities = [...visited];
+  const ownedEntities = [];
+  for (const er of orderedEntities) {
+    if (carrierToAnchor.has(er)) continue;
+    if ((!anchorEntities.has(er) || rootRawSet.has(er)) && !memberEntities.has(er)) {
+      ownedEntities.push(er);
+    }
+  }
+  const entityToLocalId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ownedEntities.length; i++) {
+    const e = ownedEntities[i];
+    if (e !== void 0) entityToLocalId.set(e, i);
+  }
+  const nonRootAnchors = [];
+  for (const er of anchorEntities) {
+    if (rootRawSet.has(er)) continue;
+    const sh = worldGetSceneAssetForInstance(world, er);
+    if (!sh.ok)
+      return err$1(
+        new SceneCollectAssetGuidUnresolvedError(
+          "SceneInstance.source",
+          sh.error
+        )
+      );
+    const pr = assets.resolve(world, sh.value);
+    if (!pr.ok)
+      return err$1(
+        new SceneCollectAssetGuidUnresolvedError(
+          "SceneInstance.source",
+          sh.value
+        )
+      );
+    const g = assets.guidOf(pr.value);
+    if (g === void 0)
+      return err$1(
+        new SceneCollectAssetGuidUnresolvedError(
+          "SceneInstance.source",
+          sh.value
+        )
+      );
+    const sr = worldGetSceneInstanceState(world, er);
+    if (!sr.ok)
+      return err$1(new SceneCollectAssetGuidUnresolvedError("SceneInstance.source", "state"));
+    nonRootAnchors.push({ entityRaw: er, sourceGuid: g, totalSlots: sr.value.totalSlots });
+  }
+  const bfsIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < orderedEntities.length; i++) {
+    if (orderedEntities[i] !== void 0) bfsIdx.set(orderedEntities[i], i);
+  }
+  nonRootAnchors.sort((a, b) => (bfsIdx.get(a.entityRaw) ?? 0) - (bfsIdx.get(b.entityRaw) ?? 0));
+  const ownedCount = ownedEntities.length;
+  const outMounts = [];
+  let nextMF = ownedCount + nonRootAnchors.length;
+  const childOfTk = world.components.resolve("ChildOf");
+  const transformTk = world.components.resolve("Transform");
+  for (const a of nonRootAnchors) {
+    const carrierRaw = carrierForAnchor.get(a.entityRaw);
+    const parentSourceRaw = carrierRaw ?? a.entityRaw;
+    let mp;
+    if (childOfTk) {
+      const cr = world.get(parentSourceRaw, childOfTk);
+      if (cr.ok) {
+        const pRaw = cr.value.parent;
+        if (pRaw !== void 0) {
+          const ol = entityToLocalId.get(pRaw);
+          if (ol !== void 0) mp = ol;
+          else {
+            const mo = memberOrigin.get(pRaw);
+            if (mo !== void 0) {
+              const ai = nonRootAnchors.findIndex((x) => x.entityRaw === mo.anchorRaw);
+              if (ai >= 0) mp = ownedCount + ai;
+            }
+          }
+        }
+      }
+    }
+    let mountComponents;
+    if (carrierRaw !== void 0 && transformTk) {
+      const tr = world.get(carrierRaw, transformTk);
+      if (tr.ok) {
+        mountComponents = {
+          Transform: { ...tr.value }
+        };
+      }
+    }
+    const memberFirst0 = nextMF;
+    let mountOverrides;
+    const foldStateRes = worldGetSceneInstanceState(world, a.entityRaw);
+    if (foldStateRes.ok) {
+      const rawOverrides = foldMountOverrides(world, assets, foldStateRes.value);
+      if (rawOverrides.length > 0) {
+        mountOverrides = [];
+        for (const ov of rawOverrides) {
+          const convRes = _serializeOverrideValueHandles(world, assets, ov);
+          if (!convRes.ok) return convRes;
+          mountOverrides.push({
+            ...ov,
+            localId: memberFirst0 + ov.localId,
+            value: convRes.value
+          });
+        }
+      }
+    }
+    const mount = {
+      localId: ownedCount + outMounts.length,
+      source: a.sourceGuid,
+      memberFirst: nextMF,
+      memberCount: a.totalSlots,
+      ...mp !== void 0 ? { parent: mp } : {},
+      ...mountComponents !== void 0 ? { components: mountComponents } : {},
+      ...mountOverrides !== void 0 && mountOverrides.length > 0 ? { overrides: mountOverrides } : {}
+    };
+    outMounts.push(mount);
+    nextMF += a.totalSlots;
+  }
+  function _rlid(t) {
+    const ol = entityToLocalId.get(t);
+    if (ol !== void 0) return ol;
+    const absorbedAnchor = carrierToAnchor.get(t);
+    if (absorbedAnchor !== void 0) {
+      for (let i = 0; i < nonRootAnchors.length; i++) {
+        if (nonRootAnchors[i]?.entityRaw === absorbedAnchor) return ownedCount + i;
+      }
+    }
+    for (let i = 0; i < nonRootAnchors.length; i++) {
+      if (nonRootAnchors[i]?.entityRaw === t) return ownedCount + i;
+    }
+    const mo = memberOrigin.get(t);
+    if (mo !== void 0) {
+      for (let i = 0; i < nonRootAnchors.length; i++) {
+        if (nonRootAnchors[i]?.entityRaw === mo.anchorRaw) {
+          let mf = ownedCount + nonRootAnchors.length;
+          for (let j = 0; j < i; j++) mf += nonRootAnchors[j]?.totalSlots ?? 0;
+          return mf + mo.memberLocalId;
+        }
+      }
+    }
+    return void 0;
+  }
+  const registeredComps = world.components.entries();
+  const entities = [];
+  for (let lid = 0; lid < ownedEntities.length; lid++) {
+    const entityRaw = ownedEntities[lid];
+    if (entityRaw === void 0) continue;
+    const entity = entityRaw;
+    const components = {};
+    const isRoot = rootRawSet.has(entityRaw);
+    for (const [compName, compToken] of registeredComps) {
+      if (!collectProfile.includeComponent(
+        compName,
+        componentDefinition(compToken).policy.transient === true
+      ))
+        continue;
+      if (isRoot && compName === "ChildOf") continue;
+      const valRes = world.get(entity, compToken);
+      if (!valRes.ok) continue;
+      const val = valRes.value;
+      const comp = compToken;
+      if (comp === void 0) continue;
+      const schema = componentSchema(comp);
+      const schemaKeys = Object.keys(schema);
+      if (schemaKeys.length === 0) {
+        components[compName] = {};
+        continue;
+      }
+      const fieldValues = {};
+      for (const fieldName of schemaKeys) {
+        const rawValue = val[fieldName];
+        if (rawValue === void 0) continue;
+        if (!collectProfile.includeField(
+          compName,
+          fieldName,
+          componentDefinition(comp).fields[fieldName]?.transient === true
+        ))
+          continue;
+        const schemaFieldType = schema[fieldName];
+        const entityKind = classifyEntityField(comp, fieldName);
+        const sharedClass = schemaFieldType !== void 0 ? classifyFieldSchema(schemaFieldType) : void 0;
+        if (!entityKind && !sharedClass) {
+          if (_isArrayLike(rawValue)) {
+            fieldValues[fieldName] = _normalizeArray(rawValue);
+          } else {
+            fieldValues[fieldName] = rawValue;
+          }
+          continue;
+        }
+        if (entityKind !== null) {
+          if (entityKind.isArray) {
+            const arr = _isArrayLike(rawValue) ? _normalizeArray(rawValue) : rawValue;
+            const mapped = [];
+            for (const elem of arr) {
+              const lid2 = _rlid(elem);
+              if (lid2 === void 0) {
+                return err$1(
+                  new SceneCollectEntityRefOutOfClosureError(entityRaw, fieldName, elem)
+                );
+              }
+              mapped.push(lid2);
+            }
+            fieldValues[fieldName] = mapped;
+          } else {
+            if (rawValue === null) continue;
+            const lid2 = _rlid(rawValue);
+            if (lid2 === void 0) {
+              return err$1(
+                new SceneCollectEntityRefOutOfClosureError(
+                  entityRaw,
+                  fieldName,
+                  rawValue
+                )
+              );
+            }
+            fieldValues[fieldName] = lid2;
+          }
+        } else {
+          const normalized = _isArrayLike(rawValue) ? _normalizeArray(rawValue) : rawValue;
+          if (sharedClass === void 0) {
+            fieldValues[fieldName] = normalized;
+            continue;
+          }
+          const conv = _serializeSharedFieldValue(
+            world,
+            assets,
+            sharedClass,
+            normalized,
+            fieldName
+          );
+          if (!conv.ok) return conv;
+          if (sharedClass.scalar && conv.value === void 0) continue;
+          fieldValues[fieldName] = conv.value;
+        }
+      }
+      if (Object.keys(fieldValues).length > 0) components[compName] = fieldValues;
+    }
+    entities.push({ localId: lid, components });
+  }
+  return ok$1({
+    kind: "scene",
+    entities,
+    ...outMounts.length > 0 ? { mounts: outMounts } : {}
+  });
+}
+function createSceneAssetPort(guidOf) {
+  return {
+    resolve(world, handle) {
+      const shared = world.sharedRefs.resolve(handle);
+      if (shared.ok) return ok(shared.value);
+      return err({
+        code: "scene-asset-unresolved",
+        expected: "the handle to identify a World.sharedRefs-owned scene asset",
+        hint: "allocate the asset through the active World shared-ref owner before collecting the scene",
+        detail: { handle: handleSlot(handle) }
+      });
+    },
+    guidOf
+  };
+}
+
+// src/index.ts
+var Engine = {
+  create: createRenderer
+};
+
+export { Engine, SceneCollectAssetGuidUnresolvedError, SceneCollectEntityRefOutOfClosureError, builtinAssetKind, createDevImportTransport, createRenderer, createSceneAssetPort, defaultAssetDecoderContributions, rootsToSceneAsset, serializeSceneAssetToPack, spriteAnimationTickSystem };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map