@forgeax/engine-runtime 0.1.28 → 0.1.29

package/dist/index.mjs

@@ -359,10 +359,6 @@ function foldMountOverrides(world, state) {
   );
   if (!sourceRes.ok) return [];
   const source = sourceRes.value;
-  const sourceByLid = /* @__PURE__ */ new Map();
-  for (const node of source.entities) {
-    sourceByLid.set(node.localId, node);
-  }
   const excluded = excludedComponentNames();
   const registered = world.components.entries();
   const overrides = [];
@@ -372,7 +368,8 @@ function foldMountOverrides(world, state) {
   }
   members.sort((a, b) => a[1] - b[1]);
   for (const [entity, lid] of members) {
-    const sourceNode = sourceByLid.get(lid);
+    const sourceKey = state.keyByLocalId.get(lid);
+    const sourceNode = sourceKey === void 0 ? void 0 : source.entities[sourceKey];
     const sourceComps = sourceNode?.components ?? {};
     for (const [compName, compToken] of registered) {
       if (excluded.has(compName)) continue;
@@ -481,6 +478,436 @@ function _serializeOverrideValueHandles(world, registry, ov) {
   }
   return ok$1(out);
 }
+function isSceneEntityAddress(value) {
+  return typeof value === "string" || value.length > 0;
+}
+function collectKeyedSceneAsset(world, registry, _roots, visited, ownedEntities, legacyEntities, mounts, anchors, memberOrigin) {
+  const sceneInstanceToken = world.components.resolve("SceneInstance");
+  const childOfToken = world.components.resolve("ChildOf");
+  const stateInfos = [];
+  if (sceneInstanceToken !== void 0) {
+    const queryResult = world.query({ read: [SceneInstance] });
+    if (queryResult.ok) {
+      for (const row of queryResult.value) {
+        const stateResult = worldGetSceneInstanceState(world, row.entity);
+        if (!stateResult.ok) continue;
+        const rowValue = row.get(SceneInstance);
+        stateInfos.push({
+          root: row.entity,
+          state: stateResult.value,
+          mapping: Uint32Array.from(rowValue.mapping)
+        });
+      }
+    }
+  }
+  const stateByRoot = /* @__PURE__ */ new Map();
+  for (const info of stateInfos) stateByRoot.set(info.root, info);
+  const parentByChildRoot = /* @__PURE__ */ new Map();
+  const relationCandidates = [];
+  for (const child of stateInfos) {
+    if (child.state.instanceKey === void 0 || childOfToken === void 0) continue;
+    const parentResult = world.get(
+      child.root,
+      childOfToken
+    );
+    if (!parentResult.ok) continue;
+    const carrier = parentResult.value.parent;
+    if (carrier === void 0) continue;
+    for (const parent of stateInfos) {
+      const bound = parent.state.bindings.get(child.state.instanceKey);
+      if (bound === carrier) {
+        parentByChildRoot.set(child.root, parent);
+        relationCandidates.push({ child, parent, key: child.state.instanceKey });
+        break;
+      }
+    }
+  }
+  const findSequence = (haystack, needle, start) => {
+    if (needle.length === 0) return start;
+    for (let index = Math.max(0, start); index + needle.length <= haystack.length; index += 1) {
+      let match = true;
+      for (let offset = 0; offset < needle.length; offset += 1) {
+        if (haystack[index + offset] !== needle[offset]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) return index;
+    }
+    return void 0;
+  };
+  const relations = [];
+  for (const candidate of relationCandidates) {
+    const slot = [...candidate.parent.state.keyByLocalId.entries()].find(
+      ([, value]) => value === candidate.key
+    )?.[0];
+    if (slot === void 0) continue;
+    const memberFirst = findSequence(candidate.parent.mapping, candidate.child.mapping, slot + 1);
+    if (memberFirst === void 0) continue;
+    relations.push({ ...candidate, memberFirst });
+  }
+  const relationsByParent = /* @__PURE__ */ new Map();
+  for (const relation of relations) {
+    const list = relationsByParent.get(relation.parent.root);
+    if (list === void 0) relationsByParent.set(relation.parent.root, [relation]);
+    else list.push(relation);
+  }
+  const statePrefixMemo = /* @__PURE__ */ new Map();
+  const statePrefix = (info, stack = /* @__PURE__ */ new Set()) => {
+    const prior = statePrefixMemo.get(info.root);
+    if (prior !== void 0) return prior;
+    if (stack.has(info.root)) return [];
+    if (info.state.instanceKey === void 0) {
+      statePrefixMemo.set(info.root, []);
+      return [];
+    }
+    const next = new Set(stack);
+    next.add(info.root);
+    const parent = parentByChildRoot.get(info.root);
+    const prefix = parent === void 0 ? [info.state.instanceKey] : [...statePrefix(parent, next), info.state.instanceKey];
+    statePrefixMemo.set(info.root, prefix);
+    return prefix;
+  };
+  const stateSlotAddress = (info, slot, prefix, stack = /* @__PURE__ */ new Set()) => {
+    if (slot < 0 || stack.has(info.root)) return void 0;
+    const key = info.state.keyByLocalId.get(slot);
+    if (key !== void 0) return [...prefix, key];
+    const next = new Set(stack);
+    next.add(info.root);
+    for (const relation of relationsByParent.get(info.root) ?? []) {
+      const end = relation.memberFirst + relation.child.mapping.length;
+      if (slot >= relation.memberFirst && slot < end) {
+        return stateSlotAddress(
+          relation.child,
+          slot - relation.memberFirst,
+          [...prefix, relation.key],
+          next
+        );
+      }
+    }
+    return void 0;
+  };
+  const rawToAddress = /* @__PURE__ */ new Map();
+  const orderedStates = [...stateInfos].sort(
+    (a, b) => statePrefix(a).length - statePrefix(b).length
+  );
+  for (const info of orderedStates) {
+    const prefix = statePrefix(info);
+    for (let slot = 0; slot < info.mapping.length; slot += 1) {
+      const raw = info.mapping[slot];
+      if (raw === void 0 || raw === 4294967295 || !visited.has(raw)) continue;
+      const address = stateSlotAddress(info, slot, prefix);
+      if (address !== void 0 && !rawToAddress.has(raw)) rawToAddress.set(raw, address);
+    }
+  }
+  for (const [raw, origin] of memberOrigin) {
+    if (!visited.has(raw) || rawToAddress.has(raw)) continue;
+    const child = stateByRoot.get(origin.anchorRaw);
+    if (child === void 0) continue;
+    const address = stateSlotAddress(child, origin.memberLocalId, statePrefix(child));
+    if (address !== void 0) rawToAddress.set(raw, address);
+  }
+  const generatedKeys = /* @__PURE__ */ new Set();
+  const keyForOwnedRaw = /* @__PURE__ */ new Map();
+  for (let index = 0; index < ownedEntities.length; index += 1) {
+    const raw = ownedEntities[index];
+    const known = rawToAddress.get(raw);
+    let key = known?.length === 1 ? known[0] : void 0;
+    if (key === void 0 || key.length === 0 || generatedKeys.has(key)) {
+      const base = `entity-${index}`;
+      key = base;
+      let suffix = 1;
+      while (generatedKeys.has(key)) key = `${base}-${suffix++}`;
+    }
+    generatedKeys.add(key);
+    keyForOwnedRaw.set(raw, key);
+    rawToAddress.set(raw, [key]);
+  }
+  const slotAddress = (slot) => {
+    if (slot >= 0 && slot < ownedEntities.length) {
+      const raw = ownedEntities[slot];
+      const key = raw === void 0 ? void 0 : keyForOwnedRaw.get(raw);
+      return key;
+    }
+    const mountIndex = mounts.findIndex((mount) => mount.localId === slot);
+    if (mountIndex >= 0) {
+      const anchor = anchors[mountIndex];
+      const child = anchor === void 0 ? void 0 : stateByRoot.get(anchor.entityRaw);
+      const key = child?.state.instanceKey;
+      if (key !== void 0) return key;
+    }
+    for (let index = 0; index < mounts.length; index += 1) {
+      const mount = mounts[index];
+      if (mount === void 0) continue;
+      const first = mount.memberFirst;
+      if (slot < first || slot >= first + mount.memberCount) continue;
+      const anchor = anchors[index];
+      const child = anchor === void 0 ? void 0 : stateByRoot.get(anchor.entityRaw);
+      const mountKey = child?.state.instanceKey;
+      if (child === void 0 || mountKey === void 0) return void 0;
+      const address = stateSlotAddress(child, slot - first, []);
+      if (address === void 0) return void 0;
+      return [mountKey, ...address];
+    }
+    const top = orderedStates.find((info) => statePrefix(info).length === 0);
+    if (top !== void 0) {
+      const address = stateSlotAddress(top, slot, []);
+      if (address !== void 0) {
+        return address.length === 1 ? address[0] : address;
+      }
+    }
+    return void 0;
+  };
+  const convertComponents = (entityRaw, source) => {
+    const out = {};
+    for (const [componentName, rawFields] of Object.entries(source)) {
+      const token = world.components.resolve(componentName);
+      if (token === void 0) {
+        out[componentName] = { ...rawFields };
+        continue;
+      }
+      const converted = {};
+      for (const [fieldName, value] of Object.entries(rawFields)) {
+        const kind = classifyEntityField(token, fieldName);
+        if (kind === null) {
+          converted[fieldName] = value;
+          continue;
+        }
+        const convertSlot = (localSlot) => {
+          if (typeof localSlot !== "number") return void 0;
+          return slotAddress(localSlot);
+        };
+        if (kind.isArray) {
+          if (!Array.isArray(value)) {
+            return err$1(
+              new SceneCollectEntityRefOutOfClosureError(
+                entityRaw,
+                `${componentName}.${fieldName}`,
+                -1
+              )
+            );
+          }
+          const addresses = [];
+          for (const item of value) {
+            const address = convertSlot(item);
+            if (address === void 0 || !isSceneEntityAddress(address)) {
+              return err$1(
+                new SceneCollectEntityRefOutOfClosureError(
+                  entityRaw,
+                  `${componentName}.${fieldName}`,
+                  Number(item)
+                )
+              );
+            }
+            addresses.push(address);
+          }
+          converted[fieldName] = addresses;
+        } else if (value === null) {
+          converted[fieldName] = null;
+        } else {
+          const address = convertSlot(value);
+          if (address === void 0 || !isSceneEntityAddress(address)) {
+            return err$1(
+              new SceneCollectEntityRefOutOfClosureError(
+                entityRaw,
+                `${componentName}.${fieldName}`,
+                Number(value)
+              )
+            );
+          }
+          converted[fieldName] = address;
+        }
+      }
+      out[componentName] = converted;
+    }
+    return ok$1(out);
+  };
+  const entities = {};
+  for (const legacy of legacyEntities) {
+    const raw = ownedEntities[legacy.localId];
+    if (raw === void 0) continue;
+    const key = keyForOwnedRaw.get(raw);
+    const converted = convertComponents(raw, legacy.components);
+    if (!converted.ok) return converted;
+    entities[key] = { components: converted.value };
+  }
+  const resolveOverrideTarget = (child, memberFirst, localId) => {
+    if (child === void 0) return void 0;
+    const target = stateSlotAddress(child, localId - memberFirst, []);
+    if (target === void 0 || target.length === 0) return void 0;
+    return target;
+  };
+  const convertOverrideValue = (entityRaw, componentName, fieldName, value) => {
+    const token = world.components.resolve(componentName);
+    if (token === void 0) return ok$1(value);
+    const schema = componentSchema(token);
+    const convertFields = (field, fieldValue) => {
+      const kind = classifyEntityField(token, field);
+      if (kind === null) {
+        const sharedType = schema[field];
+        const shared = sharedType?.startsWith("shared<") ? { scalar: true } : sharedType?.startsWith("array<shared<") ? { scalar: false } : void 0;
+        if (shared === void 0) return ok$1(fieldValue);
+        return _serializeSharedFieldValue(world, registry, shared, fieldValue, field);
+      }
+      const resolveLiveOrSlot = (item) => {
+        if (typeof item !== "number") return void 0;
+        const live = rawToAddress.get(item);
+        if (live !== void 0) {
+          return live.length === 1 ? live[0] : live;
+        }
+        return slotAddress(item);
+      };
+      if (kind.isArray) {
+        if (!Array.isArray(fieldValue)) return ok$1(fieldValue);
+        const mapped = [];
+        for (const item of fieldValue) {
+          const address2 = resolveLiveOrSlot(item);
+          if (address2 === void 0 || !isSceneEntityAddress(address2)) {
+            return err$1(
+              new SceneCollectEntityRefOutOfClosureError(
+                entityRaw,
+                `${componentName}.${field}`,
+                Number(item)
+              )
+            );
+          }
+          mapped.push(address2);
+        }
+        return ok$1(mapped);
+      }
+      if (fieldValue === null) return ok$1(null);
+      const address = resolveLiveOrSlot(fieldValue);
+      if (address === void 0 || !isSceneEntityAddress(address)) {
+        return err$1(
+          new SceneCollectEntityRefOutOfClosureError(
+            entityRaw,
+            `${componentName}.${field}`,
+            Number(fieldValue)
+          )
+        );
+      }
+      return ok$1(address);
+    };
+    if (fieldName !== void 0) return convertFields(fieldName, value);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return ok$1(value);
+    const result = {};
+    for (const [field, fieldValue] of Object.entries(value)) {
+      const converted = convertFields(field, fieldValue);
+      if (!converted.ok) return converted;
+      result[field] = converted.value;
+    }
+    return ok$1(result);
+  };
+  const declarationOverrides = (parent, child, mount, anchor) => {
+    const memberFirst = mount.memberFirst;
+    const candidates = [];
+    if (parent !== void 0) {
+      for (const override of parent.state.mountTimeOverrides) {
+        const localId = override.localId;
+        if (localId >= memberFirst && localId < memberFirst + mount.memberCount)
+          candidates.push(override);
+      }
+      for (const [localId, records] of parent.state.overrides) {
+        const numeric = localId;
+        if (numeric < memberFirst || numeric >= memberFirst + mount.memberCount) continue;
+        for (const record of records.values()) {
+          candidates.push({
+            localId,
+            comp: record.comp,
+            ...record.field === void 0 ? {} : { field: record.field },
+            value: record.value
+          });
+        }
+      }
+    }
+    if (candidates.length === 0) candidates.push(...mount.overrides ?? []);
+    if (candidates.length === 0 || child === void 0) return ok$1(void 0);
+    const byTarget = /* @__PURE__ */ new Map();
+    for (const override of candidates) {
+      const localId = override.localId;
+      const target = resolveOverrideTarget(child, memberFirst, localId);
+      if (target === void 0) {
+        return err$1(
+          new SceneCollectEntityRefOutOfClosureError(
+            anchor.entityRaw,
+            "instance.override.target",
+            localId
+          )
+        );
+      }
+      const converted = convertOverrideValue(
+        anchor.entityRaw,
+        override.comp,
+        override.field,
+        override.value
+      );
+      if (!converted.ok) return converted;
+      const targetKey = JSON.stringify(target);
+      const prior = byTarget.get(targetKey);
+      const components = {};
+      if (prior !== void 0) {
+        for (const [name, fields] of Object.entries(
+          prior.components
+        )) {
+          components[name] = { ...fields };
+        }
+      }
+      const priorFields = components[override.comp];
+      const existing = { ...priorFields ?? {} };
+      if (override.field === void 0 && typeof converted.value === "object" && converted.value !== null) {
+        Object.assign(existing, converted.value);
+      } else if (override.field !== void 0) {
+        existing[override.field] = converted.value;
+      }
+      components[override.comp] = existing;
+      byTarget.set(targetKey, { target, components });
+    }
+    return ok$1([...byTarget.values()]);
+  };
+  for (let index = 0; index < mounts.length; index += 1) {
+    const mount = mounts[index];
+    const anchor = anchors[index];
+    if (mount === void 0 || anchor === void 0) continue;
+    const child = stateByRoot.get(anchor.entityRaw);
+    const parent = child === void 0 ? void 0 : parentByChildRoot.get(child.root);
+    const instanceKey = child?.state.instanceKey ?? `instance-${index}`;
+    const carrierRaw = childOfToken === void 0 ? void 0 : (() => {
+      const parentResult = world.get(
+        anchor.entityRaw,
+        childOfToken
+      );
+      return parentResult.ok ? parentResult.value.parent : void 0;
+    })();
+    const converted = convertComponents(
+      carrierRaw ?? anchor.entityRaw,
+      mount.components ?? {}
+    );
+    if (!converted.ok) return converted;
+    if (mount.parent !== void 0) {
+      const parentAddress = slotAddress(mount.parent);
+      if (parentAddress === void 0) {
+        return err$1(
+          new SceneCollectEntityRefOutOfClosureError(
+            carrierRaw ?? anchor.entityRaw,
+            "ChildOf.parent",
+            mount.parent
+          )
+        );
+      }
+      converted.value.ChildOf = { parent: parentAddress };
+    }
+    const overrides = declarationOverrides(parent, child, mount, anchor);
+    if (!overrides.ok) return overrides;
+    entities[instanceKey] = {
+      components: converted.value,
+      instance: {
+        source: String(mount.source),
+        ...overrides.value === void 0 ? {} : { overrides: overrides.value }
+      }
+    };
+  }
+  return ok$1({ kind: "scene", entities });
+}
 function serializeSceneAssetToPack(sceneAsset, components, guid) {
   const externalized = externalizeSceneAsset(sceneAsset, (componentName) => {
     const component = components.get(componentName);
@@ -513,7 +940,7 @@ function rootsToSceneAsset(registry, world, roots) {
   const collectProfile = SCENE_COLLECT_PROFILE;
   const visited = /* @__PURE__ */ new Set();
   for (const root of roots) collectSubtree(world, root, visited);
-  if (visited.size === 0) return ok$1({ kind: "scene", entities: [] });
+  if (visited.size === 0) return ok$1({ kind: "scene", entities: {} });
   const rootRawSet = /* @__PURE__ */ new Set();
   for (const r of roots) rootRawSet.add(r);
   const anchorEntities = /* @__PURE__ */ new Set();
@@ -527,13 +954,41 @@ function rootsToSceneAsset(registry, world, roots) {
     if (rootRawSet.has(er)) continue;
     const sr = worldGetSceneInstanceState(world, er);
     if (!sr.ok) continue;
-    for (const [me, lid] of sr.value.entityToLocalId) {
+    const retainedState = sr.value;
+    for (const [me, lid] of retainedState.entityToLocalId) {
       const mr = me;
       if (visited.has(mr) && !anchorEntities.has(mr) && !memberEntities.has(mr)) {
         memberEntities.add(mr);
         memberOrigin.set(mr, { anchorRaw: er, memberLocalId: lid });
       }
     }
+    for (const [key, member] of retainedState.bindings) {
+      const mr = member;
+      const localId = [...retainedState.keyByLocalId.entries()].find(
+        ([, value]) => value === key
+      )?.[0];
+      if (localId !== void 0 && visited.has(mr) && !anchorEntities.has(mr) && !memberEntities.has(mr)) {
+        memberEntities.add(mr);
+        memberOrigin.set(mr, { anchorRaw: er, memberLocalId: localId });
+      }
+    }
+  }
+  const childOfForAnchor = world.components.resolve("ChildOf");
+  if (childOfForAnchor !== void 0) {
+    for (const anchorRaw of [...anchorEntities]) {
+      if (rootRawSet.has(anchorRaw) || memberEntities.has(anchorRaw)) continue;
+      const parentRes = world.get(
+        anchorRaw,
+        childOfForAnchor
+      );
+      if (!parentRes.ok) continue;
+      const carrierRaw = parentRes.value.parent;
+      const origin = carrierRaw === void 0 ? void 0 : memberOrigin.get(carrierRaw);
+      if (origin !== void 0) {
+        memberEntities.add(anchorRaw);
+        memberOrigin.set(anchorRaw, origin);
+      }
+    }
   }
   for (const er of anchorEntities) {
     if (memberEntities.has(er) && !rootRawSet.has(er)) anchorEntities.delete(er);
@@ -588,7 +1043,8 @@ function rootsToSceneAsset(registry, world, roots) {
   const ownedEntities = [];
   for (const er of orderedEntities) {
     if (carrierToAnchor.has(er)) continue;
-    if ((!anchorEntities.has(er) || rootRawSet.has(er)) && !memberEntities.has(er)) {
+    if (rootRawSet.has(er) && anchorEntities.has(er)) continue;
+    if (!anchorEntities.has(er) && !memberEntities.has(er)) {
       ownedEntities.push(er);
     }
   }
@@ -727,7 +1183,7 @@ function rootsToSceneAsset(registry, world, roots) {
     return void 0;
   }
   const registeredComps = world.components.entries();
-  const entities = [];
+  const legacyEntities = [];
   for (let lid = 0; lid < ownedEntities.length; lid++) {
     const entityRaw = ownedEntities[lid];
     if (entityRaw === void 0) continue;
@@ -774,6 +1230,9 @@ function rootsToSceneAsset(registry, world, roots) {
           continue;
         }
         if (entityKind !== null) {
+          if (!entityKind.isArray && typeof rawValue === "number" && rootRawSet.has(rawValue) && anchorEntities.has(rawValue)) {
+            continue;
+          }
           if (entityKind.isArray) {
             const arr = _isArrayLike(rawValue) ? _normalizeArray(rawValue) : rawValue;
             const mapped = [];
@@ -821,13 +1280,19 @@ function rootsToSceneAsset(registry, world, roots) {
       }
       if (Object.keys(fieldValues).length > 0) components[compName] = fieldValues;
     }
-    entities.push({ localId: lid, components });
+    legacyEntities.push({ localId: lid, components });
   }
-  return ok$1({
-    kind: "scene",
-    entities,
-    ...outMounts.length > 0 ? { mounts: outMounts } : {}
-  });
+  return collectKeyedSceneAsset(
+    world,
+    registry,
+    roots,
+    visited,
+    ownedEntities,
+    legacyEntities,
+    outMounts,
+    nonRootAnchors,
+    memberOrigin
+  );
 }
 
 export { createDevImportTransport, createRenderer, defaultAssetDecoderContributions, rootsToSceneAsset, serializeSceneAssetToPack, spriteAnimationTickSystem };