@forgeax/engine-scene 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -30,9 +30,6 @@ function err(error) {
 function toUnique(raw) {
   return raw;
 }
-function toShared(raw) {
-  return raw;
-}
 function unwrapHandle(h) {
   return h;
 }
@@ -192,9 +189,6 @@ function invalidScene(guid, reason) {
   });
 }
 var sceneWireRefs = /* @__PURE__ */ new WeakMap();
-function sceneAssetWireRefs(asset) {
-  return sceneWireRefs.get(asset);
-}
 function resolveWireRef(refs, value, location) {
   const guid = refs[value];
   if (!Number.isInteger(value) || value < 0 || guid === void 0) {
@@ -281,17 +275,62 @@ var sceneAssetContribution = {
   consumer: "Scene"
 };
 
-// src/assets/scene-projection.ts
-import { componentSchema as componentSchema2 } from "@forgeax/engine-ecs/internal";
-import { AssetGuid } from "@forgeax/engine-pack/guid";
+// src/components/children.ts
+import { defineRelationship } from "@forgeax/engine-ecs";
+var { source: ChildOf, target: Children } = defineRelationship({
+  sourceName: "ChildOf",
+  sourceField: "parent",
+  targetName: "Children",
+  targetField: "entities",
+  exclusive: true,
+  linkedSpawn: true
+});
 
-// src/instances/scene-instances.ts
-import {
-  ENTITY_NULL_RAW
-} from "@forgeax/engine-ecs";
-import { classifyEntityField, remapEntityFieldValue } from "@forgeax/engine-ecs/externalization";
-import { componentSchema } from "@forgeax/engine-ecs/internal";
-import { fillComponentDefaults, StaleEntityError } from "@forgeax/engine-ecs/projection";
+// src/collect-subtree.ts
+function collectSubtree(world, spawnRoot, visited) {
+  if (visited === void 0) visited = /* @__PURE__ */ new Set();
+  if (visited.has(spawnRoot)) return visited;
+  const queue = [spawnRoot];
+  visited.add(spawnRoot);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const children = world.get(current, Children);
+    if (!children.ok) continue;
+    const entities = children.value.entities;
+    for (let index = 0; index < entities.length; index += 1) {
+      const child = entities[index];
+      if (visited.has(child)) continue;
+      visited.add(child);
+      queue.push(child);
+    }
+  }
+  return visited;
+}
+
+// src/components/morph-weights.ts
+import { defineComponent } from "@forgeax/engine-ecs";
+var MorphWeights = defineComponent("MorphWeights", {
+  weights: { type: "array<f32>" }
+});
+
+// src/components/name.ts
+import { defineComponent as defineComponent2 } from "@forgeax/engine-ecs";
+var Name = defineComponent2("Name", { value: { type: "string" } });
+
+// src/components/transform.ts
+import { defineComponent as defineComponent3 } from "@forgeax/engine-ecs";
+var IDENTITY_MAT4 = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+var Transform = defineComponent3("Transform", {
+  pos: { type: "array<f32, 3>", default: new Float32Array([0, 0, 0]) },
+  // Component order [x, y, z, w] end to end (glTF-aligned; E6).
+  quat: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) },
+  scale: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
+  // `world` is field-level transient (D-5): scene collect skips it. The resolved
+  // world mat4 is derived by the propagate kernel from the persisted local TRS
+  // each frame, so serializing it would store reconstructable data (SSOT: local
+  // TRS). Round-trip re-derives an equivalent world on the first propagate pass.
+  world: { type: "array<f32, 16>", default: IDENTITY_MAT4, transient: true }
+});
 
 // src/errors.ts
 import { ComponentNotDefinedError } from "@forgeax/engine-ecs/projection";
@@ -310,18 +349,117 @@ var SceneError = class extends Error {
   }
 };
 
