@relu-interactives/spatial-ecs 0.2.17 → 0.2.21

package/dist/index.js

@@ -1,13 +1,13 @@
-import { MeshGeometrySystem, InstancedMeshSystem, EnvironmentSyncSystem, PostprocessingSyncSystem, LightSyncSystem, MaterialSyncSystem, PhysicsSyncSystem, AnimationSystem, AudioSystem, VideoSystem, CameraSyncSystem, TransformSyncSystem, ObjectVisibilitySystem, RenderSystem } from './chunk-EPK6MA7X.js';
-export { AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, ObjectVisibilitySystem, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, ScriptBehaviourSystem, TransformSyncSystem, VideoSystem } from './chunk-EPK6MA7X.js';
-import { registerDefaultFactories } from './chunk-CJW6K3CL.js';
-export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createInstanceSlotComponent, createInstancedMeshComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories } from './chunk-CJW6K3CL.js';
-import { ObjectManagementSystem, applyTransform } from './chunk-GRUK5TNL.js';
-export { ObjectManagementSystem, SHARED_MODEL_RESOURCE_FLAG, clearModelCache, loadSharedGltf, resolveDracoDecoderPath, setDracoDecoderPath } from './chunk-GRUK5TNL.js';
-import { SelectionTransformState, Object3DRef, Name, EntityType, ParentId, Environment, Postprocessing, ScriptComponent, InstancedMeshComponent, InstanceSlotComponent, AnimationComponent, TransformComponent, ModelComponent, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, CameraComponent, ImageTarget, LightComponent, MaterialComponent, MeshGeometryComponent, Selectable, PhysicsComponent } from './chunk-FTIQQK62.js';
-export { AnimationStateMachine, AnimationStateManager, components_exports as CoreComponents } from './chunk-FTIQQK62.js';
+import { MeshGeometrySystem, InstancedMeshSystem, EnvironmentSyncSystem, PostprocessingSyncSystem, LightSyncSystem, MaterialSyncSystem, PhysicsSyncSystem, AnimationSystem, AudioSystem, VideoSystem, CameraSyncSystem, TransformSyncSystem, ObjectVisibilitySystem, RenderSystem, spawnPrefab, despawnPrefab, buildNodeKeyMapsFromSnapshot, indexSnapshotByEntity, findTopLevelNestedRegions, collectSnapshotSubtreeIds, groupOverridePaths, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, canonicalizeComponentValue, mergeComponentValue, decanonicalizeComponentValue, computeInstanceOverrides, collectEntitySubtree, ADDED_NODE_MARKER_COMPONENT } from './chunk-5U3YS4JD.js';
+export { ADDED_NODE_MARKER_COMPONENT, AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, HYDRATABLE_ENTITY_KINDS, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, NODE_KEY_SEPARATOR, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, ScriptBehaviourSystem, TransformSyncSystem, VideoSystem, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeInstanceOverrides, decanonicalizeComponentValue, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, parseOverride, parsePrefabAsset, prefabFileVersionFor, restoreComponentState, restorePostCreateComponents, setPrefabAssetUrlResolver, spawnPrefab } from './chunk-5U3YS4JD.js';
+import { registerDefaultFactories } from './chunk-K6KMKKJ6.js';
+export { createAnimationComponent, createAudioComponent, createCameraComponent, createEntityTypeComponent, createEnvironmentComponent, createImageComponent, createImageTargetAnchorComponent, createImageTargetComponent, createInstanceSlotComponent, createInstancedMeshComponent, createLightComponent, createMaterialComponent, createMeshComponent, createMeshGeometryComponent, createModelComponent, createNameComponent, createObject3DRefComponent, createParentIdComponent, createPhysicsComponent, createPostprocessingComponent, createScriptComponent, createSelectableComponent, createSelectionTransformStateComponent, createSpriteComponent, createTransformComponent, createVideoComponent, registerDefaultComponentFactories, registerDefaultFactories } from './chunk-K6KMKKJ6.js';
+import { ObjectManagementSystem } from './chunk-AXRCGF63.js';
+export { ObjectManagementSystem, SHARED_MODEL_RESOURCE_FLAG, clearModelCache, loadSharedGltf, resolveDracoDecoderPath, setDracoDecoderPath } from './chunk-AXRCGF63.js';
+import { SelectionTransformState, Object3DRef, Name, EntityType, ParentId, Environment, Postprocessing, ScriptComponent } from './chunk-V7BNVTJW.js';
+export { AnimationStateMachine, AnimationStateManager, components_exports as CoreComponents } from './chunk-V7BNVTJW.js';
 import './chunk-QHILSPT4.js';
-import { normalizeDebugValue, DEBUG_CHANGE_IGNORED_SYSTEMS, cloneHistoryValue } from './chunk-R2WMVXZZ.js';
+import { normalizeDebugValue, DEBUG_CHANGE_IGNORED_SYSTEMS, cloneHistoryValue } from './chunk-ZXGHKX7N.js';
 import { __name } from './chunk-OY7ZODZP.js';
 export { Component } from './chunk-OY7ZODZP.js';
 import * as THREE from 'three';
@@ -574,6 +574,18 @@ var _World = class _World {
     }
     return this.getEntityById(parentIdComponent.value);
   }
