@aethervtt/shard-scene 0.0.1

package/dist/scene.js

@@ -0,0 +1,736 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import {
+  ChildOf,
+  findComponent,
+  findResource,
+  isPlainObject,
+  pointer,
+  quat,
+  ShardError
+} from "@aethervtt/shard-core";
+import { Materials, Meshes, materialFromJson, validateMaterial } from "@aethervtt/shard-render";
+import { FloatingOrigin, Grid, GridCell, Transform } from "@aethervtt/shard-transform";
+import {
+  InstancePart,
+  PrefabInstance,
+  SceneIndex,
+  SceneInstance,
+  SceneMember
+} from "./components.js";
+import { SCENE_VERSION } from "./format.js";
+import {
+  currentOverrides,
+  hookInstances,
+  instanceKindOf,
+  instanceKinds,
+  settleInstances,
+  validateInstance
+} from "./instances.js";
+import { PROCEDURAL_MESHES, parseProcedural, proceduralSourceFor } from "./procedural.js";
+const ALIASES = {
+  "core/Transform": {
+    rotationEuler: {
+      field: "rotation",
+      // Degrees, applied X then Y then Z.
+      decode(json) {
+        const [x, y, z] = json.map((d) => d * Math.PI / 180);
+        return [...quat.fromEuler([0, 0, 0, 1], x, y, z)];
+      }
+    }
+  }
+};
+function expandAliases(name, json, base, errors) {
+  const aliases = ALIASES[name];
+  if (!aliases) return json;
+  let out = json;
+  for (const [alias, { field, decode }] of Object.entries(aliases)) {
+    if (!(alias in json)) continue;
+    const value = json[alias];
+    if (field in json) {
+      errors?.push(
+        new ShardError("scene/conflicting-fields", `Both "${alias}" and "${field}" are set`, {
+          path: pointer(base, alias),
+          hint: `Use one: "${alias}" is the authoring form of "${field}".`
+        })
+      );
+      out = { ...out };
+      delete out[alias];
+      continue;
+    }
+    if (!Array.isArray(value) || value.length !== 3 || !value.every((v) => typeof v === "number" && Number.isFinite(v))) {
+      errors?.push(
+        new ShardError("schema/type-mismatch", `"${alias}" must be [x, y, z] in degrees`, {
+          path: pointer(base, alias)
+        })
+      );
+      continue;
+    }
+    out = { ...out };
+    delete out[alias];
+    out[field] = decode(value);
+  }
+  return out;
+}
+function resolveAssets(world, file, sceneId, mode, requested) {
+  const local = /* @__PURE__ */ new Map();
+  const server = assetServer(world);
+  const fromCatalog = (ref) => {
+    const entry = server.entry(ref);
+    if (!entry) return void 0;
+    if (mode === "create") {
+      server.request(entry.guid);
+      requested?.add(entry.guid);
+    }
+    return { guid: entry.guid, path: ref.path ?? entry.path, type: entry.type };
+  };
+  return (ref) => {
+    const path = ref.path;
+    if (path === void 0) {
+      const guid = ref.guid;
+      const known = fromCatalog(ref);
+      if (known) return known;
+      const type = guid.startsWith("mem:mesh") ? "Mesh" : guid.startsWith("mem:material") ? "Material" : void 0;
+      return type ? { guid, path: guid, type } : void 0;
+    }
+    if (path.startsWith("#")) {
+      const name = path.slice(1);
+      const cached = local.get(name);
+      if (cached) return cached;
+      const entry = file.assets?.[name];
+      if (!entry) return void 0;
+      if (mode === "check") return { guid: `pending:${path}`, path, type: entry.type };
+      let resolved;
+      if (entry.type === "Material") {
+        const store = world.tryResource(Materials);
+        if (!store) return void 0;
+        const ref2 = store.add(materialFromJson(entry.value), `${sceneId}${path}`);
+        resolved = { guid: ref2.guid, path, type: "Material" };
+      } else {
+        const proc = parseProcedural(entry.procedural, entry.params);
+        resolved = { ...procedural(world, proc.key, proc.source, proc.params), path };
+      }
+      local.set(name, resolved);
+      return resolved;
+    }
+    if (path.startsWith("procedural:")) {
+      const cached = local.get(path);
+      if (cached) return cached;
+      const spec = path.slice("procedural:".length);
+      const source = proceduralSourceFor(spec);
+      if (source) {
+        let resolved2;
+        if (mode === "check") {
+          try {
+            resolved2 = { guid: `pending:${path}`, path, type: source.check(spec).type };
+          } catch {
+            return void 0;
+          }
+        } else {
+          const made = source.resolve(world, spec);
+          server.request(made.guid);
+          requested?.add(made.guid);
+          resolved2 = { ...made, path };
+        }
+        local.set(path, resolved2);
+        return resolved2;
+      }
+      let proc;
+      try {
+        proc = parseProcedural(path.slice("procedural:".length));
+      } catch (err) {
+        if (mode === "check") return void 0;
+        throw err;
+      }
+      const resolved = mode === "check" ? { guid: `pending:${proc.key}`, path, type: "Mesh" } : { ...procedural(world, proc.key, proc.source, proc.params), path };
+      local.set(path, resolved);
+      return resolved;
+    }
+    return fromCatalog(ref);
+  };
+}
+function procedural(world, key, source, params) {
+  if (!world.tryResource(Meshes)) {
+    throw new ShardError(
+      "scene/asset-unavailable",
+      "Procedural meshes need the render/forward plugin"
+    );
+  }
+  const entry = assetServer(world).virtual(
+    `proc:${key}`,
+    key,
+    "Mesh",
+    () => PROCEDURAL_MESHES[source].create(params)
+  );
+  return { guid: entry.guid, path: key, type: "Mesh" };
+}
+function worldSchemaContext(world) {
+  hookInstances(world);
+  const empty = { version: SCENE_VERSION, entities: [] };
+  return {
+    resolveEntity: (path) => findEntityByPath(world, path),
+    resolveAsset: resolveAssets(world, empty, "runtime", "create")
+  };
+}
+function expandComponentAliases(name, json) {
+  const errors = [];
+  const out = expandAliases(name, json, "", errors);
+  if (errors.length > 0) throw errors[0];
+  return out;
+}
+function flatten(entities, base, parent, out) {
+  entities.forEach((entity, i) => {
+    const ptr = `${base}/${i}`;
+    const path = parent === void 0 ? entity.name : `${parent}/${entity.name}`;
+    out.push({ path, parent, entity, pointer: ptr });
+    if (Array.isArray(entity.children)) flatten(entity.children, `${ptr}/children`, path, out);
+  });
+}
+function rebase(err, base) {
+  return new ShardError(
+    err.code,
+    err.message.replace(/ at \/\S*/, ` at ${base}${err.path ?? ""}`),
+    {
+      path: `${base}${err.path ?? ""}`,
+      hint: err.hint
+    }
+  );
+}
+function componentDef(name) {
+  try {
+    return findComponent(name);
+  } catch {
+    return void 0;
+  }
+}
+function validateScene(world, json, options = {}) {
+  const errors = [];
+  if (!isPlainObject(json)) {
+    return [new ShardError("scene/invalid", "A scene file must be a JSON object", { path: "" })];
+  }
+  const file = json;
+  if (file.version !== SCENE_VERSION) {
+    errors.push(
+      new ShardError(
+        "scene/unsupported-version",
+        `Scene version ${JSON.stringify(file.version)} is not supported`,
+        {
+          path: "/version",
+          hint: `Use "version": ${SCENE_VERSION}.`
+        }
+      )
+    );
+  }
+  for (const key of Object.keys(file)) {
+    if (!["$schema", "version", "assets", "resources", "entities"].includes(key)) {
+      errors.push(
+        new ShardError("scene/unknown-field", `Unknown scene field "${key}"`, { path: `/${key}` })
+      );
+    }
+  }
+  validateAssetsBlock(file.assets, errors);
+  if (file.resources !== void 0) {
+    for (const [name, value] of Object.entries(file.resources ?? {})) {
+      if (!findResource(name)) {
+        errors.push(
+          new ShardError("scene/unknown-resource", `Unknown resource "${name}"`, {
+            path: pointer("/resources", name)
+          })
+        );
+      } else if (!isPlainObject(value)) {
+        errors.push(
+          new ShardError("schema/type-mismatch", `Resource "${name}" must be an object`, {
+            path: pointer("/resources", name)
+          })
+        );
+      }
+    }
+  }
+  if (!Array.isArray(file.entities)) {
+    errors.push(
+      new ShardError("schema/type-mismatch", '"entities" must be an array', { path: "/entities" })
+    );
+    return errors;
+  }
+  const flat = [];
+  flatten(file.entities, "/entities", void 0, flat);
+  validateTree(world, file, flat, errors, { id: options.id ?? "main" });
+  return dedupeErrors(errors);
+}
+function validateAssetsBlock(assets, errors) {
+  if (assets === void 0) return;
+  if (!isPlainObject(assets)) {
+    errors.push(
+      new ShardError("schema/type-mismatch", '"assets" must be an object', { path: "/assets" })
+    );
+    return;
+  }
+  for (const [name, entry] of Object.entries(assets)) {
+    const base = pointer("/assets", name);
+    if (entry?.type === "Material") {
+      for (const e of validateMaterial(entry.value)) errors.push(rebase(e, `${base}/value`));
+    } else if (entry?.type === "Mesh") {
+      try {
+        parseProcedural(entry.procedural, entry.params, base);
+      } catch (e) {
+        if (e instanceof ShardError) errors.push(e);
+      }
+    } else {
+      errors.push(
+        new ShardError(
+          "scene/invalid-asset",
+          `Asset "${name}" needs "type": "Material" or "Mesh"`,
+          {
+            path: base,
+            hint: 'Materials: { "type": "Material", "value": {...} }. Meshes: { "type": "Mesh", "procedural": "sphere", "params": {...} }.'
+          }
+        )
+      );
+    }
+  }
+}
+function validateTree(world, file, flat, errors, options) {
+  const checkedProcedural = /* @__PURE__ */ new Set();
+  const catalog = options.catalog ?? true;
+  const paths = new Set(options.extraPaths);
+  const prefab = options.root || options.extraPaths?.includes(".");
+  for (const f of flat) {
+    if (typeof f.entity?.name !== "string" || f.entity.name === "" || f.entity.name.includes("/")) {
+      errors.push(
+        new ShardError("scene/invalid-name", 'Every entity needs a "name" (non-empty, no "/")', {
+          path: `${f.pointer}/name`
+        })
+      );
+      continue;
+    }
+    if (paths.has(f.path)) {
+      errors.push(
+        new ShardError(
+          "scene/duplicate-name",
+          `Two entities are named "${f.entity.name}" under the same parent`,
+          {
+            path: `${f.pointer}/name`,
+            hint: "Names must be unique among siblings; they form entity paths."
+          }
+        )
+      );
+    }
+    paths.add(f.path);
+  }
+  const ctx = {
+    resolveAsset: resolveAssets(world, file, options.id, "check"),
+    resolveEntity: (path) => paths.has(path) ? 0 : void 0
+  };
+  for (const f of flat) {
+    for (const key of Object.keys(f.entity ?? {})) {
+      if (!["name", "components", "children"].includes(key)) {
+        errors.push(
+          new ShardError("scene/unknown-field", `Unknown entity field "${key}"`, {
+            path: pointer(f.pointer, key)
+          })
+        );
+      }
+    }
+    const components = f.entity?.components;
+    if (components === void 0) continue;
+    if (!isPlainObject(components)) {
+      errors.push(
+        new ShardError("schema/type-mismatch", '"components" must be an object', {
+          path: `${f.pointer}/components`
+        })
+      );
+      continue;
+    }
+    for (const [name, raw] of Object.entries(components)) {
+      const base = pointer(`${f.pointer}/components`, name);
+      const def = componentDef(name);
+      if (!def) {
+        errors.push(
+          new ShardError("scene/unknown-component", `Unknown component "${name}"`, {
+            path: base,
+            hint: 'Use a registered name like "core/Transform" or "render/Camera3d" (see .agents/components.md).'
+          })
+        );
+        continue;
+      }
+      if (!def.serializable || def === ChildOf) {
+        errors.push(
+          new ShardError("scene/derived-component", `"${name}" can't be written in a scene`, {
+            path: base,
+            hint: def === ChildOf ? 'Nest the entity under "children" instead.' : "It is computed by the engine each frame."
+          })
+        );
+        continue;
+      }
+      if (!isPlainObject(raw)) {
+        errors.push(
+          new ShardError("schema/type-mismatch", `"${name}" must be an object`, { path: base })
+        );
+        continue;
+      }
+      const expanded = expandAliases(name, raw, base, errors);
+      const before = errors.length;
+      for (const e of def.validate(expanded, ctx)) {
+        if (!catalog && isCatalogMiss(e, expanded)) continue;
+        if (options.inheritsAssets && isLocalMiss(e, expanded)) continue;
+        errors.push(rebase(e, base));
+      }
+      for (const { name: field, field: type } of def.layout) {
+        const value = expanded[field];
+        if (type.kind === "entity" && typeof value === "string" && !paths.has(value)) {
+          errors.push(
+            new ShardError("scene/unknown-entity-path", `No entity at path "${value}"`, {
+              path: pointer(base, field),
+              hint: `Paths join names with "/" from the top of the ${prefab ? 'prefab (its root is ".")' : "scene"}, e.g. "${[...paths].find((p) => p !== ".") ?? "ship/camera"}".`
+            })
+          );
+        }
+        if (type.kind === "handle" && isPlainObject(value) && typeof value.path === "string") {
+          const p = value.path;
+          if (p.startsWith("procedural:") && !checkedProcedural.has(p)) {
+            try {
+              const spec = p.slice("procedural:".length);
+              const source = proceduralSourceFor(spec);
+              if (source) source.check(spec, pointer(base, field));
+              else parseProcedural(spec, {}, pointer(base, field));
+              checkedProcedural.add(p);
+            } catch (e) {
+              if (e instanceof ShardError) errors.push(e);
+            }
+          }
+        }
+      }
+      if ((def === PrefabInstance || def === SceneInstance) && errors.length === before) {
+        validateInstance(world, def, expanded, base, f, errors, { catalog });
+      } else if (errors.length === before) {
+        instanceKindOf(def)?.validate?.(world, expanded, base, errors, { catalog });
+      }
+    }
+  }
+  validateGrids(flat, errors, prefab === true);
+}
+function validateGrids(flat, errors, prefab) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const f of flat) if (typeof f.path === "string") byPath.set(f.path, f);
+  const components = (f) => isPlainObject(f?.entity?.components) ? f.entity.components : void 0;
+  let origin;
+  for (const f of flat) {
+    const own = components(f);
+    if (!own) continue;
+    if (own[FloatingOrigin.name] !== void 0) {
+      if (origin === void 0) origin = f;
+      else {
+        errors.push(
+          new ShardError(
+            "transform/multiple-origins",
+            `"${f.path}" and "${origin.path}" both have FloatingOrigin`,
+            {
+              path: pointer(`${f.pointer}/components`, FloatingOrigin.name),
+              hint: "Keep one transform/FloatingOrigin per world, usually on the camera."
+            }
+          )
+        );
+      }
+    }
+    if (prefab && f.path === ".") continue;
+    const parentPath = f.parent ?? (prefab ? "." : void 0);
+    const parent = parentPath === void 0 ? void 0 : byPath.get(parentPath);
+    if (parentPath !== void 0 && parent === void 0) continue;
+    const up = components(parent);
+    if (up && instanceKinds().some((k) => up[k.def.name] !== void 0)) continue;
+    const grid = up?.[Grid.name];
+    const cell = own[GridCell.name];
+    if (grid === void 0) {
+      if (cell === void 0) continue;
+      errors.push(
+        new ShardError(
+          "transform/cell-outside-grid",
+          `"${f.path}" has a GridCell but its parent isn't a Grid`,
+          {
+            path: pointer(`${f.pointer}/components`, GridCell.name),
+            hint: "Nest the entity directly under an entity with transform/Grid, or remove its GridCell."
+          }
+        )
+      );
+      continue;
+    }
+    const transform = own[Transform.name];
+    const translation = isPlainObject(transform) ? transform.translation : void 0;
+    if (!Array.isArray(translation)) continue;
+    const size = isPlainObject(grid) ? grid.cellSize : void 0;
+    const cellSize = typeof size === "number" && size > 0 ? size : Grid.fields.cellSize.defaultValue();
+    if (translation.some((v) => typeof v === "number" && Math.abs(v) > cellSize)) {
+      errors.push(
+        new ShardError(
+          "transform/translation-outside-cell",
+          `"${f.path}" is more than one cell (${cellSize} m) from its cell's centre`,
+          {
+            path: pointer(pointer(`${f.pointer}/components`, Transform.name), "translation"),
+            hint: 'Split the position into transform/GridCell (whole cells) plus a translation under one cell, or place it with entity.patch { "position64": [x, y, z], "grid": <grid> }.'
+          }
+        )
+      );
+    }
+  }
+}
+function isLocalMiss(e, json) {
+  return e.code === "schema/asset-not-found" && !isCatalogMiss(e, json);
+}
+function isCatalogMiss(e, json) {
+  if (e.code !== "schema/asset-not-found") return false;
+  let value = json;
+  for (const part of (e.path ?? "").split("/").slice(1)) {
+    const key = part.replaceAll("~1", "/").replaceAll("~0", "~");
+    value = isPlainObject(value) || Array.isArray(value) ? value[key] : void 0;
+  }
+  const path = isPlainObject(value) ? value.path : void 0;
+  return typeof path !== "string" || !path.startsWith("#");
+}
+function dedupeErrors(errors) {
+  const specific = new Set(
+    errors.filter((e) => !e.code.startsWith("schema/") && e.code !== "scene/invalid").map((e) => e.path)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return errors.filter((e) => {
+    if (e.code === "schema/asset-not-found" && specific.has(e.path)) return false;
+    const key = `${e.code}|${e.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function loadScene(world, json, options = {}) {
+  const id = options.id ?? "main";
+  const index = world.initResource(SceneIndex);
+  if (index.has(id)) {
+    throw new ShardError("scene/already-loaded", `A scene with id "${id}" is already loaded`, {
+      hint: "Use reloadScene to replace it, or pass a different id."
+    });
+  }
+  const errors = validateScene(world, json, { id });
+  if (errors.length > 0) {
+    throw new ShardError(
+      "scene/invalid",
+      `Scene "${id}" has ${errors.length} error${errors.length === 1 ? "" : "s"}; first: ${errors[0].message}`,
+      { path: errors[0].path, hint: errors[0].hint, details: errors }
+    );
+  }
+  const file = json;
+  const flat = [];
+  flatten(file.entities, "/entities", void 0, flat);
+  const entities = /* @__PURE__ */ new Map();
+  for (const f of flat) entities.set(f.path, world.reserveEntity());
+  const requested = /* @__PURE__ */ new Set();
+  const ctx = {
+    resolveAsset: resolveAssets(world, file, id, "create", requested),
+    resolveEntity: (path) => entities.get(path)
+  };
+  const scene = {
+    id,
+    file,
+    order: flat.map((f) => f.path),
+    entities,
+    authored: /* @__PURE__ */ new Map(),
+    loaded: /* @__PURE__ */ new Map(),
+    loadedResources: /* @__PURE__ */ new Map(),
+    assets: requested
+  };
+  for (const f of flat) {
+    const entity = entities.get(f.path);
+    const inits = [];
+    for (const [name, raw] of Object.entries(f.entity.components ?? {})) {
+      const def = findComponent(name);
+      inits.push([def, def.deserialize(expandAliases(name, raw, "", void 0), ctx)]);
+    }
+    if (f.parent !== void 0)
+      inits.push([ChildOf, { parent: entities.get(f.parent) }]);
+    inits.push([SceneMember, { scene: id, path: f.path }]);
+    world.spawnReserved(entity, inits);
+    scene.authored.set(entity, f.entity);
+  }
+  for (const entity of entities.values())
+    scene.loaded.set(entity, serializeComponents(world, entity));
+  for (const [name, value] of Object.entries(file.resources ?? {})) {
+    const def = findResource(name);
+    const current = world.tryResource(def);
+    if (isPlainObject(current)) Object.assign(current, value);
+    else world.insertResource(def, structuredCloneJson(value));
+    scene.loadedResources.set(name, toJson(world.resource(def)));
+  }
+  index.set(id, scene);
+  return { id, entities };
+}
+async function whenSceneReady(world, id) {
+  const scene = world.tryResource(SceneIndex)?.get(id);
+  if (!scene) throw new ShardError("scene/not-loaded", `No scene with id "${id}" is loaded`);
+  const server = assetServer(world);
+  let size = -1;
+  while (scene.assets.size !== size) {
+    size = scene.assets.size;
+    await server.whenSettled(scene.assets);
+    await settleInstances(world);
+    for (const wait of sceneWaiters) await wait(world, scene.id);
+  }
+}
+const sceneWaiters = [];
+function addSceneReadyCheck(check) {
+  sceneWaiters.push(check);
+}
+function reloadScene(world, id, json) {
+  unloadScene(world, id, { collect: false });
+  const handle = loadScene(world, json, { id });
+  assetServer(world).collect();
+  return handle;
+}
+function unloadScene(world, id, options = {}) {
+  const index = world.initResource(SceneIndex);
+  const scene = index.get(id);
+  if (!scene) return;
+  for (const path of scene.order) {
+    const entity = scene.entities.get(path);
+    if (world.isAlive(entity)) world.despawn(entity);
+  }
+  index.delete(id);
+  if (options.collect ?? true) assetServer(world).collect();
+}
+function findEntityByPath(world, path) {
+  const index = world.tryResource(SceneIndex);
+  if (!index) return void 0;
+  const colon = path.indexOf(":");
+  if (colon !== -1) return index.get(path.slice(0, colon))?.entities.get(path.slice(colon + 1));
+  for (const scene of index.values()) {
+    const e = scene.entities.get(path);
+    if (e !== void 0 && world.isAlive(e)) return e;
+  }
+  return void 0;
+}
+function pathOfEntity(world, entity) {
+  return world.tryGet(entity, SceneMember)?.path;
+}
+function toJson(value) {
+  return JSON.parse(
+    JSON.stringify(
+      value,
+      (_, v) => ArrayBuffer.isView(v) ? Array.from(v) : v
+    )
+  );
+}
+function structuredCloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function equal(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function serializeComponents(world, entity) {
+  const out = /* @__PURE__ */ new Map();
+  for (const def of world.componentsOf(entity)) {
+    if (!def.serializable || def === ChildOf) continue;
+    out.set(def.name, def.serialize(world.get(entity, def)));
+  }
+  return out;
+}
+function saveScene(world, id) {
+  const scene = world.initResource(SceneIndex).get(id);
+  if (!scene) throw new ShardError("scene/not-loaded", `No scene with id "${id}" is loaded`);
+  const writeEntity = (path) => {
+    const entity = scene.entities.get(path);
+    if (!world.isAlive(entity)) return void 0;
+    const authored = scene.authored.get(entity);
+    const loaded = scene.loaded.get(entity);
+    const current = serializeComponents(world, entity);
+    for (const { def } of instanceKinds()) {
+      const value = current.get(def.name);
+      if (value) value.overrides = currentOverrides(world, entity) ?? value.overrides;
+    }
+    const out2 = {};
+    for (const key of Object.keys(authored)) {
+      if (key === "name") out2.name = authored.name;
+      else if (key === "components")
+        out2.components = writeComponents(authored.components ?? {}, loaded, current);
+      else if (key === "children") {
+        out2.children = (authored.children ?? []).map((child) => writeEntity(`${path}/${child.name}`)).filter((c) => c !== void 0);
+      }
+    }
+    if (!("components" in authored)) {
+      const added = writeComponents({}, loaded, current);
+      if (Object.keys(added).length > 0) out2.components = added;
+    }
+    return out2;
+  };
+  const writeComponents = (authored, loaded, current) => {
+    const out2 = {};
+    for (const [name, authoredJson] of Object.entries(authored)) {
+      const now = current.get(name);
+      if (!now) continue;
+      out2[name] = writeFields(name, authoredJson, loaded.get(name) ?? {}, now);
+    }
+    for (const [name, now] of current) {
+      if (name in authored || name === SceneMember.name || name === InstancePart.name) continue;
+      const before = loaded.get(name);
+      if (before && equal(before, now)) continue;
+      out2[name] = now;
+    }
+    return out2;
+  };
+  const writeFields = (name, authored, loaded, now) => {
+    const out2 = {};
+    const aliases = ALIASES[name] ?? {};
+    const covered = /* @__PURE__ */ new Set();
+    for (const [key, value] of Object.entries(authored)) {
+      const field = aliases[key]?.field ?? key;
+      covered.add(field);
+      if (equal(now[field], loaded[field])) out2[key] = value;
+      else out2[field] = now[field];
+    }
+    for (const field of Object.keys(now)) {
+      if (covered.has(field)) continue;
+      if (!equal(now[field], loaded[field])) out2[field] = now[field];
+    }
+    return out2;
+  };
+  const out = {};
+  for (const key of Object.keys(scene.file)) {
+    if (key === "entities") {
+      out.entities = scene.file.entities.map((e) => writeEntity(e.name)).filter((e) => e !== void 0);
+    } else if (key === "resources") {
+      const resources = {};
+      for (const [name, authored] of Object.entries(scene.file.resources ?? {})) {
+        const now = toJson(world.tryResource(findResource(name)));
+        resources[name] = equal(now, scene.loadedResources.get(name)) ? authored : now;
+      }
+      out.resources = resources;
+    } else {
+      out[key] = scene.file[key];
+    }
+  }
+  return out;
+}
+function stringifyScene(file) {
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+export {
+  ALIASES,
+  addSceneReadyCheck,
+  componentDef,
+  dedupeErrors,
+  equal,
+  expandAliases,
+  expandComponentAliases,
+  findEntityByPath,
+  flatten,
+  loadScene,
+  pathOfEntity,
+  rebase,
+  reloadScene,
+  resolveAssets,
+  saveScene,
+  serializeComponents,
+  stringifyScene,
+  toJson,
+  unloadScene,
+  validateAssetsBlock,
+  validateScene,
+  validateTree,
+  whenSceneReady,
+  worldSchemaContext
+};