+// src/instances/collect-profile.ts
+var SCENE_COLLECT_PROFILE = Object.freeze({
+  includeComponent: (_componentName, transient) => !transient,
+  includeField: (_componentName, _fieldName, transient) => !transient
+});
+
+// src/instances/externalization.ts
+function sharedKind(type) {
+  if (type?.startsWith("shared<")) return "one";
+  if (type?.startsWith("array<shared<")) return "many";
+  return void 0;
+}
+function overrideGuids(override, resolveSchema) {
+  const schema = resolveSchema(override.comp);
+  const values = override.field !== void 0 ? [[override.field, override.value]] : override.value !== null && typeof override.value === "object" && !Array.isArray(override.value) ? Object.entries(override.value) : [];
+  return values.flatMap(([field, value]) => {
+    const kind = sharedKind(schema?.[field]);
+    if (kind === "one" && typeof value === "string") return [{ field, guid: value }];
+    if (kind === "many" && Array.isArray(value)) {
+      return value.flatMap((item) => typeof item === "string" ? [{ field, guid: item }] : []);
+    }
+    return [];
+  });
+}
+function externalizeSceneAsset(scene, resolveSchema) {
+  const refs = [];
+  const indexByGuid = /* @__PURE__ */ new Map();
+  const addRef = (guid, sourceField, sceneEntityId) => {
+    const prior = indexByGuid.get(guid);
+    if (prior !== void 0) return prior;
+    const index = refs.length;
+    refs.push({ guid, sourceField, ...sceneEntityId === void 0 ? {} : { sceneEntityId } });
+    indexByGuid.set(guid, index);
+    return index;
+  };
+  const entities = scene.entities.map((entity) => {
+    const components = {};
+    for (const componentName of Object.keys(entity.components)) {
+      const schema = resolveSchema(componentName);
+      const source = entity.components[componentName];
+      if (source === void 0) continue;
+      const fields = {};
+      for (const fieldName of Object.keys(source)) {
+        const value = source[fieldName];
+        if (value === void 0) continue;
+        const kind = sharedKind(schema?.[fieldName]);
+        if (kind === "one" && typeof value === "string") {
+          fields[fieldName] = addRef(value, { componentName, fieldName }, entity.localId);
+        } else if (kind === "many" && Array.isArray(value)) {
+          fields[fieldName] = value.map(
+            (item, arrayIndex) => typeof item === "string" ? addRef(item, { componentName, fieldName, arrayIndex }, entity.localId) : item
+          );
+        } else {
+          fields[fieldName] = value;
+        }
+      }
+      if (Object.keys(fields).length > 0 || Object.keys(schema ?? {}).length === 0) {
+        components[componentName] = fields;
+      }
+    }
+    return { localId: entity.localId, components };
+  });
+  const mounts = scene.mounts?.map((mount) => {
+    const source = typeof mount.source === "string" ? addRef(
+      mount.source,
+      { componentName: "SceneInstance", fieldName: "source" },
+      mount.localId
+    ) : mount.source;
+    for (const { field, guid } of (mount.overrides ?? []).flatMap(
+      (override) => overrideGuids(override, resolveSchema)
+    )) {
+      addRef(guid, { componentName: "SceneInstance", fieldName: `overrides.${field}` });
+    }
+    return {
+      localId: mount.localId,
+      source,
+      memberFirst: mount.memberFirst,
+      memberCount: mount.memberCount,
+      ...mount.parent === void 0 ? {} : { parent: mount.parent },
+      ...mount.publicationFence === void 0 ? {} : { publicationFence: mount.publicationFence },
+      ...mount.overrides === void 0 ? {} : { overrides: mount.overrides.map((item) => ({ ...item })) }
+    };
+  });
+  for (const [arrayIndex, guid] of (scene.skinGuids ?? []).entries()) {
+    if (typeof guid !== "string") return err({ field: "skinGuids", value: guid });
+    addRef(guid, { componentName: "<scene>", fieldName: "skinGuids", arrayIndex });
+  }
+  return ok({
+    payload: {
+      entities,
+      ...mounts === void 0 || mounts.length === 0 ? {} : { mounts },
+      ...scene.skinGuids === void 0 ? {} : { skinGuids: scene.skinGuids.map((guid) => indexByGuid.get(guid)) }
+    },
+    refs
+  });
+}
+
 // src/instances/scene-instances.ts
+import {
+  ENTITY_NULL_RAW
+} from "@forgeax/engine-ecs";
+import { classifyEntityField, remapEntityFieldValue } from "@forgeax/engine-ecs/externalization";
+import { componentSchema } from "@forgeax/engine-ecs/internal";
+import { fillComponentDefaults, StaleEntityError } from "@forgeax/engine-ecs/projection";
 var entityIndex = (entity) => entity & 16777215;
 var entityGeneration = (entity) => entity >>> 24 & 255;
 var sceneWorldStates = /* @__PURE__ */ new WeakMap();
 function sceneWorldState(world) {
   const current = sceneWorldStates.get(world);
   if (current !== void 0) return current;
-  const created = {
-    resolver: null,
-    statePayloads: /* @__PURE__ */ new Map(),
-    instantiateHook: null
-  };
+  const created = { resolver: null, statePayloads: /* @__PURE__ */ new Map() };
   sceneWorldStates.set(world, created);
   return created;
 }