+  /**
+   * Instantiate a prefab asset into this world at runtime — see
+   * {@link spawnPrefab}. Convenience wrapper so scripts and embedding apps
+   * can spawn without reaching for the object management system.
+   */
+  spawnPrefab(source, options) {
+    return spawnPrefab(this, source, options);
+  }
+  /** Remove a spawned prefab instance (root + descendants). */
+  despawnPrefab(rootEntityId) {
+    return despawnPrefab(this, rootEntityId);
+  }
   getObjectManagementSystem() {
     if (this.objectManagementSystem) return this.objectManagementSystem;
     const objectManagementSystem = this.systems.find(
@@ -847,6 +859,33 @@ var _World = class _World {
   getDebugSignature(maxDepth = 3) {
     return JSON.stringify(this.getDebugSnapshot(maxDepth));
   }
+  /**
+   * Serialize ONLY the given entities into the same columnar
+   * `{entities, components}` shape as {@link getDebugSnapshot} (no systems,
+   * no selection). Used by prefab/scene subtree serialization.
+   */
+  getEntitiesSnapshot(entityIds, maxDepth = 10) {
+    const idSet = new Set(entityIds);
+    const components = [...this.components.entries()].map(([componentClass, store]) => {
+      return {
+        component: componentClass.name,
+        entries: [...store.entries()].filter(([entityId]) => idSet.has(entityId)).map(([entityId, component]) => {
+          return {
+            entityId,
+            value: normalizeDebugValue(component, {
+              seen: /* @__PURE__ */ new WeakSet(),
+              depth: 0,
+              maxDepth
+            })
+          };
+        }).sort((a, b) => a.entityId - b.entityId)
+      };
+    }).filter(({ entries }) => entries.length > 0).sort((a, b) => a.component.localeCompare(b.component));
+    return {
+      entities: [...this.entities].filter((entityId) => idSet.has(entityId)).sort((a, b) => a - b),
+      components
+    };
+  }
   createHistorySnapshot() {
     return {
       selectedEntityId: this.getSelectedEntity(),
@@ -905,980 +944,422 @@ var _World = class _World {
 __name(_World, "World");
 var World = _World;
 
-// core/hydration/readers.ts
-function asRecord(value) {
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  return value;
-}
-__name(asRecord, "asRecord");
-function readString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  return typeof record.value === "string" ? record.value : null;
-}
-__name(readString, "readString");
-function readTransform(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return void 0;
-  }
-  const position = asRecord(record.position);
-  const rotation = asRecord(record.rotation);
-  const scale = asRecord(record.scale);
-  return {
-    position: position ? {
-      x: typeof position.x === "number" ? position.x : void 0,
-      y: typeof position.y === "number" ? position.y : void 0,
-      z: typeof position.z === "number" ? position.z : void 0
-    } : void 0,
-    rotation: rotation ? {
-      x: typeof rotation.x === "number" ? rotation.x : void 0,
-      y: typeof rotation.y === "number" ? rotation.y : void 0,
-      z: typeof rotation.z === "number" ? rotation.z : void 0
-    } : void 0,
-    scale: scale ? {
-      x: typeof scale.x === "number" ? scale.x : void 0,
-      y: typeof scale.y === "number" ? scale.y : void 0,
-      z: typeof scale.z === "number" ? scale.z : void 0
-    } : void 0
-  };
-}
-__name(readTransform, "readTransform");
-function readByComponent(components, componentName) {
-  const component = components.find((entry) => entry.component === componentName);
-  const map = /* @__PURE__ */ new Map();
-  if (!component) {
-    return map;
-  }
-  for (const entry of component.entries) {
-    map.set(entry.entityId, entry.value);
-  }
-  return map;
-}
-__name(readByComponent, "readByComponent");
-function readBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-__name(readBoolean, "readBoolean");
-function readNumber(value) {
-  return typeof value === "number" ? value : void 0;
-}
-__name(readNumber, "readNumber");
-
-// core/hydration/componentValues.ts
-function buildComponentValueMaps(snapshot) {
-  return {
-    object3DRefValues: readByComponent(snapshot.components, "Object3DRef"),
-    nameValues: readByComponent(snapshot.components, "Name"),
-    transformValues: readByComponent(snapshot.components, "TransformComponent"),
-    modelValues: readByComponent(snapshot.components, "ModelComponent"),
-    imageValues: readByComponent(snapshot.components, "ImageComponent"),
-    spriteValues: readByComponent(snapshot.components, "SpriteComponent"),
-    videoValues: readByComponent(snapshot.components, "VideoComponent"),
-    cameraValues: readByComponent(snapshot.components, "CameraComponent"),
-    environmentValues: readByComponent(snapshot.components, "Environment"),
-    postprocessingValues: readByComponent(snapshot.components, "Postprocessing"),
-    audioValues: readByComponent(snapshot.components, "AudioComponent"),
-    imageTargetValues: readByComponent(snapshot.components, "ImageTarget"),
-    lightValues: readByComponent(snapshot.components, "LightComponent"),
-    materialValues: readByComponent(snapshot.components, "MaterialComponent"),
-    meshGeometryValues: readByComponent(snapshot.components, "MeshGeometryComponent"),
-    selectableValues: readByComponent(snapshot.components, "Selectable"),
-    physicsValues: readByComponent(snapshot.components, "PhysicsComponent"),
-    animationValues: readByComponent(snapshot.components, "AnimationComponent"),
-    imageTargetAnchorValues: readByComponent(snapshot.components, "ImageTargetAnchor"),
-    scriptValues: readByComponent(snapshot.components, "ScriptComponent"),
-    instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
-    instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent")
-  };
-}
-__name(buildComponentValueMaps, "buildComponentValueMaps");
-
-// core/hydration/parentLinks.ts
-function applyParentLinks(snapshot, idMap, objectManagementSystem, world) {
-  const parentValues = readByComponent(snapshot.components, "ParentId");
-  for (const [sourceEntityId, parentValue] of parentValues.entries()) {
-    const targetEntityId = idMap.get(sourceEntityId);
-    if (targetEntityId === void 0) {
+// core/prefab/snapshotIdUtils.ts
+var asRecord = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+function remapScriptData(data, idMap, nullExternal, onExternal) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    const record = asRecord(value);
+    if (!record) {
+      result[key] = value;
       continue;
     }
-    const parentRecord = asRecord(parentValue);
-    const sourceParentId = parentRecord && typeof parentRecord.value === "number" ? parentRecord.value : null;
-    if (sourceParentId === null) {
-      objectManagementSystem.setParent(world, targetEntityId, null, {
-        preserveWorldTransform: false
-      });
+    if (record.type === "entity" && typeof record.value === "number") {
+      const mapped = idMap.get(record.value);
+      if (mapped !== void 0) {
+        result[key] = { ...record, value: mapped };
+      } else {
+        onExternal(`data/${key}`, record.value);
+        result[key] = nullExternal ? { ...record, value: null } : value;
+      }
       continue;
     }
-    const mappedParentId = idMap.get(sourceParentId);
-    objectManagementSystem.setParent(world, targetEntityId, mappedParentId ?? null, {
-      preserveWorldTransform: false
-    });
-  }
-}
-__name(applyParentLinks, "applyParentLinks");
-
-// core/hydration/postCreateComponents.ts
-function remapEntityRefsInScriptData(data, idMap) {
-  const result = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      const v = value;
-      if (v.type === "entity" && typeof v.value === "number") {
-        result[key] = { ...v, value: idMap.get(v.value) ?? v.value };
-      } else if (v.type === "component" && v.value !== null && typeof v.value === "object" && !Array.isArray(v.value) && typeof v.value.entityId === "number") {
-        const ref = v.value;
+    const componentRef = asRecord(record.value);
+    if (record.type === "component" && componentRef && typeof componentRef.entityId === "number") {
+      const mapped = idMap.get(componentRef.entityId);
+      if (mapped !== void 0) {
         result[key] = {
-          ...v,
-          value: { ...ref, entityId: idMap.get(ref.entityId) ?? ref.entityId }
+          ...record,
+          value: { ...componentRef, entityId: mapped }
         };
       } else {
-        result[key] = value;
+        onExternal(`data/${key}`, componentRef.entityId);
+        result[key] = nullExternal ? { ...record, value: null } : value;
       }
-    } else {
-      result[key] = value;
+      continue;
     }
+    result[key] = value;
   }
   return result;
 }
-__name(remapEntityRefsInScriptData, "remapEntityRefsInScriptData");
-function restorePostCreateComponents(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values, idMap) {
-  const objectRef = world.getComponent(targetEntityId, Object3DRef)?.object ?? null;
-  const sourceAudio = asRecord(values.audioValues.get(sourceEntityId));
-  if (sourceAudio && entityType !== "audio") {
-    const sourceOptions = asRecord(sourceAudio.options) ?? {};
-    objectManagementSystem.createComponentNow(
-      "audio",
-      world,
-      targetEntityId,
-      typeof sourceAudio.path === "string" ? sourceAudio.path : "",
-      sourceOptions,
-      {
-        object: objectRef,
-        listener: objectManagementSystem.getOrCreateAudioListener(),
-        isEditor: objectManagementSystem.isEditorMode()
-      }
-    );
-  }
-  const sourceImageTarget = asRecord(values.imageTargetValues.get(sourceEntityId));
-  if (sourceImageTarget && entityType !== "imageTarget") {
-    objectManagementSystem.createComponentNow(
-      "imageTarget",
-      world,
-      targetEntityId,
-      {
-        targets: Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [],
-        compiledTargetUrl: typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0,
-        compiledTargetDir: typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0
+__name(remapScriptData, "remapScriptData");
+function remapSnapshotEntityIds(snapshot, idMap, options) {
+  const nullExternal = options?.externalRefPolicy === "null";
+  const warnings = [];
+  const entities = snapshot.entities.map(
+    (entityId) => idMap.get(entityId) ?? entityId
+  );
+  const components = snapshot.components.map((block) => {
+    const entries = block.entries.map((entry) => {
+      const sourceEntityId = entry.entityId;
+      const mappedEntityId = idMap.get(sourceEntityId) ?? sourceEntityId;
+      const warn = /* @__PURE__ */ __name((path, targetId) => {
+        warnings.push({
+          entityId: sourceEntityId,
+          component: block.component,
+          path,
+          targetId
+        });
+      }, "warn");
+      let value = structuredClone(entry.value);
+      const record = asRecord(value);
+      if (block.component === "ParentId" && record) {
+        if (typeof record.value === "number") {
+          const mapped = idMap.get(record.value);
+          if (mapped !== void 0) {
+            record.value = mapped;
+          } else {
+            warn("value", record.value);
+            if (nullExternal) {
+              record.value = null;
+            }
+          }
+        }
+      } else if (block.component === "ScriptComponent" && record) {
+        if (Array.isArray(record.entries)) {
+          record.entries = record.entries.map((rawEntry, index) => {
+            const entryRecord = asRecord(rawEntry);
+            if (!entryRecord) {
+              return rawEntry;
+            }
+            const data = asRecord(entryRecord.data);
+            if (!data) {
+              return rawEntry;
+            }
+            return {
+              ...entryRecord,
+              data: remapScriptData(
+                data,
+                idMap,
+                nullExternal,
+                (path, target) => warn(`entries/${index}/${path}`, target)
+              )
+            };
+          });
+        }
+      } else if (block.component === "InstancedMeshComponent" && record) {
+        if (Array.isArray(record.instanceEntityIds)) {
+          const remapped = [];
+          record.instanceEntityIds.forEach((rawId, index) => {
+            if (typeof rawId !== "number") {
+              return;
+            }
+            const mapped = idMap.get(rawId);
+            if (mapped !== void 0) {
+              remapped.push(mapped);
+            } else {
+              warn(`instanceEntityIds/${index}`, rawId);
+              if (!nullExternal) {
+                remapped.push(rawId);
+              }
+            }
+          });
+          record.instanceEntityIds = remapped;
+        }
+      } else if (block.component === "InstanceSlotComponent" && record) {
+        if (typeof record.groupEntityId === "number" && record.groupEntityId !== -1) {
+          const mapped = idMap.get(record.groupEntityId);
+          if (mapped !== void 0) {
+            record.groupEntityId = mapped;
+          } else {
+            warn("groupEntityId", record.groupEntityId);
+            if (nullExternal) {
+              record.groupEntityId = -1;
+            }
+          }
+        }
       }
-    );
-  }
-  const sourceImageTargetAnchor = asRecord(values.imageTargetAnchorValues.get(sourceEntityId));
-  if (sourceImageTargetAnchor) {
-    const mappedTargetId = typeof sourceImageTargetAnchor.targetId === "number" && Number.isFinite(sourceImageTargetAnchor.targetId) ? sourceImageTargetAnchor.targetId : null;
-    objectManagementSystem.createComponentNow("imageTargetAnchor", world, targetEntityId, {
-      targetId: mappedTargetId,
-      targetUrl: typeof sourceImageTargetAnchor.targetUrl === "string" ? sourceImageTargetAnchor.targetUrl : void 0
+      value = record ?? value;
+      return { entityId: mappedEntityId, value };
     });
-  }
-  const sourceScript = asRecord(values.scriptValues.get(sourceEntityId));
-  if (sourceScript) {
-    const entries = Array.isArray(sourceScript.entries) ? sourceScript.entries.map((entry) => asRecord(entry)).filter((entry) => Boolean(entry)).map((entry) => {
-      const runtimeState = entry.runtimeState === "idle" || entry.runtimeState === "loading" || entry.runtimeState === "ready" || entry.runtimeState === "error" ? entry.runtimeState : void 0;
-      return {
-        entityId: targetEntityId,
-        className: typeof entry.className === "string" ? entry.className : "",
-        scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
-        enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
-        data: entry.data && typeof entry.data === "object" && !Array.isArray(entry.data) ? remapEntityRefsInScriptData(entry.data, idMap) : {},
-        runtimeState,
-        runtimeMessage: typeof entry.runtimeMessage === "string" ? entry.runtimeMessage : void 0
-      };
-    }).filter((entry) => entry.className || entry.scriptUrl) : [];
-    if (!entries.length) {
-      return;
-    }
-    world.addComponent(
-      targetEntityId,
-      new ScriptComponent(entries)
-    );
-  }
-  {
-    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
-    if (imComponent && imComponent.instanceEntityIds.length > 0) {
-      imComponent.instanceEntityIds = imComponent.instanceEntityIds.map(
-        (oldId) => idMap.get(oldId) ?? oldId
-      );
-    }
-  }
-  {
-    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
-    if (slotComponent && slotComponent.groupEntityId !== -1) {
-      slotComponent.groupEntityId = idMap.get(slotComponent.groupEntityId) ?? slotComponent.groupEntityId;
-    }
-  }
+    return { component: block.component, entries };
+  });
+  return { snapshot: { entities, components }, warnings };
 }
-__name(restorePostCreateComponents, "restorePostCreateComponents");
+__name(remapSnapshotEntityIds, "remapSnapshotEntityIds");
 
-// core/hydration/animation.ts
-function readAnimationClipName(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  if (typeof record.name === "string") {
-    return record.name;
-  }
-  return null;
+// core/prefab/applyPrefabToSnapshot.ts
+var asRecord2 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var clone = /* @__PURE__ */ __name((value) => structuredClone(value), "clone");
+var stableStringify = /* @__PURE__ */ __name((value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}, "stableStringify");
+function getBlock(snapshot, component) {
+  let block = snapshot.components.find((b) => b.component === component);
+  if (!block) {
+    block = { component, entries: [] };
+    snapshot.components.push(block);
+  }
+  return block;
 }
-__name(readAnimationClipName, "readAnimationClipName");
-function readAnimationStates(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const states = [];
-  for (const entry of value) {
-    const state = asRecord(entry);
-    if (!state) {
-      continue;
-    }
-    const name = typeof state.name === "string" ? state.name : null;
-    const clip = readAnimationClipName(state.clip);
-    if (!name || !clip) {
-      continue;
-    }
-    states.push({
-      name,
-      clip,
-      clipId: typeof state.clipId === "string" ? state.clipId : void 0,
-      loop: typeof state.loop === "boolean" ? state.loop : false
-    });
+__name(getBlock, "getBlock");
+function setEntry(snapshot, component, entityId, value) {
+  const block = getBlock(snapshot, component);
+  const entry = block.entries.find((e) => e.entityId === entityId);
+  if (entry) {
+    entry.value = value;
+  } else {
+    block.entries.push({ entityId, value });
+    block.entries.sort((a, b) => a.entityId - b.entityId);
   }
-  return states;
 }
-__name(readAnimationStates, "readAnimationStates");
-function readAnimationClipSources(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const sources = [];
-  for (const entry of value) {
-    if (typeof entry !== "string") {
-      continue;
-    }
-    const trimmed = entry.trim();
-    if (!trimmed || seen.has(trimmed)) {
-      continue;
-    }
-    seen.add(trimmed);
-    sources.push(trimmed);
-  }
-  return sources;
+__name(setEntry, "setEntry");
+function deleteEntities(snapshot, entityIds) {
+  snapshot.entities = snapshot.entities.filter((id) => !entityIds.has(id));
+  snapshot.components = snapshot.components.map((block) => ({
+    component: block.component,
+    entries: block.entries.filter((e) => !entityIds.has(e.entityId))
+  })).filter((block) => block.entries.length > 0);
 }
-__name(readAnimationClipSources, "readAnimationClipSources");
-function toAnimationOptions(sourceAnimation) {
-  const paused = readBoolean(sourceAnimation.paused);
-  const reverse = readBoolean(sourceAnimation.reverse);
-  const timeScale = readNumber(sourceAnimation.timeScale);
-  const crossFadeDuration = readNumber(sourceAnimation.crossFadeDuration);
-  const states = readAnimationStates(sourceAnimation.states);
-  const externalClipSources = readAnimationClipSources(
-    sourceAnimation.externalClipSources
-  );
-  const activeStateName = typeof sourceAnimation.activeStateName === "string" ? sourceAnimation.activeStateName : typeof sourceAnimation.activeState === "string" ? sourceAnimation.activeState : typeof sourceAnimation.active?.name === "string" ? sourceAnimation.active.name ?? null : null;
+__name(deleteEntities, "deleteEntities");
+function extractRegionDoc(hostSnapshot, regionIds) {
+  const idSet = new Set(regionIds);
   return {
-    paused,
-    reverse,
-    timeScale,
-    crossFadeDuration,
-    states,
-    externalClipSources,
-    activeState: activeStateName
+    entities: regionIds.slice(),
+    components: hostSnapshot.components.map((block) => ({
+      component: block.component,
+      entries: block.entries.filter((e) => idSet.has(e.entityId))
+    })).filter((block) => block.entries.length > 0)
   };
 }
-__name(toAnimationOptions, "toAnimationOptions");
-function restoreAnimationComponent(world, objectManagementSystem, targetEntityId, sourceAnimation) {
-  const options = toAnimationOptions(sourceAnimation);
-  let animation = world.getComponent(targetEntityId, AnimationComponent);
-  if (!animation) {
-    objectManagementSystem.createComponentNow(
-      "animation",
-      world,
-      targetEntityId,
-      options
+__name(extractRegionDoc, "extractRegionDoc");
+function applyPrefabToSnapshotInstances(hostSnapshot, nestedUrl, newNestedSnapshot) {
+  const host = clone(hostSnapshot);
+  const newMaps = buildNodeKeyMapsFromSnapshot(newNestedSnapshot);
+  const newByEntity = indexSnapshotByEntity(newNestedSnapshot);
+  if (!newMaps.rootKey) {
+    return { snapshot: host, changed: false };
+  }
+  let changed = false;
+  const regions = findTopLevelNestedRegions(host).filter(
+    (region) => region.url === nestedUrl
+  );
+  for (const region of regions) {
+    const before = stableStringify(
+      extractRegionDoc(host, collectSnapshotSubtreeIds(host, region.rootEntityId))
     );
-    animation = world.getComponent(targetEntityId, AnimationComponent);
-  }
-  if (!animation) {
-    return;
-  }
-  const availableClips = Array.isArray(sourceAnimation.availableClips) ? sourceAnimation.availableClips.filter(
-    (clip) => typeof clip === "string" && clip.length > 0
-  ) : [];
-  if (availableClips.length > 0) {
-    animation.availableClips = [...availableClips];
-  }
-  if (Array.isArray(options.externalClipSources)) {
-    animation.setExternalClipSources(options.externalClipSources);
-  }
-  const states = options.states ?? [];
-  const hasClips = Array.isArray(animation.clips) && animation.clips.length > 0;
-  if (!hasClips) {
-    animation.__pendingHydratedOptions = options;
-    if (typeof options.reverse === "boolean") {
-      animation.reverse = options.reverse;
-    }
-    if (typeof options.timeScale === "number") {
-      animation.timeScale = options.timeScale;
-    }
-    if (typeof options.crossFadeDuration === "number") {
-      animation.crossFadeDuration = options.crossFadeDuration;
-    }
-    if (typeof options.paused === "boolean") {
-      animation.paused = options.paused;
-    }
-    return;
-  }
-  if (states.length > 0) {
-    animation.setStates(states);
-  }
-  if (typeof options.reverse === "boolean") {
-    animation.reverse = options.reverse;
-  }
-  if (typeof options.timeScale === "number") {
-    animation.timeScale = options.timeScale;
-  }
-  if (typeof options.crossFadeDuration === "number") {
-    animation.crossFadeDuration = options.crossFadeDuration;
-  }
-  if (typeof options.activeState === "string" && options.activeState.length > 0) {
-    animation.setActiveState(options.activeState, !options.paused);
-  }
-  if (typeof options.paused === "boolean") {
-    if (options.paused) {
-      animation.pauseState();
-    } else if (typeof options.activeState === "string" && options.activeState.length > 0) {
-      animation.playState(options.activeState);
+    patchRegion(host, region.rootEntityId, region.overrides, {
+      newSnapshot: newNestedSnapshot,
+      newMaps,
+      newByEntity
+    });
+    const after = stableStringify(
+      extractRegionDoc(host, collectSnapshotSubtreeIds(host, region.rootEntityId))
+    );
+    if (before !== after) {
+      changed = true;
     }
   }
+  return { snapshot: host, changed };
 }
-__name(restoreAnimationComponent, "restoreAnimationComponent");
-
-// core/hydration/restoreComponentState.ts
-function readEnvironmentState(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  const nestedValues = asRecord(record.values);
-  if (nestedValues) {
-    return nestedValues;
-  }
-  return record;
-}
-__name(readEnvironmentState, "readEnvironmentState");
-function readPostprocessingState(value) {
-  const record = asRecord(value);
-  if (!record) {
-    return null;
-  }
-  const nestedValues = asRecord(record.values);
-  if (nestedValues) {
-    return nestedValues;
-  }
-  return record;
-}
-__name(readPostprocessingState, "readPostprocessingState");
-function restoreComponentState(world, objectManagementSystem, targetEntityId, sourceEntityId, entityType, values) {
-  const sourceName = readString(values.nameValues.get(sourceEntityId));
-  if (sourceName !== null) {
-    const nameComponent = world.getComponent(targetEntityId, Name);
-    if (nameComponent) {
-      nameComponent.value = sourceName;
-    }
-  }
-  const sourceObject3DRef = asRecord(values.object3DRefValues.get(sourceEntityId));
-  if (sourceObject3DRef) {
-    const object3DRefComponent = world.getComponent(targetEntityId, Object3DRef);
-    const visibility = readBoolean(sourceObject3DRef.visibility);
-    if (object3DRefComponent && typeof visibility === "boolean") {
-      object3DRefComponent.visibility = visibility;
-    }
-  }
-  const sourceTransform = readTransform(values.transformValues.get(sourceEntityId));
-  if (sourceTransform) {
-    const transformComponent = world.getComponent(targetEntityId, TransformComponent);
-    if (transformComponent) {
-      if (typeof sourceTransform.position?.x === "number") {
-        transformComponent.position.x = sourceTransform.position.x;
-      }
-      if (typeof sourceTransform.position?.y === "number") {
-        transformComponent.position.y = sourceTransform.position.y;
-      }
-      if (typeof sourceTransform.position?.z === "number") {
-        transformComponent.position.z = sourceTransform.position.z;
-      }
-      if (typeof sourceTransform.rotation?.x === "number") {
-        transformComponent.rotation.x = sourceTransform.rotation.x;
-      }
-      if (typeof sourceTransform.rotation?.y === "number") {
-        transformComponent.rotation.y = sourceTransform.rotation.y;
-      }
-      if (typeof sourceTransform.rotation?.z === "number") {
-        transformComponent.rotation.z = sourceTransform.rotation.z;
-      }
-      if (typeof sourceTransform.scale?.x === "number") {
-        transformComponent.scale.x = sourceTransform.scale.x;
-      }
-      if (typeof sourceTransform.scale?.y === "number") {
-        transformComponent.scale.y = sourceTransform.scale.y;
-      }
-      if (typeof sourceTransform.scale?.z === "number") {
-        transformComponent.scale.z = sourceTransform.scale.z;
-      }
-    }
-  }
-  const sourceModel = asRecord(values.modelValues.get(sourceEntityId));
-  if (sourceModel) {
-    const modelComponent = world.getComponent(targetEntityId, ModelComponent);
-    if (modelComponent && typeof sourceModel.path === "string") {
-      modelComponent.path = sourceModel.path;
-    }
-  }
-  const sourceImage = asRecord(values.imageValues.get(sourceEntityId));
-  if (sourceImage) {
-    const imageComponent = world.getComponent(targetEntityId, ImageComponent);
-    if (imageComponent) {
-      if (typeof sourceImage.path === "string") {
-        imageComponent.path = sourceImage.path;
-      }
-      const width = readNumber(sourceImage.width);
-      if (typeof width === "number") {
-        imageComponent.width = width;
-      }
-      const height = readNumber(sourceImage.height);
-      if (typeof height === "number") {
-        imageComponent.height = height;
-      }
-    }
-  }
-  const sourceSprite = asRecord(values.spriteValues.get(sourceEntityId));
-  if (sourceSprite) {
-    const spriteComponent = world.getComponent(targetEntityId, SpriteComponent);
-    if (spriteComponent) {
-      if (typeof sourceSprite.path === "string") {
-        spriteComponent.path = sourceSprite.path;
-      }
-      const width = readNumber(sourceSprite.width);
-      if (typeof width === "number") {
-        spriteComponent.width = width;
-      }
-      const height = readNumber(sourceSprite.height);
-      if (typeof height === "number") {
-        spriteComponent.height = height;
+__name(applyPrefabToSnapshotInstances, "applyPrefabToSnapshotInstances");
+function patchRegion(host, regionRootId, storedOverrides, file) {
+  const { newSnapshot, newMaps, newByEntity } = file;
+  const regionIds = collectSnapshotSubtreeIds(host, regionRootId);
+  const regionDoc = extractRegionDoc(host, regionIds);
+  const regionMaps = buildNodeKeyMapsFromSnapshot(regionDoc, {
+    scopeRootEntityId: regionRootId
+  });
+  const regionByEntity = indexSnapshotByEntity(regionDoc);
+  const grouped = groupOverridePaths(storedOverrides);
+  const overridePathsFor = /* @__PURE__ */ __name((key, component) => grouped.get(key)?.get(component), "overridePathsFor");
+  const isMarkedAddition = /* @__PURE__ */ __name((key) => Boolean(grouped.get(key)?.get(ADDED_NODE_MARKER_COMPONENT)), "isMarkedAddition");
+  const parentBlockNew = newSnapshot.components.find(
+    (b) => b.component === "ParentId"
+  );
+  const keyToHostId = /* @__PURE__ */ new Map();
+  for (const [hostId, key] of regionMaps.idToKey) {
+    keyToHostId.set(key, hostId);
+  }
+  const addedFileIds = [...newMaps.keyToId.entries()].filter(([key]) => !keyToHostId.has(key)).map(([, fileId]) => fileId);
+  if (addedFileIds.length > 0) {
+    let nextHostId = Math.max(0, ...host.entities) + 1;
+    const addedSet = new Set(addedFileIds);
+    const idMap = /* @__PURE__ */ new Map();
+    for (const [key, fileId] of newMaps.keyToId) {
+      const hostId = keyToHostId.get(key);
+      if (hostId !== void 0) {
+        idMap.set(fileId, hostId);
       }
     }
-  }
-  const sourceVideo = asRecord(values.videoValues.get(sourceEntityId));
-  if (sourceVideo) {
-    const videoComponent = world.getComponent(targetEntityId, VideoComponent);
-    if (videoComponent) {
-      if (typeof sourceVideo.path === "string") {
-        videoComponent.path = sourceVideo.path;
-      }
-      const videoOptions = asRecord(sourceVideo.options);
-      if (videoOptions) {
-        videoComponent.options = {
-          ...videoComponent.options,
-          ...videoOptions
-        };
-      }
+    for (const fileId of addedFileIds) {
+      idMap.set(fileId, nextHostId);
+      nextHostId += 1;
     }
-  }
-  const sourceAudio = asRecord(values.audioValues.get(sourceEntityId));
-  if (sourceAudio && entityType === "audio") {
-    const audioComponent = world.getComponent(targetEntityId, AudioComponent);
-    if (audioComponent) {
-      if (typeof sourceAudio.path === "string") {
-        audioComponent.path = sourceAudio.path;
-      }
-      const audioOptions = asRecord(sourceAudio.options);
-      if (audioOptions) {
-        audioComponent.options = {
-          ...audioComponent.options,
-          ...audioOptions
-        };
+    const addedSub = {
+      entities: newSnapshot.entities.filter((id) => addedSet.has(id)),
+      components: newSnapshot.components.map((block) => ({
+        component: block.component,
+        entries: block.entries.filter((e) => addedSet.has(e.entityId))
+      })).filter((block) => block.entries.length > 0)
+    };
+    const { snapshot: remapped } = remapSnapshotEntityIds(addedSub, idMap, {
+      externalRefPolicy: "null"
+    });
+    host.entities = [...host.entities, ...remapped.entities];
+    for (const block of remapped.components) {
+      for (const entry of block.entries) {
+        setEntry(host, block.component, entry.entityId, entry.value);
       }
     }
-  }
-  const sourceCamera = asRecord(values.cameraValues.get(sourceEntityId));
-  if (sourceCamera) {
-    const cameraComponent = world.getComponent(targetEntityId, CameraComponent);
-    if (cameraComponent) {
-      if (sourceCamera.projection === "orthographic" || sourceCamera.projection === "perspective") {
-        cameraComponent.projection = sourceCamera.projection;
-      }
-      if (sourceCamera.type === "3d" || sourceCamera.type === "ar") {
-        cameraComponent.type = sourceCamera.type;
-      }
-      if (typeof sourceCamera.isDefault === "boolean") {
-        cameraComponent.isDefault = sourceCamera.isDefault;
-      }
-      const fov = readNumber(sourceCamera.fov);
-      if (typeof fov === "number") {
-        cameraComponent.fov = fov;
-      }
-      const near = readNumber(sourceCamera.near);
-      if (typeof near === "number") {
-        cameraComponent.near = near;
-      }
-      const far = readNumber(sourceCamera.far);
-      if (typeof far === "number") {
-        cameraComponent.far = far;
-      }
-      const left = readNumber(sourceCamera.left);
-      if (typeof left === "number") {
-        cameraComponent.left = left;
-      }
-      const right = readNumber(sourceCamera.right);
-      if (typeof right === "number") {
-        cameraComponent.right = right;
-      }
-      const top = readNumber(sourceCamera.top);
-      if (typeof top === "number") {
-        cameraComponent.top = top;
-      }
-      const bottom = readNumber(sourceCamera.bottom);
-      if (typeof bottom === "number") {
-        cameraComponent.bottom = bottom;
+    for (const fileId of addedFileIds) {
+      const hostId = idMap.get(fileId);
+      const parentValue = asRecord2(
+        parentBlockNew?.entries.find((e) => e.entityId === fileId)?.value
+      )?.value;
+      if (typeof parentValue === "number" && !addedSet.has(parentValue)) {
+        const parentKey = newMaps.idToKey.get(parentValue);
+        const parentHost = parentKey ? keyToHostId.get(parentKey) : void 0;
+        setEntry(host, "ParentId", hostId, {
+          __type: "ParentId",
+          value: parentHost ?? regionRootId
+        });
       }
-      const zoom = readNumber(sourceCamera.zoom);
-      if (typeof zoom === "number") {
-        cameraComponent.zoom = zoom;
+      const key = newMaps.idToKey.get(fileId);
+      if (key) {
+        keyToHostId.set(key, hostId);
       }
     }
   }
-  const sourceEnvironment = readEnvironmentState(
-    values.environmentValues.get(sourceEntityId)
-  );
-  if (sourceEnvironment) {
-    let environmentComponent = world.getComponent(targetEntityId, Environment);
-    if (!environmentComponent) {
-      objectManagementSystem.createComponentNow(
-        "environment",
-        world,
-        targetEntityId,
-        sourceEnvironment
+  for (const [key, fileId] of newMaps.keyToId) {
+    const hostId = keyToHostId.get(key);
+    if (hostId === void 0) continue;
+    const isRegionRoot = key === newMaps.rootKey;
+    const fileComponents = newByEntity.get(fileId);
+    if (!fileComponents) continue;
+    const regionEntityComponents = regionByEntity.get(hostId);
+    for (const [componentName, fileRaw] of fileComponents) {
+      if (OVERRIDE_DIFF_EXCLUDED_COMPONENTS.has(componentName)) continue;
+      if (isRegionRoot && OVERRIDE_ROOT_EXCLUDED_COMPONENTS.has(componentName))
+        continue;
+      const fileCanonical = canonicalizeComponentValue(
+        componentName,
+        fileRaw,
+        newMaps.idToKey
       );
-      environmentComponent = world.getComponent(targetEntityId, Environment);
-    }
-    if (environmentComponent) {
-      environmentComponent.values = new Environment({
-        ...environmentComponent.values,
-        ...sourceEnvironment
-      }).values;
-    }
-  }
-  const sourcePostprocessing = readPostprocessingState(
-    values.postprocessingValues.get(sourceEntityId)
-  );
-  if (sourcePostprocessing) {
-    let postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
-    if (!postprocessingComponent) {
-      objectManagementSystem.createComponentNow(
-        "postprocessing",
-        world,
-        targetEntityId,
-        sourcePostprocessing
+      const regionRaw = regionEntityComponents?.get(componentName);
+      const regionCanonical = regionRaw === void 0 ? void 0 : canonicalizeComponentValue(
+        componentName,
+        regionRaw,
+        regionMaps.idToKey
       );
-      postprocessingComponent = world.getComponent(targetEntityId, Postprocessing);
-    }
-    if (postprocessingComponent) {
-      postprocessingComponent.values = new Postprocessing({
-        ...postprocessingComponent.values,
-        ...sourcePostprocessing
-      }).values;
-    }
-  }
-  const sourceImageTarget = asRecord(values.imageTargetValues.get(sourceEntityId));
-  if (sourceImageTarget && entityType === "imageTarget") {
-    const imageTargetComponent = world.getComponent(targetEntityId, ImageTarget);
-    if (imageTargetComponent) {
-      imageTargetComponent.targets = Array.isArray(sourceImageTarget.targets) ? sourceImageTarget.targets : [];
-      imageTargetComponent.compiledTargetUrl = typeof sourceImageTarget.compiledTargetUrl === "string" ? sourceImageTarget.compiledTargetUrl : void 0;
-      imageTargetComponent.compiledTargetDir = typeof sourceImageTarget.compiledTargetDir === "string" ? sourceImageTarget.compiledTargetDir : void 0;
-    }
-  }
-  const sourceLight = asRecord(values.lightValues.get(sourceEntityId));
-  if (sourceLight) {
-    const lightComponent = world.getComponent(targetEntityId, LightComponent);
-    const sourceValues = asRecord(sourceLight.values);
-    if (lightComponent && sourceValues) {
-      lightComponent.values = {
-        ...lightComponent.values,
-        ...sourceValues
-      };
-    }
-  }
-  const sourceMaterial = asRecord(values.materialValues.get(sourceEntityId));
-  if (sourceMaterial) {
-    const materialComponent = world.getComponent(targetEntityId, MaterialComponent);
-    const sourceValues = sourceMaterial.values;
-    if (materialComponent && Array.isArray(sourceValues)) {
-      materialComponent.values = sourceValues;
-    }
-  }
-  const sourceMeshGeometry = asRecord(values.meshGeometryValues.get(sourceEntityId));
-  if (sourceMeshGeometry) {
-    const meshGeometryComponent = world.getComponent(
-      targetEntityId,
-      MeshGeometryComponent
-    );
-    if (meshGeometryComponent) {
-      const parameters = asRecord(sourceMeshGeometry.parameters);
-      if (parameters) {
-        meshGeometryComponent.parameters = parameters;
-      }
-      if (typeof sourceMeshGeometry.modelName === "string") {
-        meshGeometryComponent.modelName = sourceMeshGeometry.modelName;
-      }
-      if (typeof sourceMeshGeometry.castShadow === "boolean") {
-        meshGeometryComponent.castShadow = sourceMeshGeometry.castShadow;
-      }
-      if (typeof sourceMeshGeometry.receiveShadow === "boolean") {
-        meshGeometryComponent.receiveShadow = sourceMeshGeometry.receiveShadow;
+      const merged = regionCanonical === void 0 ? fileCanonical : mergeComponentValue(
+        fileCanonical,
+        regionCanonical,
+        overridePathsFor(key, componentName)
+      );
+      if (regionCanonical !== void 0 && stableStringify(merged) === stableStringify(regionCanonical)) {
+        continue;
       }
+      const hostValue = decanonicalizeComponentValue(merged, keyToHostId);
+      setEntry(host, componentName, hostId, hostValue);
     }
   }
-  const sourceSelectable = asRecord(values.selectableValues.get(sourceEntityId));
-  if (sourceSelectable) {
-    const enabled = readBoolean(sourceSelectable.enabled);
-    let selectable = world.getComponent(targetEntityId, Selectable);
-    if (!selectable) {
-      objectManagementSystem.createComponentNow(
-        "selectable",
-        world,
-        targetEntityId,
-        enabled ?? true
-      );
-      selectable = world.getComponent(targetEntityId, Selectable);
-    }
-    if (selectable && typeof enabled === "boolean") {
-      selectable.enabled = enabled;
-    }
-  }
-  const sourcePhysics = asRecord(values.physicsValues.get(sourceEntityId));
-  if (sourcePhysics) {
-    const physicsValues = asRecord(sourcePhysics.values) ?? sourcePhysics;
-    let physics = world.getComponent(targetEntityId, PhysicsComponent);
-    if (!physics) {
-      objectManagementSystem.createComponentNow(
-        "physics",
-        world,
-        targetEntityId,
-        physicsValues
-      );
-      physics = world.getComponent(targetEntityId, PhysicsComponent);
-    }
-    if (physics) {
-      physics.setValues({
-        rigidbody: asRecord(physicsValues.rigidbody) ?? {},
-        collider: asRecord(physicsValues.collider) ?? {}
-      });
-    }
+  const removedHostIds = /* @__PURE__ */ new Set();
+  for (const [key, hostId] of keyToHostId) {
+    if (newMaps.keyToId.has(key)) continue;
+    if (isMarkedAddition(key)) continue;
+    removedHostIds.add(hostId);
   }
-  const sourceAnimation = asRecord(values.animationValues.get(sourceEntityId));
-  if (sourceAnimation) {
-    restoreAnimationComponent(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceAnimation
+  if (removedHostIds.size > 0) {
+    const regionIdSet = new Set(regionIds);
+    const parentBlockHost = host.components.find(
+      (b) => b.component === "ParentId"
     );
-  }
-  const sourceInstancedMesh = asRecord(values.instancedMeshValues.get(sourceEntityId));
-  if (sourceInstancedMesh) {
-    const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
-    if (imComponent) {
-      if (typeof sourceInstancedMesh.meshKind === "string") {
-        imComponent.meshKind = sourceInstancedMesh.meshKind;
-      }
-      if (typeof sourceInstancedMesh.modelPath === "string") {
-        imComponent.modelPath = sourceInstancedMesh.modelPath;
-      }
-      const parameters = asRecord(sourceInstancedMesh.meshParameters);
-      if (parameters) {
-        imComponent.meshParameters = parameters;
+    for (const entry of parentBlockHost?.entries ?? []) {
+      const record = asRecord2(entry.value);
+      if (!removedHostIds.has(entry.entityId) && regionIdSet.has(entry.entityId) && record && typeof record.value === "number" && removedHostIds.has(record.value)) {
+        record.value = regionRootId;
       }
-      if (typeof sourceInstancedMesh.castShadow === "boolean") {
-        imComponent.castShadow = sourceInstancedMesh.castShadow;
-      }
-      if (typeof sourceInstancedMesh.receiveShadow === "boolean") {
-        imComponent.receiveShadow = sourceInstancedMesh.receiveShadow;
-      }
-      if (Array.isArray(sourceInstancedMesh.instanceEntityIds)) {
-        imComponent.instanceEntityIds = sourceInstancedMesh.instanceEntityIds;
-      }
-      imComponent.instancedMesh = null;
     }
+    deleteEntities(host, removedHostIds);
   }
-  const sourceInstanceSlot = asRecord(values.instanceSlotValues.get(sourceEntityId));
-  if (sourceInstanceSlot) {
-    const slotComponent = world.getComponent(targetEntityId, InstanceSlotComponent);
-    if (slotComponent) {
-      if (typeof sourceInstanceSlot.slotIndex === "number") {
-        slotComponent.slotIndex = sourceInstanceSlot.slotIndex;
-      }
-    }
+  const refreshedRegionIds = collectSnapshotSubtreeIds(host, regionRootId);
+  const refreshedDoc = extractRegionDoc(host, refreshedRegionIds);
+  const refreshedOverrides = computeInstanceOverrides(
+    newSnapshot,
+    refreshedDoc,
+    { emitAdditionMarkers: true }
+  );
+  const instanceEntry = asRecord2(
+    host.components.find((b) => b.component === "PrefabInstance")?.entries.find((e) => e.entityId === regionRootId)?.value
+  );
+  if (instanceEntry) {
+    instanceEntry.overrides = refreshedOverrides;
   }
 }
-__name(restoreComponentState, "restoreComponentState");
-
-// core/hydration/types.ts
-var HYDRATABLE_ENTITY_KINDS = /* @__PURE__ */ new Set([
-  "cube",
-  "sphere",
-  "plane",
-  "capsule",
-  "cylinder",
-  "empty",
-  "model",
-  "image",
-  "imageTarget",
-  "sprite",
-  "audio",
-  "camera",
-  "video",
-  "ambientLight",
-  "directionalLight",
-  "pointLight",
-  "spotLight",
-  "areaLight",
-  "instancedMesh",
-  "instanceSlot"
-]);
+__name(patchRegion, "patchRegion");
 
-// core/hydration/hydrateWorld.ts
-function buildEntityCreationPayload(sourceEntityId, kind, componentValues) {
-  const payload = {
-    name: readString(componentValues.nameValues.get(sourceEntityId)) ?? void 0,
-    transform: readTransform(componentValues.transformValues.get(sourceEntityId))
-  };
-  if (kind === "model") {
-    const model = asRecord(componentValues.modelValues.get(sourceEntityId));
-    if (typeof model?.path === "string") {
-      payload.path = model.path;
-    }
-  }
-  if (kind === "image") {
-    const image = asRecord(componentValues.imageValues.get(sourceEntityId));
-    if (typeof image?.path === "string") {
-      payload.path = image.path;
-    }
-  }
-  if (kind === "sprite") {
-    const sprite = asRecord(componentValues.spriteValues.get(sourceEntityId));
-    if (typeof sprite?.path === "string") {
-      payload.path = sprite.path;
-    }
-  }
-  if (kind === "video") {
-    const video = asRecord(componentValues.videoValues.get(sourceEntityId));
-    if (typeof video?.path === "string") {
-      payload.path = video.path;
-    }
-    const videoOptions = asRecord(video?.options);
-    if (videoOptions) {
-      payload.options = videoOptions;
-    }
-  }
-  if (kind === "audio") {
-    const audio = asRecord(componentValues.audioValues.get(sourceEntityId));
-    if (typeof audio?.path === "string") {
-      payload.path = audio.path;
-    }
-    const audioOptions = asRecord(audio?.options);
-    if (audioOptions) {
-      payload.options = audioOptions;
-    }
-  }
-  if (kind === "camera") {
-    const camera = asRecord(componentValues.cameraValues.get(sourceEntityId));
-    if (camera) {
-      const projection = camera.projection === "orthographic" || camera.projection === "perspective" ? camera.projection : void 0;
-      const type = camera.type === "3d" || camera.type === "ar" ? camera.type : void 0;
-      payload.options = {
-        isDefault: typeof camera.isDefault === "boolean" ? camera.isDefault : void 0,
-        projection,
-        type,
-        fov: typeof camera.fov === "number" ? camera.fov : void 0,
-        near: typeof camera.near === "number" ? camera.near : void 0,
-        far: typeof camera.far === "number" ? camera.far : void 0,
-        left: typeof camera.left === "number" ? camera.left : void 0,
-        right: typeof camera.right === "number" ? camera.right : void 0,
-        top: typeof camera.top === "number" ? camera.top : void 0,
-        bottom: typeof camera.bottom === "number" ? camera.bottom : void 0,
-        zoom: typeof camera.zoom === "number" ? camera.zoom : void 0
-      };
-    }
-  }
-  if (kind === "imageTarget") {
-    const imageTarget = asRecord(componentValues.imageTargetValues.get(sourceEntityId));
-    if (imageTarget) {
-      payload.options = {
-        targets: Array.isArray(imageTarget.targets) ? imageTarget.targets : [],
-        compiledTargetUrl: typeof imageTarget.compiledTargetUrl === "string" ? imageTarget.compiledTargetUrl : void 0,
-        compiledTargetDir: typeof imageTarget.compiledTargetDir === "string" ? imageTarget.compiledTargetDir : void 0
-      };
-    }
-  }
-  if (kind === "instancedMesh") {
-    const im = asRecord(componentValues.instancedMeshValues.get(sourceEntityId));
-    if (im) {
-      payload.options = {
-        meshKind: typeof im.meshKind === "string" ? im.meshKind : "cube",
-        modelPath: typeof im.modelPath === "string" ? im.modelPath : void 0,
-        meshParameters: asRecord(im.meshParameters) ?? void 0,
-        castShadow: typeof im.castShadow === "boolean" ? im.castShadow : false,
-        receiveShadow: typeof im.receiveShadow === "boolean" ? im.receiveShadow : false,
-        // New format: signal the factory to skip child entity creation.
-        // Old format (instances[]): pass through for migration — factory will
-        // create slot entities from the legacy InstanceTransform array.
-        ...Array.isArray(im.instanceEntityIds) ? { instanceEntityIds: im.instanceEntityIds } : Array.isArray(im.instances) ? { instances: im.instances } : {}
-      };
-    }
-  }
-  if (kind === "instanceSlot") {
-    const slot = asRecord(componentValues.instanceSlotValues.get(sourceEntityId));
-    if (slot) {
-      payload.options = {
-        groupEntityId: typeof slot.groupEntityId === "number" ? slot.groupEntityId : -1,
-        slotIndex: typeof slot.slotIndex === "number" ? slot.slotIndex : 0
-      };
-    }
-  }
-  return payload;
-}
-__name(buildEntityCreationPayload, "buildEntityCreationPayload");
-function resolvePrimaryCameraSourceEntityId(snapshot, componentValues, entityTypeValues) {
-  let firstCameraSourceEntityId = null;
-  for (const sourceEntityId of snapshot.entities) {
-    const entityType = readString(entityTypeValues.get(sourceEntityId));
-    if (entityType !== "camera") {
-      continue;
-    }
-    if (firstCameraSourceEntityId === null) {
-      firstCameraSourceEntityId = sourceEntityId;
-    }
-    const cameraValue = asRecord(componentValues.cameraValues.get(sourceEntityId));
-    if (cameraValue?.isDefault === true) {
-      return sourceEntityId;
-    }
+// core/prefab/dependencies.ts
+function collectDirectPrefabDependencies(snapshot) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const region of findTopLevelNestedRegions(snapshot)) {
+    urls.add(region.url);
   }
-  return firstCameraSourceEntityId;
+  return [...urls];
 }
-__name(resolvePrimaryCameraSourceEntityId, "resolvePrimaryCameraSourceEntityId");
-function applyLocalTransformsAfterHierarchyRestore(world) {
-  const transformEntities = world.query(TransformComponent, Object3DRef);
-  for (const entityId of transformEntities) {
-    const transform = world.getComponent(entityId, TransformComponent);
-    const object = world.getComponent(entityId, Object3DRef)?.object;
-    if (!transform || !object) {
-      continue;
+__name(collectDirectPrefabDependencies, "collectDirectPrefabDependencies");
+
+// core/prefab/serializeEntitySubtree.ts
+var SUBTREE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
+  "Environment",
+  "Postprocessing",
+  "SelectionTransformState"
+]);
+function serializeEntitySubtree(world, rootId, options) {
+  const orderedIds = collectEntitySubtree(world, [rootId]);
+  const raw = world.getEntitiesSnapshot(orderedIds, options?.maxDepth ?? 10);
+  const strippedComponents = [];
+  const components = raw.components.filter((block) => {
+    if (SUBTREE_EXCLUDED_COMPONENTS.has(block.component)) {
+      strippedComponents.push(block.component);
+      return false;
     }
-    applyTransform(object, transform);
-    object.updateMatrixWorld(true);
-  }
-}
-__name(applyLocalTransformsAfterHierarchyRestore, "applyLocalTransformsAfterHierarchyRestore");
-function hydrateWorldFromSnapshotDetailed(snapshot, world, objectManagementSystem) {
-  if (!snapshot || !snapshot.entities.length) {
-    return {
-      restoredCount: 0,
-      selectedEntityId: null
-    };
-  }
-  const entityTypeValues = readByComponent(snapshot.components, "EntityType");
-  const componentValues = buildComponentValueMaps(snapshot);
-  const primaryCameraSourceEntityId = resolvePrimaryCameraSourceEntityId(
-    snapshot,
-    componentValues,
-    entityTypeValues
-  );
+    return true;
+  });
   const idMap = /* @__PURE__ */ new Map();
-  for (const sourceEntityId of snapshot.entities) {
-    const entityTypeValue = entityTypeValues.get(sourceEntityId);
-    const entityType = readString(entityTypeValue);
-    if (!entityType || !HYDRATABLE_ENTITY_KINDS.has(entityType)) {
-      continue;
-    }
-    const kind = entityType;
-    const payload = buildEntityCreationPayload(sourceEntityId, kind, componentValues);
-    if (kind === "camera" && sourceEntityId === primaryCameraSourceEntityId) {
-      payload.useWorldCamera = true;
-      const options = asRecord(payload.options);
-      payload.options = {
-        ...options ?? {},
-        isDefault: true
-      };
-    }
-    const createdEntityId = objectManagementSystem.createNow(kind, world, payload);
-    idMap.set(sourceEntityId, createdEntityId);
+  orderedIds.forEach((liveId, index) => {
+    idMap.set(liveId, index + 1);
+  });
+  const { snapshot, warnings } = remapSnapshotEntityIds(
+    { entities: orderedIds.slice(), components },
+    idMap,
+    { externalRefPolicy: "null" }
+  );
+  const rootFileId = 1;
+  const parentBlock = snapshot.components.find(
+    (block) => block.component === "ParentId"
+  );
+  const rootParentEntry = parentBlock?.entries.find(
+    (entry) => entry.entityId === rootFileId
+  );
+  if (rootParentEntry && rootParentEntry.value !== null && typeof rootParentEntry.value === "object") {
+    rootParentEntry.value.value = null;
   }
-  for (const sourceEntityId of snapshot.entities) {
-    const targetEntityId = idMap.get(sourceEntityId);
-    if (targetEntityId === void 0) {
-      continue;
-    }
-    const entityType = readString(entityTypeValues.get(sourceEntityId));
-    restoreComponentState(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceEntityId,
-      entityType,
-      componentValues
-    );
-    restorePostCreateComponents(
-      world,
-      objectManagementSystem,
-      targetEntityId,
-      sourceEntityId,
-      entityType,
-      componentValues,
-      idMap
+  const prefabInstanceBlock = snapshot.components.find(
+    (block) => block.component === "PrefabInstance"
+  );
+  if (prefabInstanceBlock) {
+    prefabInstanceBlock.entries = prefabInstanceBlock.entries.filter(
+      (entry) => entry.entityId !== rootFileId
     );
+    if (prefabInstanceBlock.entries.length === 0) {
+      snapshot.components = snapshot.components.filter(
+        (block) => block !== prefabInstanceBlock
+      );
+    }
   }
-  applyParentLinks(snapshot, idMap, objectManagementSystem, world);
-  objectManagementSystem.reconcileSceneFromWorld(world);
-  applyLocalTransformsAfterHierarchyRestore(world);
-  const selectedEntityId = typeof snapshot.selectedEntityId === "number" ? idMap.get(snapshot.selectedEntityId) ?? null : null;
-  return {
-    restoredCount: idMap.size,
-    selectedEntityId
-  };
-}
-__name(hydrateWorldFromSnapshotDetailed, "hydrateWorldFromSnapshotDetailed");
-function hydrateWorldFromSnapshot(snapshot, world, objectManagementSystem) {
-  return hydrateWorldFromSnapshotDetailed(
-    snapshot,
-    world,
-    objectManagementSystem
-  ).restoredCount;
+  const filteredWarnings = warnings.filter(
+    (warning) => !(warning.component === "ParentId" && warning.entityId === rootId)
+  );
+  return { snapshot, warnings: filteredWarnings, strippedComponents };
 }
-__name(hydrateWorldFromSnapshot, "hydrateWorldFromSnapshot");
+__name(serializeEntitySubtree, "serializeEntitySubtree");
 
-export { HYDRATABLE_ENTITY_KINDS, World, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed };
+export { World, applyPrefabToSnapshotInstances, collectDirectPrefabDependencies, remapSnapshotEntityIds, serializeEntitySubtree };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map