@relu-interactives/spatial-ecs 0.2.20 → 0.2.21

package/dist/index.cjs

@@ -3550,11 +3550,19 @@ __export(components_exports, {
 });
 
 // core/components/PrefabInstance.ts
+var generateInstanceId = /* @__PURE__ */ __name(() => {
+  try {
+    return crypto.randomUUID();
+  } catch {
+    return `i-${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+  }
+}, "generateInstanceId");
 var _PrefabInstance = class _PrefabInstance extends Component {
-  constructor(url, overrides = []) {
+  constructor(url, overrides = [], instanceId) {
     super();
     this.url = url;
     this.overrides = overrides;
+    this.instanceId = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : generateInstanceId();
   }
 };
 __name(_PrefabInstance, "PrefabInstance");
@@ -4767,7 +4775,13 @@ function restoreComponentState(world, objectManagementSystem, targetEntityId, so
       ) : [];
       world.addComponent(
         targetEntityId,
-        new PrefabInstance(sourcePrefabInstance.url, overrides)
+        new PrefabInstance(
+          sourcePrefabInstance.url,
+          overrides,
+          // Preserve the placement identity; the constructor generates a
+          // fresh one for legacy snapshots that predate instanceId.
+          typeof sourcePrefabInstance.instanceId === "string" && sourcePrefabInstance.instanceId.length > 0 ? sourcePrefabInstance.instanceId : void 0
+        )
       );
     }
   }
@@ -5014,6 +5028,148 @@ function hydrateWorldFromSnapshot(snapshot, world, objectManagementSystem) {
 }
 __name(hydrateWorldFromSnapshot, "hydrateWorldFromSnapshot");
 
+// core/prefab/nodeKeys.ts
+var NODE_KEY_SEPARATOR = "/";
+var ADDED_NODE_MARKER_COMPONENT = "+node";
+var asRecord4 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var readBlock = /* @__PURE__ */ __name((snapshot, component) => {
+  const map = /* @__PURE__ */ new Map();
+  const block = snapshot.components.find((b) => b.component === component);
+  for (const entry of block?.entries ?? []) {
+    const record = asRecord4(entry.value);
+    if (record) {
+      map.set(entry.entityId, record);
+    }
+  }
+  return map;
+}, "readBlock");
+var fallbackInstanceId = /* @__PURE__ */ __name((entityId) => `e${entityId}`, "fallbackInstanceId");
+function buildNodeKeyMapsFromSnapshot(snapshot, options) {
+  const parentValues = readBlock(snapshot, "ParentId");
+  const nodeValues = readBlock(snapshot, "PrefabNode");
+  const instanceValues = readBlock(snapshot, "PrefabInstance");
+  const inDocument = new Set(snapshot.entities);
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const rootIds = [];
+  for (const entityId of snapshot.entities) {
+    const parent = parentValues.get(entityId)?.value;
+    if (typeof parent === "number" && inDocument.has(parent)) {
+      const siblings = childrenByParent.get(parent);
+      if (siblings) siblings.push(entityId);
+      else childrenByParent.set(parent, [entityId]);
+    } else {
+      rootIds.push(entityId);
+    }
+  }
+  const scopeRoots = options?.scopeRootEntityId !== void 0 ? [options.scopeRootEntityId] : rootIds;
+  const idToKey = /* @__PURE__ */ new Map();
+  const keyToId = /* @__PURE__ */ new Map();
+  const boundaryIds = /* @__PURE__ */ new Map();
+  const scopeRootSet = new Set(scopeRoots);
+  const queue = scopeRoots.map(
+    (entityId) => ({ entityId, prefix: "" })
+  );
+  while (queue.length > 0) {
+    const { entityId, prefix } = queue.shift();
+    const instance = instanceValues.get(entityId);
+    const isBoundary = Boolean(
+      instance && typeof instance.url === "string" && !scopeRootSet.has(entityId)
+    );
+    let ownPrefix = prefix;
+    let childPrefix = prefix;
+    if (isBoundary && instance) {
+      const instanceId = typeof instance.instanceId === "string" && instance.instanceId.length > 0 ? instance.instanceId : fallbackInstanceId(entityId);
+      childPrefix = `${prefix}${instanceId}${NODE_KEY_SEPARATOR}`;
+      ownPrefix = childPrefix;
+      boundaryIds.set(entityId, {
+        url: instance.url,
+        instanceId
+      });
+    }
+    const nodeId = nodeValues.get(entityId)?.nodeId;
+    if (typeof nodeId === "string" && nodeId.length > 0) {
+      const key = `${ownPrefix}${nodeId}`;
+      idToKey.set(entityId, key);
+      keyToId.set(key, entityId);
+    }
+    for (const child of childrenByParent.get(entityId) ?? []) {
+      queue.push({ entityId: child, prefix: childPrefix });
+    }
+  }
+  const rootEntityId = scopeRoots[0];
+  const rootNodeId = rootEntityId !== void 0 ? nodeValues.get(rootEntityId)?.nodeId : void 0;
+  return {
+    idToKey,
+    keyToId,
+    rootKey: typeof rootNodeId === "string" && rootNodeId.length > 0 ? rootNodeId : null,
+    boundaryIds
+  };
+}
+__name(buildNodeKeyMapsFromSnapshot, "buildNodeKeyMapsFromSnapshot");
+function collectSnapshotSubtreeIds(snapshot, rootEntityId) {
+  const parentValues = readBlock(snapshot, "ParentId");
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const entityId of snapshot.entities) {
+    const parent = parentValues.get(entityId)?.value;
+    if (typeof parent === "number") {
+      const siblings = childrenByParent.get(parent);
+      if (siblings) siblings.push(entityId);
+      else childrenByParent.set(parent, [entityId]);
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [rootEntityId];
+  while (queue.length > 0) {
+    const entityId = queue.shift();
+    if (seen.has(entityId)) continue;
+    seen.add(entityId);
+    ordered.push(entityId);
+    queue.push(...childrenByParent.get(entityId) ?? []);
+  }
+  return ordered;
+}
+__name(collectSnapshotSubtreeIds, "collectSnapshotSubtreeIds");
+function findTopLevelNestedRegions(snapshot) {
+  const parentValues = readBlock(snapshot, "ParentId");
+  const instanceValues = readBlock(snapshot, "PrefabInstance");
+  const inDocument = new Set(snapshot.entities);
+  const roots = new Set(
+    snapshot.entities.filter((entityId) => {
+      const parent = parentValues.get(entityId)?.value;
+      return typeof parent !== "number" || !inDocument.has(parent);
+    })
+  );
+  const regions = [];
+  for (const [entityId, instance] of instanceValues) {
+    if (roots.has(entityId)) continue;
+    if (typeof instance.url !== "string" || instance.url.length === 0) continue;
+    let ancestor = parentValues.get(entityId)?.value;
+    let nestedDeeper = false;
+    let hops = 0;
+    while (typeof ancestor === "number" && hops < 512) {
+      if (instanceValues.has(ancestor) && !roots.has(ancestor)) {
+        nestedDeeper = true;
+        break;
+      }
+      ancestor = parentValues.get(ancestor)?.value;
+      hops += 1;
+    }
+    if (nestedDeeper) continue;
+    regions.push({
+      rootEntityId: entityId,
+      url: instance.url,
+      instanceId: typeof instance.instanceId === "string" && instance.instanceId.length > 0 ? instance.instanceId : fallbackInstanceId(entityId),
+      overrides: Array.isArray(instance.overrides) ? instance.overrides.filter(
+        (entry) => typeof entry === "string"
+      ) : []
+    });
+  }
+  regions.sort((a, b) => a.rootEntityId - b.rootEntityId);
+  return regions;
+}
+__name(findTopLevelNestedRegions, "findTopLevelNestedRegions");
+
 // core/prefab/overrides.ts
 var OVERRIDE_DIFF_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
   "PrefabNode",
@@ -5027,10 +5183,10 @@ var OVERRIDE_ROOT_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
   "Name",
   "ParentId"
 ]);
-var asRecord4 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var asRecord5 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
 var clone = /* @__PURE__ */ __name((value) => value === void 0 ? value : structuredClone(value), "clone");
 var isNodeRef = /* @__PURE__ */ __name((value) => {
-  const record = asRecord4(value);
+  const record = asRecord5(value);
   return Boolean(
     record && typeof record.$node === "string" && Object.keys(record).length === 1
   );
@@ -5042,7 +5198,7 @@ function findSnapshotRootEntityIds(snapshot) {
   );
   const parentByEntity = /* @__PURE__ */ new Map();
   for (const entry of parentBlock?.entries ?? []) {
-    parentByEntity.set(entry.entityId, asRecord4(entry.value)?.value ?? null);
+    parentByEntity.set(entry.entityId, asRecord5(entry.value)?.value ?? null);
   }
   return snapshot.entities.filter(
     (entityId) => typeof parentByEntity.get(entityId) !== "number"
@@ -5056,7 +5212,7 @@ function buildNodeMapsFromSnapshot(snapshot) {
     (block) => block.component === "PrefabNode"
   );
   for (const entry of nodeBlock?.entries ?? []) {
-    const nodeId = asRecord4(entry.value)?.nodeId;
+    const nodeId = asRecord5(entry.value)?.nodeId;
     if (typeof nodeId === "string" && nodeId.length > 0) {
       idToNode.set(entry.entityId, nodeId);
       nodeToId.set(nodeId, entry.entityId);
@@ -5088,7 +5244,7 @@ var toRefOrRaw = /* @__PURE__ */ __name((id, idToNode) => {
 }, "toRefOrRaw");
 function canonicalizeComponentValue(componentName, value, idToNode) {
   const cloned = clone(value);
-  const record = asRecord4(cloned);
+  const record = asRecord5(cloned);
   if (!record) {
     return cloned;
   }
@@ -5107,14 +5263,14 @@ function canonicalizeComponentValue(componentName, value, idToNode) {
     const entries = Array.isArray(record.entries) ? record.entries : [];
     return {
       entries: entries.map((rawEntry) => {
-        const entry = asRecord4(rawEntry);
+        const entry = asRecord5(rawEntry);
         if (!entry) {
           return rawEntry;
         }
-        const data = asRecord4(entry.data) ?? {};
+        const data = asRecord5(entry.data) ?? {};
         const canonicalData = {};
         for (const [key, fieldValue] of Object.entries(data)) {
-          const field = asRecord4(fieldValue);
+          const field = asRecord5(fieldValue);
           if (field?.type === "entity" && typeof field.value === "number") {
             canonicalData[key] = {
               ...field,
@@ -5122,7 +5278,7 @@ function canonicalizeComponentValue(componentName, value, idToNode) {
             };
             continue;
           }
-          const componentRef = asRecord4(field?.value);
+          const componentRef = asRecord5(field?.value);
           if (field?.type === "component" && componentRef && typeof componentRef.entityId === "number") {
             canonicalData[key] = {
               ...field,
@@ -5168,7 +5324,7 @@ function decanonicalizeComponentValue(value, nodeToId) {
   if (Array.isArray(value)) {
     return value.map((item) => decanonicalizeComponentValue(item, nodeToId));
   }
-  const record = asRecord4(value);
+  const record = asRecord5(value);
   if (record) {
     const result = {};
     for (const [key, item] of Object.entries(record)) {
@@ -5271,15 +5427,20 @@ function collectDiffPaths(base, current, prefix = "", out = []) {
   return out;
 }
 __name(collectDiffPaths, "collectDiffPaths");
-function computeInstanceOverrides(baseSnapshot, instanceSnapshot) {
-  const baseMaps = buildNodeMapsFromSnapshot(baseSnapshot);
-  const instanceMaps = buildNodeMapsFromSnapshot(instanceSnapshot);
+function computeInstanceOverrides(baseSnapshot, instanceSnapshot, options) {
+  const baseMaps = buildNodeKeyMapsFromSnapshot(baseSnapshot);
+  const instanceMaps = buildNodeKeyMapsFromSnapshot(instanceSnapshot);
   const baseByEntity = indexSnapshotByEntity(baseSnapshot);
   const instanceByEntity = indexSnapshotByEntity(instanceSnapshot);
   const overrides = [];
-  for (const [nodeId, instanceEntityId] of instanceMaps.nodeToId) {
-    const baseEntityId = baseMaps.nodeToId.get(nodeId);
+  for (const [nodeKey, instanceEntityId] of instanceMaps.keyToId) {
+    const baseEntityId = baseMaps.keyToId.get(nodeKey);
     if (baseEntityId === void 0) {
+      if (options?.emitAdditionMarkers) {
+        overrides.push(
+          encodeOverride(nodeKey, ADDED_NODE_MARKER_COMPONENT, "")
+        );
+      }
       continue;
     }
     const baseComponents = baseByEntity.get(baseEntityId);
@@ -5287,7 +5448,7 @@ function computeInstanceOverrides(baseSnapshot, instanceSnapshot) {
     if (!baseComponents) {
       continue;
     }
-    const isRoot = nodeId === baseMaps.rootNodeId;
+    const isRoot = nodeKey === baseMaps.rootKey;
     for (const [componentName, baseRaw] of baseComponents) {
       if (OVERRIDE_DIFF_EXCLUDED_COMPONENTS.has(componentName)) {
         continue;
@@ -5302,15 +5463,15 @@ function computeInstanceOverrides(baseSnapshot, instanceSnapshot) {
       const baseCanonical = canonicalizeComponentValue(
         componentName,
         baseRaw,
-        baseMaps.idToNode
+        baseMaps.idToKey
       );
       const instanceCanonical = canonicalizeComponentValue(
         componentName,
         instanceRaw,
-        instanceMaps.idToNode
+        instanceMaps.idToKey
       );
       for (const path of collectDiffPaths(baseCanonical, instanceCanonical)) {
-        overrides.push(encodeOverride(nodeId, componentName, path));
+        overrides.push(encodeOverride(nodeKey, componentName, path));
       }
     }
   }
@@ -5324,7 +5485,7 @@ function getAtPath(value, tokens) {
     if (Array.isArray(cursor)) {
       cursor = cursor[Number(token)];
     } else {
-      const record = asRecord4(cursor);
+      const record = asRecord5(cursor);
       if (!record) {
         return void 0;
       }
@@ -5344,7 +5505,7 @@ function setAtPath(target, tokens, value) {
     if (Array.isArray(cursor)) {
       cursor = cursor[Number(token)];
     } else {
-      const record = asRecord4(cursor);
+      const record = asRecord5(cursor);
       if (!record) {
         return;
       }
@@ -5358,7 +5519,7 @@ function setAtPath(target, tokens, value) {
   if (Array.isArray(cursor)) {
     cursor[Number(last)] = value;
   } else {
-    const record = asRecord4(cursor);
+    const record = asRecord5(cursor);
     if (record) {
       if (value === void 0) {
         delete record[last];
@@ -5390,15 +5551,20 @@ __name(mergeComponentValue, "mergeComponentValue");
 var INSTANTIATE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
   "Environment",
   "Postprocessing",
-  "SelectionTransformState",
-  "PrefabInstance"
+  "SelectionTransformState"
 ]);
 function instantiateSubtree(world, objectManagementSystem, snapshot) {
+  const snapshotRootIds = new Set(findSnapshotRootEntityIds(snapshot));
   const safeSnapshot = {
     entities: snapshot.entities,
-    components: snapshot.components.filter(
-      (block) => !INSTANTIATE_EXCLUDED_COMPONENTS.has(block.component)
-    )
+    components: snapshot.components.filter((block) => !INSTANTIATE_EXCLUDED_COMPONENTS.has(block.component)).map(
+      (block) => block.component === "PrefabInstance" ? {
+        component: block.component,
+        entries: block.entries.filter(
+          (entry) => !snapshotRootIds.has(entry.entityId)
+        )
+      } : block
+    ).filter((block) => block.entries.length > 0)
   };
   const result = hydrateWorldFromSnapshotDetailed(
     safeSnapshot,
@@ -5418,6 +5584,11 @@ __name(instantiateSubtree, "instantiateSubtree");
 
 // core/prefab/types.ts
 var PREFAB_FILE_VERSION = 1;
+var PREFAB_FILE_VERSION_NESTED = 2;
+function prefabFileVersionFor(snapshot) {
+  return findTopLevelNestedRegions(snapshot).length > 0 ? PREFAB_FILE_VERSION_NESTED : PREFAB_FILE_VERSION;
+}
+__name(prefabFileVersionFor, "prefabFileVersionFor");
 var isRecord = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "isRecord");
 function parsePrefabAsset(json) {
   if (!isRecord(json)) {
@@ -8360,10 +8531,10 @@ var _Behaviour = class _Behaviour {
     if (!this.threeRef) {
       return;
     }
-    const clone2 = this.threeRef.object.clone();
+    const clone3 = this.threeRef.object.clone();
     const rotation = new THREE35__namespace.Quaternion();
-    clone2.lookAt(targetPosition);
-    clone2.getWorldQuaternion(rotation);
+    clone3.lookAt(targetPosition);
+    clone3.getWorldQuaternion(rotation);
     this.transform.setRotation(rotation);
   }
   /** Returns every component currently attached to this entity. */
@@ -10170,11 +10341,11 @@ __name(_World, "World");
 var World = _World;
 
 // core/prefab/snapshotIdUtils.ts
-var asRecord5 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var asRecord6 = /* @__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 = asRecord5(value);
+    const record = asRecord6(value);
     if (!record) {
       result[key] = value;
       continue;
@@ -10189,7 +10360,7 @@ function remapScriptData(data, idMap, nullExternal, onExternal) {
       }
       continue;
     }
-    const componentRef = asRecord5(record.value);
+    const componentRef = asRecord6(record.value);
     if (record.type === "component" && componentRef && typeof componentRef.entityId === "number") {
       const mapped = idMap.get(componentRef.entityId);
       if (mapped !== void 0) {
@@ -10227,7 +10398,7 @@ function remapSnapshotEntityIds(snapshot, idMap, options) {
         });
       }, "warn");
       let value = structuredClone(entry.value);
-      const record = asRecord5(value);
+      const record = asRecord6(value);
       if (block.component === "ParentId" && record) {
         if (typeof record.value === "number") {
           const mapped = idMap.get(record.value);
@@ -10243,11 +10414,11 @@ function remapSnapshotEntityIds(snapshot, idMap, options) {
       } else if (block.component === "ScriptComponent" && record) {
         if (Array.isArray(record.entries)) {
           record.entries = record.entries.map((rawEntry, index) => {
-            const entryRecord = asRecord5(rawEntry);
+            const entryRecord = asRecord6(rawEntry);
             if (!entryRecord) {
               return rawEntry;
             }
-            const data = asRecord5(entryRecord.data);
+            const data = asRecord6(entryRecord.data);
             if (!data) {
               return rawEntry;
             }
@@ -10303,12 +10474,237 @@ function remapSnapshotEntityIds(snapshot, idMap, options) {
 }
 __name(remapSnapshotEntityIds, "remapSnapshotEntityIds");
 
+// core/prefab/applyPrefabToSnapshot.ts
+var asRecord7 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null, "asRecord");
+var clone2 = /* @__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(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);
+  }
+}
+__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(deleteEntities, "deleteEntities");
+function extractRegionDoc(hostSnapshot, regionIds) {
+  const idSet = new Set(regionIds);
+  return {
+    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(extractRegionDoc, "extractRegionDoc");
+function applyPrefabToSnapshotInstances(hostSnapshot, nestedUrl, newNestedSnapshot) {
+  const host = clone2(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))
+    );
+    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(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);
+      }
+    }
+    for (const fileId of addedFileIds) {
+      idMap.set(fileId, nextHostId);
+      nextHostId += 1;
+    }
+    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);
+      }
+    }
+    for (const fileId of addedFileIds) {
+      const hostId = idMap.get(fileId);
+      const parentValue = asRecord7(
+        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 key = newMaps.idToKey.get(fileId);
+      if (key) {
+        keyToHostId.set(key, hostId);
+      }
+    }
+  }
+  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
+      );
+      const regionRaw = regionEntityComponents?.get(componentName);
+      const regionCanonical = regionRaw === void 0 ? void 0 : canonicalizeComponentValue(
+        componentName,
+        regionRaw,
+        regionMaps.idToKey
+      );
+      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 removedHostIds = /* @__PURE__ */ new Set();
+  for (const [key, hostId] of keyToHostId) {
+    if (newMaps.keyToId.has(key)) continue;
+    if (isMarkedAddition(key)) continue;
+    removedHostIds.add(hostId);
+  }
+  if (removedHostIds.size > 0) {
+    const regionIdSet = new Set(regionIds);
+    const parentBlockHost = host.components.find(
+      (b) => b.component === "ParentId"
+    );
+    for (const entry of parentBlockHost?.entries ?? []) {
+      const record = asRecord7(entry.value);
+      if (!removedHostIds.has(entry.entityId) && regionIdSet.has(entry.entityId) && record && typeof record.value === "number" && removedHostIds.has(record.value)) {
+        record.value = regionRootId;
+      }
+    }
+    deleteEntities(host, removedHostIds);
+  }
+  const refreshedRegionIds = collectSnapshotSubtreeIds(host, regionRootId);
+  const refreshedDoc = extractRegionDoc(host, refreshedRegionIds);
+  const refreshedOverrides = computeInstanceOverrides(
+    newSnapshot,
+    refreshedDoc,
+    { emitAdditionMarkers: true }
+  );
+  const instanceEntry = asRecord7(
+    host.components.find((b) => b.component === "PrefabInstance")?.entries.find((e) => e.entityId === regionRootId)?.value
+  );
+  if (instanceEntry) {
+    instanceEntry.overrides = refreshedOverrides;
+  }
+}
+__name(patchRegion, "patchRegion");
+
+// core/prefab/dependencies.ts
+function collectDirectPrefabDependencies(snapshot) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const region of findTopLevelNestedRegions(snapshot)) {
+    urls.add(region.url);
+  }
+  return [...urls];
+}
+__name(collectDirectPrefabDependencies, "collectDirectPrefabDependencies");
+
 // core/prefab/serializeEntitySubtree.ts
 var SUBTREE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
   "Environment",
   "Postprocessing",
-  "SelectionTransformState",
-  "PrefabInstance"
+  "SelectionTransformState"
 ]);
 function serializeEntitySubtree(world, rootId, options) {
   const orderedIds = collectEntitySubtree(world, [rootId]);
@@ -10340,6 +10736,19 @@ function serializeEntitySubtree(world, rootId, options) {
   if (rootParentEntry && rootParentEntry.value !== null && typeof rootParentEntry.value === "object") {
     rootParentEntry.value.value = null;
   }
+  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
+      );
+    }
+  }
   const filteredWarnings = warnings.filter(
     (warning) => !(warning.component === "ParentId" && warning.entityId === rootId)
   );
@@ -10347,6 +10756,7 @@ function serializeEntitySubtree(world, rootId, options) {
 }
 __name(serializeEntitySubtree, "serializeEntitySubtree");
 
+exports.ADDED_NODE_MARKER_COMPONENT = ADDED_NODE_MARKER_COMPONENT;
 exports.AnimationStateMachine = AnimationStateMachine;
 exports.AnimationStateManager = AnimationStateManager;
 exports.AnimationSystem = AnimationSystem;
@@ -10363,11 +10773,13 @@ exports.KeyboardKeys = KeyboardKeys;
 exports.LightSyncSystem = LightSyncSystem;
 exports.MaterialSyncSystem = MaterialSyncSystem;
 exports.MeshGeometrySystem = MeshGeometrySystem;
+exports.NODE_KEY_SEPARATOR = NODE_KEY_SEPARATOR;
 exports.OVERRIDE_DIFF_EXCLUDED_COMPONENTS = OVERRIDE_DIFF_EXCLUDED_COMPONENTS;
 exports.OVERRIDE_ROOT_EXCLUDED_COMPONENTS = OVERRIDE_ROOT_EXCLUDED_COMPONENTS;
 exports.ObjectManagementSystem = ObjectManagementSystem;
 exports.ObjectVisibilitySystem = ObjectVisibilitySystem;
 exports.PREFAB_FILE_VERSION = PREFAB_FILE_VERSION;
+exports.PREFAB_FILE_VERSION_NESTED = PREFAB_FILE_VERSION_NESTED;
 exports.PhysicsSyncSystem = PhysicsSyncSystem;
 exports.PostprocessingSyncSystem = PostprocessingSyncSystem;
 exports.RenderSystem = RenderSystem;
@@ -10376,13 +10788,17 @@ exports.ScriptBehaviourSystem = ScriptBehaviourSystem;
 exports.TransformSyncSystem = TransformSyncSystem;
 exports.VideoSystem = VideoSystem;
 exports.World = World;
+exports.applyPrefabToSnapshotInstances = applyPrefabToSnapshotInstances;
 exports.buildComponentValueMaps = buildComponentValueMaps;
+exports.buildNodeKeyMapsFromSnapshot = buildNodeKeyMapsFromSnapshot;
 exports.buildNodeMapsFromSnapshot = buildNodeMapsFromSnapshot;
 exports.canonicalizeComponentValue = canonicalizeComponentValue;
 exports.clearModelCache = clearModelCache;
 exports.clearPrefabCache = clearPrefabCache;
 exports.collectDiffPaths = collectDiffPaths;
+exports.collectDirectPrefabDependencies = collectDirectPrefabDependencies;
 exports.collectEntitySubtree = collectEntitySubtree;
+exports.collectSnapshotSubtreeIds = collectSnapshotSubtreeIds;
 exports.computeInstanceOverrides = computeInstanceOverrides;
 exports.createAnimationComponent = createAnimationComponent;
 exports.createAudioComponent = createAudioComponent;
@@ -10414,6 +10830,7 @@ exports.decanonicalizeComponentValue = decanonicalizeComponentValue;
 exports.despawnPrefab = despawnPrefab;
 exports.encodeOverride = encodeOverride;
 exports.findSnapshotRootEntityIds = findSnapshotRootEntityIds;
+exports.findTopLevelNestedRegions = findTopLevelNestedRegions;
 exports.groupOverridePaths = groupOverridePaths;
 exports.hydrateWorldFromSnapshot = hydrateWorldFromSnapshot;
 exports.hydrateWorldFromSnapshotDetailed = hydrateWorldFromSnapshotDetailed;
@@ -10424,6 +10841,7 @@ exports.loadSharedGltf = loadSharedGltf;
 exports.mergeComponentValue = mergeComponentValue;
 exports.parseOverride = parseOverride;
 exports.parsePrefabAsset = parsePrefabAsset;
+exports.prefabFileVersionFor = prefabFileVersionFor;
 exports.registerDefaultComponentFactories = registerDefaultComponentFactories;
 exports.registerDefaultFactories = registerDefaultFactories;
 exports.remapSnapshotEntityIds = remapSnapshotEntityIds;