@@ -331,24 +469,21 @@ function worldSetSceneAssetResolver(world, resolver) {
 function worldGetSceneAssetResolver(world) {
   return sceneWorldState(world).resolver;
 }
-function worldSetSceneInstantiateHook(world, hook) {
-  sceneWorldState(world).instantiateHook = hook;
-}
 function worldInstantiateScene(world, handle, parent) {
   const stack = /* @__PURE__ */ new Set();
   const diagnostics = [];
   const r = worldInstantiateSceneRec(world, handle, parent, stack, diagnostics);
   if (!r.ok) return r;
-  const hook = sceneWorldState(world).instantiateHook;
-  if (hook !== null) {
-    const hooked = hook(world, r.value);
-    if (!hooked.ok) {
-      worldDespawnScene(world, r.value);
-      return err(hooked.error);
-    }
-  }
   return ok({ root: r.value, diagnostics });
 }
+function worldInstantiateScenePayload(world, asset, parent) {
+  const handle = world.allocSharedRef("SceneAsset", asset);
+  try {
+    return worldInstantiateScene(world, handle, parent);
+  } finally {
+    world.sharedRefs.release(handle);
+  }
+}
 function worldInstantiateSceneFlat(world, handle) {
   const stack = /* @__PURE__ */ new Set();
   const diagnostics = [];
@@ -1156,573 +1291,6 @@ function primitiveJsType(fieldType) {
   return "number";
 }
 
-// src/assets/scene-projection.ts
-var SCENE_ASSET_SKIN_RESOLVER_RESOURCE_KEY = "SceneAssetSkinResolver";
-var SCENE_ASSET_MESH_DEFAULT_RESOLVER_RESOURCE_KEY = "SceneAssetMeshDefaultResolver";
-var ASSET_KIND_BY_TARGET = Object.freeze({
-  MeshAsset: "mesh",
-  TextureAsset: "texture",
-  EquirectAsset: "equirect",
-  SamplerAsset: "sampler",
-  MaterialAsset: "material",
-  SceneAsset: "scene",
-  AudioClipAsset: "audio",
-  SkinAsset: "skin",
-  SkeletonAsset: "skeleton",
-  AnimationClip: "animation-clip",
-  AnimationGraph: "animation-graph",
-  FontAsset: "font",
-  RenderPipelineAsset: "render-pipeline",
-  TilesetAsset: "tileset",
-  VideoAsset: "video",
-  ParticleEffectAsset: "particle-effect"
-});
-var projectionStores = /* @__PURE__ */ new WeakMap();
-function projectionStoreFor(world) {
-  const current = projectionStores.get(world);
-  if (current !== void 0) return current;
-  const skeletonGuidByHandle = /* @__PURE__ */ new Map();
-  const skinByGuid = /* @__PURE__ */ new Map();
-  const skinBySkeletonGuid = /* @__PURE__ */ new Map();
-  const materialHandleByGuid = /* @__PURE__ */ new Map();
-  const resolver = {
-    resolveSkinAsset(skeletonHandle) {
-      const skeletonGuid = skeletonGuidByHandle.get(skeletonHandle);
-      return skeletonGuid === void 0 ? void 0 : skinBySkeletonGuid.get(skeletonGuid);
-    }
-  };
-  const meshDefaultResolver = {
-    resolveMeshDefaultMaterial(guid) {
-      return materialHandleByGuid.get(guid.toLowerCase());
-    }
-  };
-  const store = {
-    skeletonGuidByHandle,
-    skinByGuid,
-    skinBySkeletonGuid,
-    resolver,
-    materialHandleByGuid,
-    meshDefaultResolver
-  };
-  projectionStores.set(world, store);
-  world.insertResource(SCENE_ASSET_SKIN_RESOLVER_RESOURCE_KEY, resolver);
-  world.insertResource(SCENE_ASSET_MESH_DEFAULT_RESOLVER_RESOURCE_KEY, meshDefaultResolver);
-  return store;
-}
-function projectionError(code, detail) {
-  switch (code) {
-    case "scene-reference-target-unsupported":
-      return {
-        code,
-        expected: "every shared SceneAsset field target maps to a built-in Asset kind",
-        hint: "register the target in the AssetTagMap before projecting the scene",
-        detail
-      };
-    case "scene-reference-kind-mismatch":
-      return {
-        code,
-        expected: "the loaded payload kind matches the component shared-handle target",
-        hint: "repair the scene refs[] edge or republish the referenced asset",
-        detail
-      };
-    case "scene-reference-cycle":
-      return {
-        code,
-        expected: "an acyclic SceneAsset mount graph",
-        hint: "remove the circular mount.source reference and republish the scenes",
-        detail
-      };
-    case "scene-reference-unresolved":
-      return {
-        code,
-        expected: "a mount.source GUID that is loadable by the current AssetRegistry",
-        hint: "publish the child SceneAsset before projecting its parent",
-        detail
-      };
-  }
-}
-function isPayloadOfKind(value, kind) {
-  return typeof value === "object" && value !== null && value.kind === kind;
-}
-function sharedTarget(fieldType) {
-  if (typeof fieldType !== "string") return void 0;
-  const match = /^shared<([^>]+)>$/.exec(fieldType);
-  return match?.[1];
-}
-function schemaFieldType(field) {
-  if (typeof field === "object" && field !== null && "type" in field) {
-    return field.type;
-  }
-  return field;
-}
-function sharedArrayTarget(fieldType) {
-  if (typeof fieldType !== "string") return void 0;
-  const match = /^array<shared<([^>]+)>(?:,\s*\d+)? *>$/.exec(fieldType);
-  return match?.[1];
-}
-function resolveWireValue(value, refs, location) {
-  if (refs === void 0 || typeof value !== "number") return ok(value);
-  const guid = refs[value];
-  if (!Number.isInteger(value) || guid === void 0) {
-    return err(
-      projectionError("scene-reference-unresolved", {
-        source: `${location} refs[${value}]`
-      })
-    );
-  }
-  return ok(guid);
-}
-async function projectSharedValue(state, value, target, field) {
-  if (typeof value !== "string") {
-    if (target === "MeshAsset" && typeof value === "number") {
-      const resolved = state.world.sharedRefs.resolve(toShared(value));
-      if (resolved.ok && isPayloadOfKind(resolved.value, "mesh")) {
-        const meshDefaults = await projectMeshDefaults(state, resolved.value, field);
-        if (!meshDefaults.ok) return meshDefaults;
-      }
-    }
-    return ok(value);
-  }
-  const kind = ASSET_KIND_BY_TARGET[target];
-  if (kind === void 0) {
-    return err(
-      projectionError("scene-reference-target-unsupported", {
-        guid: value,
-        target,
-        field
-      })
-    );
-  }
-  const cacheKey = `${target}:${value.toLowerCase()}`;
-  const cached = state.assetHandles.get(cacheKey);
-  if (cached !== void 0) {
-    if (target === "SkeletonAsset") {
-      state.skinStore.skeletonGuidByHandle.set(Number(cached), value.toLowerCase());
-    }
-    return ok(cached);
-  }
-  const loaded = await state.load(value, kind);
-  if (!loaded.ok) return loaded;
-  if (!isPayloadOfKind(loaded.value, kind)) {
-    return err(
-      projectionError("scene-reference-kind-mismatch", {
-        guid: value,
-        target,
-        expectedKind: kind,
-        actualKind: typeof loaded.value === "object" && loaded.value !== null && "kind" in loaded.value ? String(loaded.value.kind) : typeof loaded.value,
-        field
-      })
-    );
-  }
-  if (target === "MeshAsset") {
-    const meshDefaults = await projectMeshDefaults(state, loaded.value, field);
-    if (!meshDefaults.ok) return meshDefaults;
-  }
-  const handle = state.world.allocSharedRef(target, loaded.value);
-  state.assetHandles.set(cacheKey, handle);
-  if (target === "SkeletonAsset") {
-    state.skinStore.skeletonGuidByHandle.set(Number(handle), value.toLowerCase());
-  }
-  return ok(handle);
-}
-async function projectMeshDefaults(state, mesh, field) {
-  if (!Array.isArray(mesh.materialSlots)) return ok(void 0);
-  for (let slotIndex = 0; slotIndex < mesh.materialSlots.length; slotIndex += 1) {
-    const defaultMaterial = mesh.materialSlots[slotIndex]?.defaultMaterial;
-    if (defaultMaterial === void 0) continue;
-    const guid = AssetGuid.format(defaultMaterial);
-    const projected = await projectSharedValue(
-      state,
-      guid,
-      "MaterialAsset",
-      `${field}.materialSlots[${slotIndex}].defaultMaterial`
-    );
-    if (!projected.ok) return projected;
-    state.skinStore.materialHandleByGuid.set(guid, Number(projected.value));
-  }
-  return ok(void 0);
-}
-async function projectSkinDependencies(state, asset) {
-  for (let index = 0; index < (asset.skinGuids?.length ?? 0); index += 1) {
-    const guid = asset.skinGuids?.[index];
-    if (guid === void 0) continue;
-    const guidKey = guid.toLowerCase();
-    if (state.skinStore.skinByGuid.has(guidKey)) continue;
-    const loaded = await state.load(guid, "skin");
-    if (!loaded.ok) return loaded;
-    if (!isPayloadOfKind(loaded.value, "skin")) {
-      return err(
-        projectionError("scene-reference-kind-mismatch", {
-          guid,
-          target: "SkinAsset",
-          expectedKind: "skin",
-          actualKind: typeof loaded.value === "object" && loaded.value !== null && "kind" in loaded.value ? String(loaded.value.kind) : typeof loaded.value,
-          field: `scene.skinGuids[${index}]`
-        })
-      );
-    }
-    const skin = loaded.value;
-    state.skinStore.skinByGuid.set(guidKey, skin);
-    state.skinStore.skinBySkeletonGuid.set(skin.skeletonGuid.toLowerCase(), skin);
-  }
-  return ok(void 0);
-}
-async function projectFields(state, componentName, rawFields, location, wireRefs) {
-  const component = state.world.components.resolve(componentName);
-  if (component === void 0) return ok({ ...rawFields });
-  const fields = { ...rawFields };
-  for (const [fieldName, value] of Object.entries(rawFields)) {
-    const fieldType = schemaFieldType(componentSchema2(component)[fieldName]);
-    const target = sharedTarget(fieldType);
-    if (target !== void 0) {
-      const wireValue = await resolveWireValue(
-        value,
-        wireRefs,
-        `${location}.${componentName}.${fieldName}`
-      );
-      if (!wireValue.ok) return wireValue;
-      const projected = await projectSharedValue(
-        state,
-        wireValue.value,
-        target,
-        `${location}.${componentName}.${fieldName}`
-      );
-      if (!projected.ok) return projected;
-      fields[fieldName] = projected.value;
-      continue;
-    }
-    const arrayTarget = sharedArrayTarget(fieldType);
-    if (arrayTarget === void 0 || !Array.isArray(value)) continue;
-    const projectedValues = [];
-    for (let index = 0; index < value.length; index += 1) {
-      const wireValue = await resolveWireValue(
-        value[index],
-        wireRefs,
-        `${location}.${componentName}.${fieldName}[${index}]`
-      );
-      if (!wireValue.ok) return wireValue;
-      const projected = await projectSharedValue(
-        state,
-        wireValue.value,
-        arrayTarget,
-        `${location}.${componentName}.${fieldName}[${index}]`
-      );
-      if (!projected.ok) return projected;
-      projectedValues.push(projected.value);
-    }
-    fields[fieldName] = projectedValues;
-  }
-  return ok(fields);
-}
-async function projectComponents(state, components, location, wireRefs) {
-  const projected = {};
-  for (const [componentName, rawFields] of Object.entries(components)) {
-    if (typeof rawFields !== "object" || rawFields === null || Array.isArray(rawFields)) continue;
-    const fields = await projectFields(
-      state,
-      componentName,
-      rawFields,
-      location,
-      wireRefs
-    );
-    if (!fields.ok) return fields;
-    projected[componentName] = fields.value;
-  }
-  return ok(projected);
-}
-async function projectOverride(state, override, index, wireRefs) {
-  const component = state.world.components.resolve(override.comp);
-  if (component === void 0) return ok(override);
-  if (override.field !== void 0) {
-    const fieldType = schemaFieldType(componentSchema2(component)[override.field]);
-    const target = sharedTarget(fieldType);
-    if (target !== void 0) {
-      const wireValue = await resolveWireValue(
-        override.value,
-        wireRefs,
-        `mount override ${index}.${override.comp}.${override.field}`
-      );
-      if (!wireValue.ok) return wireValue;
-      const value2 = await projectSharedValue(
-        state,
-        wireValue.value,
-        target,
-        `mount override ${index}.${override.comp}.${override.field}`
-      );
-      if (!value2.ok) return value2;
-      return ok({ ...override, value: value2.value });
-    }
-    const arrayTarget = sharedArrayTarget(fieldType);
-    if (arrayTarget !== void 0 && Array.isArray(override.value)) {
-      const values = [];
-      for (let element = 0; element < override.value.length; element += 1) {
-        const wireValue = await resolveWireValue(
-          override.value[element],
-          wireRefs,
-          `mount override ${index}.${override.comp}.${override.field}[${element}]`
-        );
-        if (!wireValue.ok) return wireValue;
-        const value2 = await projectSharedValue(
-          state,
-          wireValue.value,
-          arrayTarget,
-          `mount override ${index}.${override.comp}.${override.field}[${element}]`
-        );
-        if (!value2.ok) return value2;
-        values.push(value2.value);
-      }
-      return ok({ ...override, value: values });
-    }
-    return ok(override);
-  }
-  if (typeof override.value !== "object" || override.value === null || Array.isArray(override.value)) {
-    return ok(override);
-  }
-  const value = await projectFields(
-    state,
-    override.comp,
-    override.value,
-    `mount override ${index}`,
-    wireRefs
-  );
-  if (!value.ok) return value;
-  return ok({ ...override, value: value.value });
-}
-async function projectMount(state, mount, index, visiting, wireRefs) {
-  const components = mount.components === void 0 ? void 0 : await projectComponents(state, mount.components, `mount ${index}`, wireRefs);
-  if (components !== void 0 && !components.ok) return components;
-  const overrides = [];
-  for (let overrideIndex = 0; overrideIndex < (mount.overrides?.length ?? 0); overrideIndex += 1) {
-    const override = mount.overrides?.[overrideIndex];
-    if (override === void 0) continue;
-    const projected = await projectOverride(state, override, overrideIndex, wireRefs);
-    if (!projected.ok) return projected;
-    overrides.push(projected.value);
-  }
-  if (typeof mount.source !== "string") {
-    return ok({
-      ...mount,
-      ...components === void 0 ? {} : { components: components.value },
-      ...mount.overrides === void 0 ? {} : { overrides }
-    });
-  }
-  const sourceKey = mount.source.toLowerCase();
-  const cached = state.sceneHandles.get(sourceKey);
-  if (cached !== void 0) {
-    return ok({
-      ...mount,
-      source: cached,
-      ...components === void 0 ? {} : { components: components.value },
-      ...mount.overrides === void 0 ? {} : { overrides }
-    });
-  }
-  if (visiting.has(sourceKey)) {
-    return err(
-      projectionError("scene-reference-cycle", {
-        cycle: [...visiting, sourceKey]
-      })
-    );
-  }
-  const loaded = await state.load(mount.source, "scene");
-  if (!loaded.ok) return loaded;
-  if (!isPayloadOfKind(loaded.value, "scene")) {
-    return err(projectionError("scene-reference-unresolved", { source: mount.source }));
-  }
-  visiting.add(sourceKey);
-  const projectedChild = await projectScene(state, loaded.value, visiting);
-  visiting.delete(sourceKey);
-  if (!projectedChild.ok) return projectedChild;
-  const childHandle = state.world.allocSharedRef("SceneAsset", projectedChild.value);
-  state.sceneHandles.set(sourceKey, childHandle);
-  return ok({
-    ...mount,
-    source: childHandle,
-    ...components === void 0 ? {} : { components: components.value },
-    ...mount.overrides === void 0 ? {} : { overrides }
-  });
-}
-async function projectScene(state, asset, visiting) {
-  const skins = await projectSkinDependencies(state, asset);
-  if (!skins.ok) return skins;
-  const entities = [];
-  const wireRefs = sceneAssetWireRefs(asset);
-  for (const entity of asset.entities) {
-    const components = await projectComponents(
-      state,
-      entity.components,
-      `entity ${entity.localId}`,
-      wireRefs
-    );
-    if (!components.ok) return components;
-    entities.push({ localId: entity.localId, components: components.value });
-  }
-  const mounts = [];
-  for (let index = 0; index < (asset.mounts?.length ?? 0); index += 1) {
-    const mount = asset.mounts?.[index];
-    if (mount === void 0) continue;
-    const projected = await projectMount(state, mount, index, visiting, wireRefs);
-    if (!projected.ok) return projected;
-    mounts.push(projected.value);
-  }
-  return ok({
-    kind: "scene",
-    entities,
-    ...asset.mounts === void 0 ? {} : { mounts },
-    ...asset.skinGuids === void 0 ? {} : { skinGuids: [...asset.skinGuids] }
-  });
-}
-async function projectSceneAsset(world, asset, load) {
-  const skinStore = projectionStoreFor(world);
-  worldSetSceneAssetResolver(world, (source) => {
-    if (typeof source === "number") return ok(toShared(source));
-    return err(projectionError("scene-reference-unresolved", { source }));
-  });
-  return projectScene(
-    {
-      world,
-      load,
-      assetHandles: /* @__PURE__ */ new Map(),
-      sceneHandles: /* @__PURE__ */ new Map(),
-      skinStore
-    },
-    asset,
-    /* @__PURE__ */ new Set()
-  );
-}
-
-// src/components/children.ts
-import { defineRelationship } from "@forgeax/engine-ecs";
-var { source: ChildOf, target: Children } = defineRelationship({
-  sourceName: "ChildOf",
-  sourceField: "parent",
-  targetName: "Children",
-  targetField: "entities",
-  exclusive: true,
-  linkedSpawn: true
-});
-
-// src/components/morph-weights.ts
-import { defineComponent } from "@forgeax/engine-ecs";
-var MorphWeights = defineComponent("MorphWeights", {
-  weights: { type: "array<f32>" }
-});
-
-// src/components/name.ts
-import { defineComponent as defineComponent2 } from "@forgeax/engine-ecs";
-var Name = defineComponent2("Name", { value: { type: "string" } });
-
-// src/components/transform.ts
-import { defineComponent as defineComponent3 } from "@forgeax/engine-ecs";
-var IDENTITY_MAT4 = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-var Transform = defineComponent3("Transform", {
-  pos: { type: "array<f32, 3>", default: new Float32Array([0, 0, 0]) },
-  // Component order [x, y, z, w] end to end (glTF-aligned; E6).
-  quat: { type: "array<f32, 4>", default: new Float32Array([0, 0, 0, 1]) },
-  scale: { type: "array<f32, 3>", default: new Float32Array([1, 1, 1]) },
-  // `world` is field-level transient (D-5): scene collect skips it. The resolved
-  // world mat4 is derived by the propagate kernel from the persisted local TRS
-  // each frame, so serializing it would store reconstructable data (SSOT: local
-  // TRS). Round-trip re-derives an equivalent world on the first propagate pass.
-  world: { type: "array<f32, 16>", default: IDENTITY_MAT4, transient: true }
-});
-
-// src/instances/collect-profile.ts
-var SCENE_COLLECT_PROFILE = Object.freeze({
-  includeComponent: (_componentName, transient) => !transient,
-  includeField: (_componentName, _fieldName, transient) => !transient
-});
-
-// src/instances/externalization.ts
-function sharedKind(type) {
-  if (type?.startsWith("shared<")) return "one";
-  if (type?.startsWith("array<shared<")) return "many";
-  return void 0;
-}
-function overrideGuids(override, resolveSchema) {
-  const schema = resolveSchema(override.comp);
-  const values = override.field !== void 0 ? [[override.field, override.value]] : override.value !== null && typeof override.value === "object" && !Array.isArray(override.value) ? Object.entries(override.value) : [];
-  return values.flatMap(([field, value]) => {
-    const kind = sharedKind(schema?.[field]);
-    if (kind === "one" && typeof value === "string") return [{ field, guid: value }];
-    if (kind === "many" && Array.isArray(value)) {
-      return value.flatMap((item) => typeof item === "string" ? [{ field, guid: item }] : []);
-    }
-    return [];
-  });
-}
-function externalizeSceneAsset(scene, resolveSchema) {
-  const refs = [];
-  const indexByGuid = /* @__PURE__ */ new Map();
-  const addRef = (guid, sourceField, sceneEntityId) => {
-    const prior = indexByGuid.get(guid);
-    if (prior !== void 0) return prior;
-    const index = refs.length;
-    refs.push({ guid, sourceField, ...sceneEntityId === void 0 ? {} : { sceneEntityId } });
-    indexByGuid.set(guid, index);
-    return index;
-  };
-  const entities = scene.entities.map((entity) => {
-    const components = {};
-    for (const componentName of Object.keys(entity.components)) {
-      const schema = resolveSchema(componentName);
-      const source = entity.components[componentName];
-      if (source === void 0) continue;
-      const fields = {};
-      for (const fieldName of Object.keys(source)) {
-        const value = source[fieldName];
-        if (value === void 0) continue;
-        const kind = sharedKind(schema?.[fieldName]);
-        if (kind === "one" && typeof value === "string") {
-          fields[fieldName] = addRef(value, { componentName, fieldName }, entity.localId);
-        } else if (kind === "many" && Array.isArray(value)) {
-          fields[fieldName] = value.map(
-            (item, arrayIndex) => typeof item === "string" ? addRef(item, { componentName, fieldName, arrayIndex }, entity.localId) : item
-          );
-        } else {
-          fields[fieldName] = value;
-        }
-      }
-      if (Object.keys(fields).length > 0 || Object.keys(schema ?? {}).length === 0) {
-        components[componentName] = fields;
-      }
-    }
-    return { localId: entity.localId, components };
-  });
-  const mounts = scene.mounts?.map((mount) => {
-    const source = typeof mount.source === "string" ? addRef(
-      mount.source,
-      { componentName: "SceneInstance", fieldName: "source" },
-      mount.localId
-    ) : mount.source;
-    for (const { field, guid } of (mount.overrides ?? []).flatMap(
-      (override) => overrideGuids(override, resolveSchema)
-    )) {
-      addRef(guid, { componentName: "SceneInstance", fieldName: `overrides.${field}` });
-    }
-    return {
-      localId: mount.localId,
-      source,
-      memberFirst: mount.memberFirst,
-      memberCount: mount.memberCount,
-      ...mount.parent === void 0 ? {} : { parent: mount.parent },
-      ...mount.publicationFence === void 0 ? {} : { publicationFence: mount.publicationFence },
-      ...mount.overrides === void 0 ? {} : { overrides: mount.overrides.map((item) => ({ ...item })) }
-    };
-  });
-  for (const [arrayIndex, guid] of (scene.skinGuids ?? []).entries()) {
-    if (typeof guid !== "string") return err({ field: "skinGuids", value: guid });
-    addRef(guid, { componentName: "<scene>", fieldName: "skinGuids", arrayIndex });
-  }
-  return ok({
-    payload: {
-      entities,
-      ...mounts === void 0 || mounts.length === 0 ? {} : { mounts },
-      ...scene.skinGuids === void 0 ? {} : { skinGuids: scene.skinGuids.map((guid) => indexByGuid.get(guid)) }
-    },
-    refs
-  });
-}
-
 // src/systems/propagate-transforms.ts
 import {
   defineSystem,
@@ -2123,20 +1691,16 @@ export {
   MorphWeights,
   Name,
   PROPAGATE_TRANSFORMS_SYSTEM,
-  SCENE_ASSET_MESH_DEFAULT_RESOLVER_RESOURCE_KEY,
-  SCENE_ASSET_SKIN_RESOLVER_RESOURCE_KEY,
   SCENE_COLLECT_PROFILE,
   SceneError,
   Transform,
   TransformSet,
+  collectSubtree,
   externalizeSceneAsset,
   projectHierarchy,
-  projectSceneAsset,
   propagateTransforms,
   registerPropagateTransforms,
   sceneAssetContribution,
-  sceneAssetDecoder,
-  sceneAssetKind,
   scenePlugin,
   worldApplyMountOverride,
   worldBuildSceneEntityComponentDatas,
@@ -2150,6 +1714,7 @@ export {
   worldInstantiateSceneAsset,
   worldInstantiateSceneAssetFlat,
   worldInstantiateSceneFlat,
+  worldInstantiateScenePayload,
   worldInstantiateSceneRec,
   worldMountOverridesToStateMap,
   worldReattachSceneMember,
@@ -2158,7 +1723,6 @@ export {
   worldResolveSceneAsset,
   worldResolveSceneInstanceStatePayload,
   worldSetSceneAssetResolver,
-  worldSetSceneInstantiateHook,
   worldSetSceneOverride,
   worldSpawnMountEntity,
   worldSpawnSceneMembers,