@relu-interactives/spatial-ecs 0.5.3 → 0.9.0

package/dist/chunk-WWP46AEF.js

@@ -0,0 +1,2878 @@
+import { applyTransform } from './chunk-JEPUCLZX.js';
+import { ScriptComponent, ParentId, Object3DRef, ScriptObjectComponent, XRRigComponent, VRTeleportAreaComponent, XRInteractableComponent, createAttachPoint, XRHandPoseComponent, createHandPoseEntry, XRAnchorComponent, BoneAttachmentComponent, NetworkIdentityComponent, NetworkTransformComponent, NetworkedPropsComponent, NetworkSpawnerComponent, IKComponent, normalizeIKChain, UIPanelComponent, UITextComponent, UIButtonComponent, UIToggleComponent, UISliderComponent, XRInteractorComponent, XRInteractorSideComponent, InstancedMeshComponent, InstanceSlotComponent, AnimationComponent, Name, TransformComponent, ModelComponent, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, CameraComponent, Environment, Postprocessing, ImageTarget, LightComponent, MaterialComponent, MeshGeometryComponent, Selectable, PhysicsComponent, PrefabNode, PrefabInstance, normalizeUiStyle, normalizeUiTokens } from './chunk-JNYPJB55.js';
+import { __name } from './chunk-XE4OXN2W.js';
+import * as THREE from 'three';
+
+// core/systems/scriptShared.ts
+async function defaultModuleLoader(scriptUrl) {
+  return await import(
+    /* webpackIgnore: true */
+    scriptUrl
+  );
+}
+__name(defaultModuleLoader, "defaultModuleLoader");
+function sanitizeErrorText(value) {
+  return value.replace(/localasset:\/\/[^/]+\//g, "localasset://").replace(/\/Users\/[^\s)]+/g, "[local path]");
+}
+__name(sanitizeErrorText, "sanitizeErrorText");
+function toErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return sanitizeErrorText(error.message);
+  }
+  if (typeof error === "string" && error) {
+    return sanitizeErrorText(error);
+  }
+  return "Unknown script error.";
+}
+__name(toErrorMessage, "toErrorMessage");
+function toErrorStack(error) {
+  const stack = error && typeof error === "object" ? error.stack : void 0;
+  return typeof stack === "string" && stack.length > 0 ? sanitizeErrorText(stack) : void 0;
+}
+__name(toErrorStack, "toErrorStack");
+var SCRIPT_PHASE = /* @__PURE__ */ Symbol("scriptErrorPhase");
+function withScriptPhase(phase, error) {
+  if (error && typeof error === "object" && SCRIPT_PHASE in error) {
+    return error;
+  }
+  return { [SCRIPT_PHASE]: phase, error };
+}
+__name(withScriptPhase, "withScriptPhase");
+function readScriptPhase(thrown, fallback) {
+  if (thrown && typeof thrown === "object" && SCRIPT_PHASE in thrown) {
+    const phased = thrown;
+    return { phase: phased[SCRIPT_PHASE], error: phased.error };
+  }
+  return { phase: fallback, error: thrown };
+}
+__name(readScriptPhase, "readScriptPhase");
+function reportScriptError(world, report, error) {
+  const reporter = world.reportScriptError;
+  if (typeof reporter === "function") {
+    reporter.call(world, report, error);
+    return;
+  }
+  console.error(
+    `[spatial-ecs] ${report.className || "Script"} failed in ${report.phase} (entity ${report.entityId}):`,
+    error
+  );
+}
+__name(reportScriptError, "reportScriptError");
+function reportBehaviourHookError(world, entityId, instance, hook, error) {
+  let scriptUrl = "";
+  let className = instance?.constructor?.name ?? "";
+  const script = typeof world.getComponent === "function" ? world.getComponent(entityId, ScriptComponent) : void 0;
+  if (script?.scriptInstances && Array.isArray(script.entries)) {
+    const entries = script.entries.filter(
+      (entry) => entry && (entry.className || entry.scriptUrl)
+    );
+    for (const [index, live] of script.scriptInstances) {
+      if (live !== instance) continue;
+      const entry = entries[index];
+      if (entry) {
+        scriptUrl = typeof entry.scriptUrl === "string" ? entry.scriptUrl : "";
+        className = typeof entry.className === "string" && entry.className ? entry.className : className;
+      }
+      break;
+    }
+  }
+  reportScriptError(
+    world,
+    { entityId, scriptUrl, className, phase: hook, source: "behaviour" },
+    error
+  );
+}
+__name(reportBehaviourHookError, "reportBehaviourHookError");
+function resolveScriptCtor(moduleValue, className, options) {
+  const named = moduleValue[className];
+  const fallback = moduleValue.default;
+  const candidate = typeof named === "function" ? named : typeof fallback === "function" ? fallback : null;
+  if (!candidate) {
+    return null;
+  }
+  if (!(candidate.prototype instanceof options.baseClass)) {
+    const marker = candidate[options.markerKey];
+    if (!marker) {
+      return null;
+    }
+  }
+  return candidate;
+}
+__name(resolveScriptCtor, "resolveScriptCtor");
+function normalizeScriptData(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+__name(normalizeScriptData, "normalizeScriptData");
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function mergeValueByDefaultShape(defaultValue, currentValue) {
+  if (Array.isArray(defaultValue)) {
+    return Array.isArray(currentValue) ? currentValue : defaultValue;
+  }
+  if (isPlainObject(defaultValue)) {
+    if (!isPlainObject(currentValue)) {
+      return defaultValue;
+    }
+    const next = {};
+    for (const key of Object.keys(defaultValue)) {
+      next[key] = mergeValueByDefaultShape(defaultValue[key], currentValue[key]);
+    }
+    return next;
+  }
+  if (typeof defaultValue === "number") {
+    return typeof currentValue === "number" ? currentValue : defaultValue;
+  }
+  if (typeof defaultValue === "string") {
+    return typeof currentValue === "string" ? currentValue : defaultValue;
+  }
+  if (typeof defaultValue === "boolean") {
+    return typeof currentValue === "boolean" ? currentValue : defaultValue;
+  }
+  if (defaultValue === null) {
+    return currentValue !== void 0 ? currentValue : null;
+  }
+  return typeof currentValue === "undefined" ? defaultValue : currentValue;
+}
+__name(mergeValueByDefaultShape, "mergeValueByDefaultShape");
+function mergeDataByCurrentDefaults(defaults, current) {
+  const next = {};
+  for (const key of Object.keys(defaults)) {
+    next[key] = mergeValueByDefaultShape(defaults[key], current[key]);
+  }
+  return next;
+}
+__name(mergeDataByCurrentDefaults, "mergeDataByCurrentDefaults");
+function isRawEntityInput(value) {
+  if (!isPlainObject(value)) return false;
+  return value.type === "entity";
+}
+__name(isRawEntityInput, "isRawEntityInput");
+function isRawComponentInput(value) {
+  if (!isPlainObject(value)) return false;
+  return value.type === "component";
+}
+__name(isRawComponentInput, "isRawComponentInput");
+function findComponentByKind(components, componentKind) {
+  return components.find(
+    (c) => c.constructor.name === `${componentKind}Component` || c.constructor.name === componentKind
+  ) ?? null;
+}
+__name(findComponentByKind, "findComponentByKind");
+function resolveInputData(world, rawData) {
+  const resolved = { ...rawData };
+  for (const [key, value] of Object.entries(rawData)) {
+    if (isRawEntityInput(value)) {
+      const entityId = value.value;
+      const entityView = typeof entityId === "number" ? world.getEntityById(entityId) : null;
+      resolved[key] = { ...value, value: entityView };
+    } else if (isRawComponentInput(value)) {
+      const ref = value.value;
+      if (isPlainObject(ref) && typeof ref.entityId === "number" && typeof ref.componentKind === "string") {
+        const { entityId: refEntityId, componentKind } = ref;
+        const entityView = world.getEntityById(refEntityId);
+        const component = entityView ? findComponentByKind(entityView.components, componentKind) : null;
+        resolved[key] = { ...value, value: component };
+      }
+    }
+  }
+  return resolved;
+}
+__name(resolveInputData, "resolveInputData");
+function serializeDataForStorage(rawData, instanceData) {
+  const result = { ...instanceData };
+  for (const [key, rawValue] of Object.entries(rawData)) {
+    if (isRawEntityInput(rawValue) || isRawComponentInput(rawValue)) {
+      result[key] = rawValue;
+    }
+  }
+  return result;
+}
+__name(serializeDataForStorage, "serializeDataForStorage");
+
+// core/prefab/collectEntitySubtree.ts
+function collectEntitySubtree(world, rootIds) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const entityId of world.query(ParentId)) {
+    const parentId = world.getComponent(entityId, ParentId)?.value;
+    if (parentId === null || parentId === void 0) {
+      continue;
+    }
+    const siblings = childrenByParent.get(parentId);
+    if (siblings) {
+      siblings.push(entityId);
+    } else {
+      childrenByParent.set(parentId, [entityId]);
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...rootIds];
+  while (queue.length > 0) {
+    const entityId = queue.shift();
+    if (seen.has(entityId)) {
+      continue;
+    }
+    seen.add(entityId);
+    ordered.push(entityId);
+    const children = childrenByParent.get(entityId);
+    if (children) {
+      queue.push(...children.sort((a, b) => a - b));
+    }
+  }
+  return ordered;
+}
+__name(collectEntitySubtree, "collectEntitySubtree");
+
+// 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"),
+    scriptObjectValues: readByComponent(
+      snapshot.components,
+      "ScriptObjectComponent"
+    ),
+    xrRigValues: readByComponent(snapshot.components, "XRRigComponent"),
+    vrTeleportAreaValues: readByComponent(
+      snapshot.components,
+      "VRTeleportAreaComponent"
+    ),
+    xrInteractableValues: readByComponent(
+      snapshot.components,
+      "XRInteractableComponent"
+    ),
+    xrInteractorValues: readByComponent(
+      snapshot.components,
+      "XRInteractorComponent"
+    ),
+    xrHandPoseValues: readByComponent(
+      snapshot.components,
+      "XRHandPoseComponent"
+    ),
+    xrAnchorValues: readByComponent(snapshot.components, "XRAnchorComponent"),
+    boneAttachmentValues: readByComponent(snapshot.components, "BoneAttachmentComponent"),
+    ikValues: readByComponent(snapshot.components, "IKComponent"),
+    networkIdentityValues: readByComponent(snapshot.components, "NetworkIdentityComponent"),
+    networkTransformValues: readByComponent(snapshot.components, "NetworkTransformComponent"),
+    networkedPropsValues: readByComponent(snapshot.components, "NetworkedPropsComponent"),
+    networkSpawnerValues: readByComponent(snapshot.components, "NetworkSpawnerComponent"),
+    uiPanelValues: readByComponent(snapshot.components, "UIPanelComponent"),
+    uiTextValues: readByComponent(snapshot.components, "UITextComponent"),
+    uiButtonValues: readByComponent(snapshot.components, "UIButtonComponent"),
+    uiToggleValues: readByComponent(snapshot.components, "UIToggleComponent"),
+    uiSliderValues: readByComponent(snapshot.components, "UISliderComponent"),
+    xrInteractorSideValues: readByComponent(
+      snapshot.components,
+      "XRInteractorSideComponent"
+    ),
+    instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
+    instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
+    prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
+    prefabInstanceValues: readByComponent(snapshot.components, "PrefabInstance")
+  };
+}
+__name(buildComponentValueMaps, "buildComponentValueMaps");
+
+// core/hydration/postCreateComponents.ts
+var OPTIONAL_UI_FIELDS = {
+  pixelDensity: "number",
+  icon: "string",
+  iconPosition: "string",
+  variant: "string",
+  step: "number",
+  readOnly: "boolean"
+};
+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;
+        result[key] = {
+          ...v,
+          value: { ...ref, entityId: idMap.get(ref.entityId) ?? ref.entityId }
+        };
+      } else {
+        result[key] = value;
+      }
+    } else {
+      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
+      }
+    );
+  }
+  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
+    });
+  }
+  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) {
+      world.addComponent(targetEntityId, new ScriptComponent(entries));
+    }
+  }
+  const sourceScriptObject = asRecord(values.scriptObjectValues.get(sourceEntityId));
+  if (sourceScriptObject) {
+    const soc = world.getComponent(targetEntityId, ScriptObjectComponent);
+    const data = asRecord(sourceScriptObject.data);
+    if (soc && data) {
+      soc.data = remapEntityRefsInScriptData(data, idMap);
+    }
+  }
+  {
+    const sourceXrRig = asRecord(values.xrRigValues.get(sourceEntityId));
+    const rig = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceXrRig && rig) {
+      if (typeof sourceXrRig.locomotion === "string") {
+        rig.locomotion = sourceXrRig.locomotion;
+      }
+      if (typeof sourceXrRig.moveSpeed === "number") {
+        rig.moveSpeed = sourceXrRig.moveSpeed;
+      }
+      if (typeof sourceXrRig.snapTurn === "boolean") {
+        rig.snapTurn = sourceXrRig.snapTurn;
+      }
+      if (typeof sourceXrRig.snapTurnDegrees === "number") {
+        rig.snapTurnDegrees = sourceXrRig.snapTurnDegrees;
+      }
+      if (typeof sourceXrRig.teleportArcColor === "string") {
+        rig.teleportArcColor = sourceXrRig.teleportArcColor;
+      }
+      if (typeof sourceXrRig.teleportArcInvalidColor === "string") {
+        rig.teleportArcInvalidColor = sourceXrRig.teleportArcInvalidColor;
+      }
+      if (typeof sourceXrRig.teleportArcThickness === "number") {
+        rig.teleportArcThickness = sourceXrRig.teleportArcThickness;
+      }
+      if (typeof sourceXrRig.fallbackEyeHeight === "number") {
+        rig.fallbackEyeHeight = sourceXrRig.fallbackEyeHeight;
+      }
+      if (typeof sourceXrRig.passthrough === "boolean") {
+        rig.passthrough = sourceXrRig.passthrough;
+      }
+      if (typeof sourceXrRig.depthOcclusion === "boolean") {
+        rig.depthOcclusion = sourceXrRig.depthOcclusion;
+      }
+      if (typeof sourceXrRig.environmentPhysics === "string") {
+        rig.environmentPhysics = sourceXrRig.environmentPhysics;
+      }
+      if (typeof sourceXrRig.environmentDebug === "boolean") {
+        rig.environmentDebug = sourceXrRig.environmentDebug;
+      }
+      if (typeof sourceXrRig.hitTest === "boolean") {
+        rig.hitTest = sourceXrRig.hitTest;
+      }
+      if (typeof sourceXrRig.anchors === "boolean") {
+        rig.anchors = sourceXrRig.anchors;
+      }
+    }
+  }
+  {
+    const sourceArea = asRecord(values.vrTeleportAreaValues.get(sourceEntityId));
+    const area = world.getComponent(targetEntityId, VRTeleportAreaComponent);
+    if (sourceArea && area) {
+      if (typeof sourceArea.enabled === "boolean") {
+        area.enabled = sourceArea.enabled;
+      }
+      if (typeof sourceArea.shape === "string") {
+        area.shape = sourceArea.shape === "cylinder" ? "circle" : sourceArea.shape;
+      }
+      if (typeof sourceArea.width === "number") area.width = sourceArea.width;
+      if (typeof sourceArea.depth === "number") area.depth = sourceArea.depth;
+    }
+  }
+  {
+    const sourceInteractable = asRecord(
+      values.xrInteractableValues.get(sourceEntityId)
+    );
+    let interactable = world.getComponent(
+      targetEntityId,
+      XRInteractableComponent
+    );
+    if (sourceInteractable && !interactable) {
+      interactable = new XRInteractableComponent();
+      world.addComponent(targetEntityId, interactable);
+    }
+    if (sourceInteractable && interactable) {
+      if (typeof sourceInteractable.enabled === "boolean") {
+        interactable.enabled = sourceInteractable.enabled;
+      }
+      if (typeof sourceInteractable.grabbable === "boolean") {
+        interactable.grabbable = sourceInteractable.grabbable;
+      }
+      if (typeof sourceInteractable.pointable === "boolean") {
+        interactable.pointable = sourceInteractable.pointable;
+      }
+      if (typeof sourceInteractable.grabReach === "string") {
+        interactable.grabReach = sourceInteractable.grabReach;
+      }
+      if (typeof sourceInteractable.distanceBehavior === "string") {
+        interactable.distanceBehavior = sourceInteractable.distanceBehavior;
+      }
+      if (typeof sourceInteractable.grabGesture === "string") {
+        interactable.grabGesture = sourceInteractable.grabGesture;
+      }
+      if (typeof sourceInteractable.grabRadius === "number") {
+        interactable.grabRadius = sourceInteractable.grabRadius;
+      }
+      if (typeof sourceInteractable.grabHands === "string") {
+        interactable.grabHands = sourceInteractable.grabHands;
+      }
+      if (typeof sourceInteractable.twoHandRotation === "string") {
+        interactable.twoHandRotation = sourceInteractable.twoHandRotation;
+      }
+      if (typeof sourceInteractable.allowTwoHandScale === "boolean") {
+        interactable.allowTwoHandScale = sourceInteractable.allowTwoHandScale;
+      }
+      if (typeof sourceInteractable.minScale === "number") {
+        interactable.minScale = sourceInteractable.minScale;
+      }
+      if (typeof sourceInteractable.maxScale === "number") {
+        interactable.maxScale = sourceInteractable.maxScale;
+      }
+      if (Array.isArray(sourceInteractable.attachPoints)) {
+        interactable.attachPoints = sourceInteractable.attachPoints.map((point) => asRecord(point)).filter(
+          (point) => point !== null && typeof point.id === "string"
+        ).map(
+          (point) => createAttachPoint(
+            point
+          )
+        );
+      }
+      if (typeof sourceInteractable.applyVelocityOnRelease === "boolean") {
+        interactable.applyVelocityOnRelease = sourceInteractable.applyVelocityOnRelease;
+      } else if (typeof sourceInteractable.throwOnRelease === "boolean") {
+        interactable.applyVelocityOnRelease = sourceInteractable.throwOnRelease;
+      }
+      if (typeof sourceInteractable.velocityScale === "number") {
+        interactable.velocityScale = sourceInteractable.velocityScale;
+      } else if (typeof sourceInteractable.throwStrength === "number") {
+        interactable.velocityScale = sourceInteractable.throwStrength;
+      }
+      const grabPos = asRecord(sourceInteractable.grabOffsetPosition);
+      if (grabPos) {
+        interactable.grabOffsetPosition = {
+          x: typeof grabPos.x === "number" ? grabPos.x : 0,
+          y: typeof grabPos.y === "number" ? grabPos.y : 0,
+          z: typeof grabPos.z === "number" ? grabPos.z : 0
+        };
+      }
+      const grabRot = asRecord(sourceInteractable.grabOffsetRotation);
+      if (grabRot) {
+        interactable.grabOffsetRotation = {
+          x: typeof grabRot.x === "number" ? grabRot.x : 0,
+          y: typeof grabRot.y === "number" ? grabRot.y : 0,
+          z: typeof grabRot.z === "number" ? grabRot.z : 0
+        };
+      }
+      if (typeof sourceInteractable.hoverBehavior === "string") {
+        interactable.hoverBehavior = sourceInteractable.hoverBehavior;
+      } else if (sourceInteractable.highlightOnHover === false) {
+        interactable.hoverBehavior = "none";
+      }
+      if (typeof sourceInteractable.hoverColor === "string") {
+        interactable.hoverColor = sourceInteractable.hoverColor;
+      }
+      if (typeof sourceInteractable.hoverScale === "number") {
+        interactable.hoverScale = sourceInteractable.hoverScale;
+      }
+    }
+  }
+  {
+    const sourceHandPose = asRecord(
+      values.xrHandPoseValues.get(sourceEntityId)
+    );
+    let handPose = world.getComponent(targetEntityId, XRHandPoseComponent);
+    if (sourceHandPose && !handPose) {
+      handPose = new XRHandPoseComponent();
+      world.addComponent(targetEntityId, handPose);
+    }
+    if (sourceHandPose && handPose) {
+      if (typeof sourceHandPose.enabled === "boolean") {
+        handPose.enabled = sourceHandPose.enabled;
+      }
+      if (Array.isArray(sourceHandPose.poses)) {
+        handPose.poses = sourceHandPose.poses.map((entry) => asRecord(entry)).filter(
+          (entry) => entry !== null && typeof entry.id === "string"
+        ).map(
+          (entry) => createHandPoseEntry(
+            entry
+          )
+        );
+      }
+    }
+  }
+  {
+    const sourceAnchor = asRecord(values.xrAnchorValues.get(sourceEntityId));
+    let anchor = world.getComponent(targetEntityId, XRAnchorComponent);
+    if (sourceAnchor && !anchor) {
+      anchor = new XRAnchorComponent();
+      world.addComponent(targetEntityId, anchor);
+    }
+    if (sourceAnchor && anchor) {
+      if (typeof sourceAnchor.enabled === "boolean") {
+        anchor.enabled = sourceAnchor.enabled;
+      }
+    }
+  }
+  {
+    const source = asRecord(values.boneAttachmentValues.get(sourceEntityId));
+    if (source) {
+      let attachment = world.getComponent(targetEntityId, BoneAttachmentComponent);
+      if (!attachment) {
+        attachment = new BoneAttachmentComponent();
+        world.addComponent(targetEntityId, attachment);
+      }
+      if (typeof source.bone === "string") attachment.bone = source.bone;
+      if (typeof source.humanoid === "string" || source.humanoid === null) attachment.humanoid = source.humanoid;
+      if (typeof source.compensateScale === "boolean") attachment.compensateScale = source.compensateScale;
+      if (typeof source.enabled === "boolean") attachment.enabled = source.enabled;
+    }
+  }
+  if (values.networkIdentityValues.has(sourceEntityId) && !world.getComponent(targetEntityId, NetworkIdentityComponent)) {
+    world.addComponent(targetEntityId, new NetworkIdentityComponent());
+  }
+  {
+    const source = asRecord(values.networkTransformValues.get(sourceEntityId));
+    if (source) {
+      let net = world.getComponent(targetEntityId, NetworkTransformComponent);
+      if (!net) {
+        net = new NetworkTransformComponent();
+        world.addComponent(targetEntityId, net);
+      }
+      if (typeof source.enabled === "boolean") net.enabled = source.enabled;
+      if (typeof source.sendRate === "number") net.sendRate = source.sendRate;
+      if (typeof source.interpolationMs === "number") {
+        net.interpolationMs = source.interpolationMs;
+      }
+      if (typeof source.syncRotation === "boolean") {
+        net.syncRotation = source.syncRotation;
+      }
+      if (typeof source.teleportDistance === "number") {
+        net.teleportDistance = source.teleportDistance;
+      }
+    }
+  }
+  {
+    const source = asRecord(values.networkedPropsValues.get(sourceEntityId));
+    if (source) {
+      let props = world.getComponent(targetEntityId, NetworkedPropsComponent);
+      if (!props) {
+        props = new NetworkedPropsComponent();
+        world.addComponent(targetEntityId, props);
+      }
+      props.values = asRecord(source.values) ?? {};
+    }
+  }
+  {
+    const source = asRecord(values.networkSpawnerValues.get(sourceEntityId));
+    if (source) {
+      let spawner = world.getComponent(targetEntityId, NetworkSpawnerComponent);
+      if (!spawner) {
+        spawner = new NetworkSpawnerComponent();
+        world.addComponent(targetEntityId, spawner);
+      }
+      if (typeof source.playerPrefab === "string") {
+        spawner.playerPrefab = source.playerPrefab;
+      }
+      if (typeof source.spawnRadius === "number") {
+        spawner.spawnRadius = source.spawnRadius;
+      }
+    }
+  }
+  {
+    const source = asRecord(values.ikValues.get(sourceEntityId));
+    if (source) {
+      let ik = world.getComponent(targetEntityId, IKComponent);
+      if (!ik) {
+        ik = new IKComponent();
+        world.addComponent(targetEntityId, ik);
+      }
+      if (typeof source.enabled === "boolean") ik.enabled = source.enabled;
+      if (Array.isArray(source.chains)) {
+        const mapId = /* @__PURE__ */ __name((v) => typeof v === "number" ? idMap.get(v) ?? v : null, "mapId");
+        ik.chains = source.chains.map((raw) => asRecord(raw)).filter((c) => !!c && typeof c.limb === "string").map(
+          (c) => normalizeIKChain({
+            ...c,
+            limb: c.limb,
+            target: mapId(c.target),
+            pole: mapId(c.pole)
+          })
+        );
+      }
+    }
+  }
+  {
+    const restoreUi = /* @__PURE__ */ __name((map, Ctor, existing) => {
+      const source = asRecord(map.get(sourceEntityId));
+      if (!source) return;
+      let component = existing;
+      if (!component) {
+        component = new Ctor();
+        world.addComponent(targetEntityId, component);
+      }
+      const target = component;
+      for (const [key, value] of Object.entries(source)) {
+        const current = target[key];
+        if (key === "style") {
+          const style = normalizeUiStyle(value);
+          if (style) target.style = style;
+          continue;
+        }
+        if (key === "tokens") {
+          const tokens = normalizeUiTokens(value);
+          if (tokens) target.tokens = tokens;
+          continue;
+        }
+        if (OPTIONAL_UI_FIELDS[key] === typeof value) {
+          target[key] = value;
+          continue;
+        }
+        if ((typeof value === "string" || typeof value === "number" || typeof value === "boolean") && typeof current === typeof value) {
+          target[key] = value;
+        }
+      }
+    }, "restoreUi");
+    restoreUi(
+      values.uiPanelValues,
+      UIPanelComponent,
+      world.getComponent(targetEntityId, UIPanelComponent)
+    );
+    restoreUi(
+      values.uiTextValues,
+      UITextComponent,
+      world.getComponent(targetEntityId, UITextComponent)
+    );
+    restoreUi(
+      values.uiButtonValues,
+      UIButtonComponent,
+      world.getComponent(targetEntityId, UIButtonComponent)
+    );
+    restoreUi(
+      values.uiToggleValues,
+      UIToggleComponent,
+      world.getComponent(targetEntityId, UIToggleComponent)
+    );
+    restoreUi(
+      values.uiSliderValues,
+      UISliderComponent,
+      world.getComponent(targetEntityId, UISliderComponent)
+    );
+  }
+  {
+    const sourceInteractor = asRecord(
+      values.xrInteractorValues.get(sourceEntityId)
+    );
+    const interactor = world.getComponent(targetEntityId, XRInteractorComponent);
+    if (sourceInteractor && interactor) {
+      if (typeof sourceInteractor.interactorType === "string") {
+        interactor.interactorType = sourceInteractor.interactorType;
+      }
+      if (typeof sourceInteractor.handPreset === "string") {
+        interactor.handPreset = sourceInteractor.handPreset;
+      }
+      if (typeof sourceInteractor.handColor === "string") {
+        interactor.handColor = sourceInteractor.handColor;
+      }
+      if (typeof sourceInteractor.handOpacity === "number") {
+        interactor.handOpacity = sourceInteractor.handOpacity;
+      }
+      if (typeof sourceInteractor.handEmissiveIntensity === "number") {
+        interactor.handEmissiveIntensity = sourceInteractor.handEmissiveIntensity;
+      }
+      if (typeof sourceInteractor.rayVisibility === "string") {
+        interactor.rayVisibility = sourceInteractor.rayVisibility;
+      } else if (typeof sourceInteractor.showRay === "boolean") {
+        interactor.rayVisibility = sourceInteractor.showRay ? "interacting" : "never";
+      }
+      if (typeof sourceInteractor.rayColor === "string") {
+        interactor.rayColor = sourceInteractor.rayColor;
+      }
+      if (typeof sourceInteractor.rayThickness === "number") {
+        interactor.rayThickness = sourceInteractor.rayThickness;
+      }
+    }
+  }
+  {
+    const sourceSide = asRecord(
+      values.xrInteractorSideValues.get(sourceEntityId)
+    );
+    if (sourceSide && typeof sourceSide.side === "string") {
+      const existing = world.getComponent(
+        targetEntityId,
+        XRInteractorSideComponent
+      );
+      if (existing) {
+        existing.side = sourceSide.side;
+      } else {
+        world.addComponent(
+          targetEntityId,
+          new XRInteractorSideComponent({
+            side: sourceSide.side
+          })
+        );
+      }
+    }
+  }
+  {
+    const sourceRigOrigin = asRecord(values.xrRigValues.get(sourceEntityId));
+    const rigForOrigin = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceRigOrigin && rigForOrigin && typeof sourceRigOrigin.trackingOrigin === "string") {
+      rigForOrigin.trackingOrigin = sourceRigOrigin.trackingOrigin;
+    }
+  }
+  {
+    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;
+    }
+  }
+}
+__name(restorePostCreateComponents, "restorePostCreateComponents");
+
+// 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;
+}
+__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
+    });
+  }
+  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(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;
+  return {
+    paused,
+    reverse,
+    timeScale,
+    crossFadeDuration,
+    states,
+    externalClipSources,
+    activeState: activeStateName
+  };
+}
+__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
+    );
+    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);
+    }
+  }
+}
+__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;
+      }
+    }
+  }
+  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
+        };
+      }
+    }
+  }
+  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 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;
+      }
+      const zoom = readNumber(sourceCamera.zoom);
+      if (typeof zoom === "number") {
+        cameraComponent.zoom = zoom;
+      }
+    }
+  }
+  const sourceEnvironment = readEnvironmentState(
+    values.environmentValues.get(sourceEntityId)
+  );
+  if (sourceEnvironment) {
+    let environmentComponent = world.getComponent(targetEntityId, Environment);
+    if (!environmentComponent) {
+      objectManagementSystem.createComponentNow(
+        "environment",
+        world,
+        targetEntityId,
+        sourceEnvironment
+      );
+      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
+      );
+      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 sourceAssetRefs = sourceMaterial.assetRefs;
+    if (materialComponent && Array.isArray(sourceAssetRefs)) {
+      materialComponent.assetRefs = sourceAssetRefs;
+    }
+  }
+  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 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 sourceAnimation = asRecord(values.animationValues.get(sourceEntityId));
+  if (sourceAnimation) {
+    restoreAnimationComponent(
+      world,
+      objectManagementSystem,
+      targetEntityId,
+      sourceAnimation
+    );
+  }
+  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;
+      }
+      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;
+    }
+  }
+  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 sourcePrefabNode = asRecord(values.prefabNodeValues.get(sourceEntityId));
+  if (sourcePrefabNode && typeof sourcePrefabNode.nodeId === "string") {
+    if (!world.getComponent(targetEntityId, PrefabNode)) {
+      world.addComponent(targetEntityId, new PrefabNode(sourcePrefabNode.nodeId));
+    }
+  }
+  const sourcePrefabInstance = asRecord(
+    values.prefabInstanceValues.get(sourceEntityId)
+  );
+  if (sourcePrefabInstance && typeof sourcePrefabInstance.url === "string") {
+    if (!world.getComponent(targetEntityId, PrefabInstance)) {
+      const overrides = Array.isArray(sourcePrefabInstance.overrides) ? sourcePrefabInstance.overrides.filter(
+        (entry) => typeof entry === "string"
+      ) : [];
+      world.addComponent(
+        targetEntityId,
+        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
+        )
+      );
+    }
+  }
+}
+__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",
+  "scriptObject",
+  "xrRig",
+  "xrInteractor",
+  "teleportArea",
+  "uiPanel",
+  "uiText",
+  "uiButton",
+  "uiToggle",
+  "uiSlider"
+]);
+
+// 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) {
+      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
+      });
+      continue;
+    }
+    const mappedParentId = idMap.get(sourceParentId);
+    objectManagementSystem.setParent(world, targetEntityId, mappedParentId ?? null, {
+      preserveWorldTransform: false
+    });
+  }
+}
+__name(applyParentLinks, "applyParentLinks");
+
+// 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
+      };
+    }
+  }
+  if (kind === "scriptObject") {
+    const so = asRecord(componentValues.scriptObjectValues.get(sourceEntityId));
+    if (so) {
+      payload.options = {
+        scriptUrl: typeof so.scriptUrl === "string" ? so.scriptUrl : null,
+        className: typeof so.className === "string" ? so.className : null,
+        enabled: typeof so.enabled === "boolean" ? so.enabled : true
+      };
+    }
+  }
+  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;
+    }
+  }
+  return firstCameraSourceEntityId;
+}
+__name(resolvePrimaryCameraSourceEntityId, "resolvePrimaryCameraSourceEntityId");
+function applyLocalTransformsAfterHierarchyRestore(world, scopeEntityIds) {
+  const transformEntities = scopeEntityIds ? Array.from(scopeEntityIds) : 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;
+    }
+    applyTransform(object, transform);
+    object.updateMatrixWorld(true);
+  }
+}
+__name(applyLocalTransformsAfterHierarchyRestore, "applyLocalTransformsAfterHierarchyRestore");
+function hydrateWorldFromSnapshotDetailed(snapshot, world, objectManagementSystem, options) {
+  if (!snapshot || !snapshot.entities.length) {
+    return {
+      restoredCount: 0,
+      selectedEntityId: null,
+      idMap: /* @__PURE__ */ new Map()
+    };
+  }
+  const assignPrimaryCamera = options?.assignPrimaryCamera !== false;
+  const entityTypeValues = readByComponent(snapshot.components, "EntityType");
+  const componentValues = buildComponentValueMaps(snapshot);
+  const primaryCameraSourceEntityId = assignPrimaryCamera ? resolvePrimaryCameraSourceEntityId(
+    snapshot,
+    componentValues,
+    entityTypeValues
+  ) : null;
+  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 options2 = asRecord(payload.options);
+      payload.options = {
+        ...options2 ?? {},
+        isDefault: true
+      };
+    }
+    payload.skipDefaultChildren = true;
+    const createdEntityId = objectManagementSystem.createNow(kind, world, payload);
+    idMap.set(sourceEntityId, createdEntityId);
+  }
+  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
+    );
+  }
+  applyParentLinks(snapshot, idMap, objectManagementSystem, world);
+  objectManagementSystem.reconcileSceneFromWorld(world);
+  applyLocalTransformsAfterHierarchyRestore(
+    world,
+    options?.applyTransformsScope === "created" ? idMap.values() : void 0
+  );
+  const selectedEntityId = typeof snapshot.selectedEntityId === "number" ? idMap.get(snapshot.selectedEntityId) ?? null : null;
+  return {
+    restoredCount: idMap.size,
+    selectedEntityId,
+    idMap
+  };
+}
+__name(hydrateWorldFromSnapshotDetailed, "hydrateWorldFromSnapshotDetailed");
+function hydrateWorldFromSnapshot(snapshot, world, objectManagementSystem) {
+  return hydrateWorldFromSnapshotDetailed(
+    snapshot,
+    world,
+    objectManagementSystem
+  ).restoredCount;
+}
+__name(hydrateWorldFromSnapshot, "hydrateWorldFromSnapshot");
+
+// core/prefab/nodeKeys.ts
+var NODE_KEY_SEPARATOR = "/";
+var ADDED_NODE_MARKER_COMPONENT = "+node";
+var asRecord2 = /* @__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 = asRecord2(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",
+  "PrefabInstance",
+  "EntityType",
+  "Selectable",
+  "SelectionTransformState"
+]);
+var OVERRIDE_ROOT_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
+  "TransformComponent",
+  "Name",
+  "ParentId"
+]);
+var asRecord3 = /* @__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 = asRecord3(value);
+  return Boolean(
+    record && typeof record.$node === "string" && Object.keys(record).length === 1
+  );
+}, "isNodeRef");
+var makeNodeRef = /* @__PURE__ */ __name((nodeId) => ({ $node: nodeId }), "makeNodeRef");
+function findSnapshotRootEntityIds(snapshot) {
+  const parentBlock = snapshot.components.find(
+    (block) => block.component === "ParentId"
+  );
+  const parentByEntity = /* @__PURE__ */ new Map();
+  for (const entry of parentBlock?.entries ?? []) {
+    parentByEntity.set(entry.entityId, asRecord3(entry.value)?.value ?? null);
+  }
+  return snapshot.entities.filter(
+    (entityId) => typeof parentByEntity.get(entityId) !== "number"
+  );
+}
+__name(findSnapshotRootEntityIds, "findSnapshotRootEntityIds");
+function buildNodeMapsFromSnapshot(snapshot) {
+  const idToNode = /* @__PURE__ */ new Map();
+  const nodeToId = /* @__PURE__ */ new Map();
+  const nodeBlock = snapshot.components.find(
+    (block) => block.component === "PrefabNode"
+  );
+  for (const entry of nodeBlock?.entries ?? []) {
+    const nodeId = asRecord3(entry.value)?.nodeId;
+    if (typeof nodeId === "string" && nodeId.length > 0) {
+      idToNode.set(entry.entityId, nodeId);
+      nodeToId.set(nodeId, entry.entityId);
+    }
+  }
+  const rootEntityId = findSnapshotRootEntityIds(snapshot)[0];
+  const rootNodeId = rootEntityId !== void 0 ? idToNode.get(rootEntityId) ?? null : null;
+  return { idToNode, nodeToId, rootNodeId };
+}
+__name(buildNodeMapsFromSnapshot, "buildNodeMapsFromSnapshot");
+function indexSnapshotByEntity(snapshot) {
+  const byEntity = /* @__PURE__ */ new Map();
+  for (const block of snapshot.components) {
+    for (const entry of block.entries) {
+      let componentMap = byEntity.get(entry.entityId);
+      if (!componentMap) {
+        componentMap = /* @__PURE__ */ new Map();
+        byEntity.set(entry.entityId, componentMap);
+      }
+      componentMap.set(block.component, entry.value);
+    }
+  }
+  return byEntity;
+}
+__name(indexSnapshotByEntity, "indexSnapshotByEntity");
+var toRefOrRaw = /* @__PURE__ */ __name((id, idToNode) => {
+  const nodeId = idToNode.get(id);
+  return nodeId !== void 0 ? makeNodeRef(nodeId) : id;
+}, "toRefOrRaw");
+function canonicalizeScriptDataFields(data, idToNode) {
+  const canonicalData = {};
+  for (const [key, fieldValue] of Object.entries(data)) {
+    const field = asRecord3(fieldValue);
+    if (field?.type === "entity" && typeof field.value === "number") {
+      canonicalData[key] = {
+        ...field,
+        value: toRefOrRaw(field.value, idToNode)
+      };
+      continue;
+    }
+    const componentRef = asRecord3(field?.value);
+    if (field?.type === "component" && componentRef && typeof componentRef.entityId === "number") {
+      canonicalData[key] = {
+        ...field,
+        value: {
+          ...componentRef,
+          entityId: toRefOrRaw(componentRef.entityId, idToNode)
+        }
+      };
+      continue;
+    }
+    canonicalData[key] = fieldValue;
+  }
+  return canonicalData;
+}
+__name(canonicalizeScriptDataFields, "canonicalizeScriptDataFields");
+function canonicalizeComponentValue(componentName, value, idToNode) {
+  const cloned = clone(value);
+  const record = asRecord3(cloned);
+  if (!record) {
+    return cloned;
+  }
+  if (componentName === "ParentId") {
+    if (typeof record.value === "number") {
+      record.value = toRefOrRaw(record.value, idToNode);
+    }
+    return record;
+  }
+  if (componentName === "Object3DRef") {
+    return {
+      visibility: typeof record.visibility === "boolean" ? record.visibility : true
+    };
+  }
+  if (componentName === "ScriptComponent") {
+    const entries = Array.isArray(record.entries) ? record.entries : [];
+    return {
+      entries: entries.map((rawEntry) => {
+        const entry = asRecord3(rawEntry);
+        if (!entry) {
+          return rawEntry;
+        }
+        return {
+          className: typeof entry.className === "string" ? entry.className : "",
+          scriptUrl: typeof entry.scriptUrl === "string" ? entry.scriptUrl : "",
+          enabled: typeof entry.enabled === "boolean" ? entry.enabled : true,
+          data: canonicalizeScriptDataFields(asRecord3(entry.data) ?? {}, idToNode)
+        };
+      })
+    };
+  }
+  if (componentName === "ScriptObjectComponent") {
+    return {
+      scriptUrl: typeof record.scriptUrl === "string" ? record.scriptUrl : null,
+      className: typeof record.className === "string" ? record.className : null,
+      enabled: typeof record.enabled === "boolean" ? record.enabled : true,
+      data: canonicalizeScriptDataFields(asRecord3(record.data) ?? {}, idToNode)
+    };
+  }
+  if (componentName === "InstancedMeshComponent") {
+    if (Array.isArray(record.instanceEntityIds)) {
+      record.instanceEntityIds = record.instanceEntityIds.map(
+        (id) => typeof id === "number" ? toRefOrRaw(id, idToNode) : id
+      );
+    }
+    return record;
+  }
+  if (componentName === "IKComponent") {
+    if (Array.isArray(record.chains)) {
+      record.chains = record.chains.map((rawChain) => {
+        const chain = asRecord3(rawChain);
+        if (!chain) return rawChain;
+        for (const key of ["target", "pole"]) {
+          if (typeof chain[key] === "number") chain[key] = toRefOrRaw(chain[key], idToNode);
+        }
+        return chain;
+      });
+    }
+    return record;
+  }
+  if (componentName === "InstanceSlotComponent") {
+    if (typeof record.groupEntityId === "number" && record.groupEntityId !== -1) {
+      record.groupEntityId = toRefOrRaw(record.groupEntityId, idToNode);
+    }
+    return record;
+  }
+  return record;
+}
+__name(canonicalizeComponentValue, "canonicalizeComponentValue");
+function decanonicalizeComponentValue(value, nodeToId) {
+  if (isNodeRef(value)) {
+    return nodeToId.get(value.$node) ?? null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => decanonicalizeComponentValue(item, nodeToId));
+  }
+  const record = asRecord3(value);
+  if (record) {
+    const result = {};
+    for (const [key, item] of Object.entries(record)) {
+      result[key] = decanonicalizeComponentValue(item, nodeToId);
+    }
+    return result;
+  }
+  return value;
+}
+__name(decanonicalizeComponentValue, "decanonicalizeComponentValue");
+var encodeOverride = /* @__PURE__ */ __name((nodeId, componentName, path) => `${nodeId}|${componentName}|${path}`, "encodeOverride");
+function parseOverride(encoded) {
+  const firstSep = encoded.indexOf("|");
+  if (firstSep <= 0) {
+    return null;
+  }
+  const secondSep = encoded.indexOf("|", firstSep + 1);
+  if (secondSep <= firstSep + 1) {
+    return null;
+  }
+  return {
+    nodeId: encoded.slice(0, firstSep),
+    componentName: encoded.slice(firstSep + 1, secondSep),
+    path: encoded.slice(secondSep + 1)
+  };
+}
+__name(parseOverride, "parseOverride");
+function groupOverridePaths(overrides) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const encoded of overrides) {
+    const parsed = parseOverride(encoded);
+    if (!parsed) {
+      continue;
+    }
+    let byComponent = grouped.get(parsed.nodeId);
+    if (!byComponent) {
+      byComponent = /* @__PURE__ */ new Map();
+      grouped.set(parsed.nodeId, byComponent);
+    }
+    let paths = byComponent.get(parsed.componentName);
+    if (!paths) {
+      paths = /* @__PURE__ */ new Set();
+      byComponent.set(parsed.componentName, paths);
+    }
+    paths.add(parsed.path);
+  }
+  return grouped;
+}
+__name(groupOverridePaths, "groupOverridePaths");
+var isPrimitive = /* @__PURE__ */ __name((value) => value === null || typeof value !== "object", "isPrimitive");
+function collectDiffPaths(base, current, prefix = "", out = []) {
+  if (isNodeRef(base) || isNodeRef(current)) {
+    const same = isNodeRef(base) && isNodeRef(current) && base.$node === current.$node;
+    if (!same) {
+      out.push(prefix);
+    }
+    return out;
+  }
+  if (isPrimitive(base) || isPrimitive(current)) {
+    if (base !== current) {
+      out.push(prefix);
+    }
+    return out;
+  }
+  const baseIsArray = Array.isArray(base);
+  const currentIsArray = Array.isArray(current);
+  if (baseIsArray !== currentIsArray) {
+    out.push(prefix);
+    return out;
+  }
+  if (baseIsArray && currentIsArray) {
+    if (base.length !== current.length) {
+      out.push(prefix);
+      return out;
+    }
+    base.forEach((item, index) => {
+      collectDiffPaths(
+        item,
+        current[index],
+        prefix ? `${prefix}/${index}` : String(index),
+        out
+      );
+    });
+    return out;
+  }
+  const baseRecord = base;
+  const currentRecord = current;
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(baseRecord),
+    ...Object.keys(currentRecord)
+  ]);
+  for (const key of keys) {
+    const childPrefix = prefix ? `${prefix}/${key}` : key;
+    if (!(key in baseRecord) || !(key in currentRecord)) {
+      out.push(childPrefix);
+      continue;
+    }
+    collectDiffPaths(baseRecord[key], currentRecord[key], childPrefix, out);
+  }
+  return out;
+}
+__name(collectDiffPaths, "collectDiffPaths");
+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 [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);
+    const instanceComponents = instanceByEntity.get(instanceEntityId);
+    if (!baseComponents) {
+      continue;
+    }
+    const isRoot = nodeKey === baseMaps.rootKey;
+    for (const [componentName, baseRaw] of baseComponents) {
+      if (OVERRIDE_DIFF_EXCLUDED_COMPONENTS.has(componentName)) {
+        continue;
+      }
+      if (isRoot && OVERRIDE_ROOT_EXCLUDED_COMPONENTS.has(componentName)) {
+        continue;
+      }
+      const instanceRaw = instanceComponents?.get(componentName);
+      if (instanceRaw === void 0) {
+        continue;
+      }
+      const baseCanonical = canonicalizeComponentValue(
+        componentName,
+        baseRaw,
+        baseMaps.idToKey
+      );
+      const instanceCanonical = canonicalizeComponentValue(
+        componentName,
+        instanceRaw,
+        instanceMaps.idToKey
+      );
+      for (const path of collectDiffPaths(baseCanonical, instanceCanonical)) {
+        overrides.push(encodeOverride(nodeKey, componentName, path));
+      }
+    }
+  }
+  return overrides;
+}
+__name(computeInstanceOverrides, "computeInstanceOverrides");
+var PATH_TOKEN_SPLIT = "/";
+function getAtPath(value, tokens) {
+  let cursor = value;
+  for (const token of tokens) {
+    if (Array.isArray(cursor)) {
+      cursor = cursor[Number(token)];
+    } else {
+      const record = asRecord3(cursor);
+      if (!record) {
+        return void 0;
+      }
+      cursor = record[token];
+    }
+    if (cursor === void 0) {
+      return void 0;
+    }
+  }
+  return cursor;
+}
+__name(getAtPath, "getAtPath");
+function setAtPath(target, tokens, value) {
+  let cursor = target;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const token = tokens[i];
+    if (Array.isArray(cursor)) {
+      cursor = cursor[Number(token)];
+    } else {
+      const record = asRecord3(cursor);
+      if (!record) {
+        return;
+      }
+      cursor = record[token];
+    }
+    if (cursor === null || typeof cursor !== "object") {
+      return;
+    }
+  }
+  const last = tokens[tokens.length - 1];
+  if (Array.isArray(cursor)) {
+    cursor[Number(last)] = value;
+  } else {
+    const record = asRecord3(cursor);
+    if (record) {
+      if (value === void 0) {
+        delete record[last];
+      } else {
+        record[last] = value;
+      }
+    }
+  }
+}
+__name(setAtPath, "setAtPath");
+function mergeComponentValue(newFileCanonical, instanceCanonical, overridePaths) {
+  if (!overridePaths || overridePaths.size === 0) {
+    return clone(newFileCanonical);
+  }
+  if (overridePaths.has("")) {
+    return clone(instanceCanonical);
+  }
+  const merged = clone(newFileCanonical);
+  for (const path of overridePaths) {
+    const tokens = path.split(PATH_TOKEN_SPLIT);
+    const instanceValue = getAtPath(instanceCanonical, tokens);
+    setAtPath(merged, tokens, clone(instanceValue));
+  }
+  return merged;
+}
+__name(mergeComponentValue, "mergeComponentValue");
+
+// core/prefab/instantiateSubtree.ts
+var INSTANTIATE_EXCLUDED_COMPONENTS = /* @__PURE__ */ new Set([
+  "Environment",
+  "Postprocessing",
+  "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)).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,
+    world,
+    objectManagementSystem,
+    { assignPrimaryCamera: false, applyTransformsScope: "created" }
+  );
+  const rootSourceId = findSnapshotRootEntityIds(safeSnapshot).find(
+    (sourceId) => result.idMap.has(sourceId)
+  );
+  return {
+    rootId: rootSourceId !== void 0 ? result.idMap.get(rootSourceId) ?? null : null,
+    idMap: result.idMap
+  };
+}
+__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)) {
+    return null;
+  }
+  if (typeof json.version !== "number" || json.version < 1) {
+    return null;
+  }
+  const snapshot = json.snapshot;
+  if (!isRecord(snapshot)) {
+    return null;
+  }
+  const entities = snapshot.entities;
+  const components = snapshot.components;
+  if (!Array.isArray(entities) || !Array.isArray(components)) {
+    return null;
+  }
+  if (!entities.every((id) => typeof id === "number")) {
+    return null;
+  }
+  if (!components.every(
+    (block) => isRecord(block) && typeof block.component === "string" && Array.isArray(block.entries)
+  )) {
+    return null;
+  }
+  return {
+    version: json.version,
+    type: json.type === "scene" ? "scene" : "prefab",
+    name: typeof json.name === "string" ? json.name : void 0,
+    snapshot
+  };
+}
+__name(parsePrefabAsset, "parsePrefabAsset");
+
+// core/prefab/spawnPrefab.ts
+var prefabAssetUrlResolver = null;
+function setPrefabAssetUrlResolver(resolver) {
+  prefabAssetUrlResolver = resolver;
+}
+__name(setPrefabAssetUrlResolver, "setPrefabAssetUrlResolver");
+var resolvePrefabAssetUrl = /* @__PURE__ */ __name((url) => prefabAssetUrlResolver ? prefabAssetUrlResolver(url) : url, "resolvePrefabAssetUrl");
+var resolveUrl = resolvePrefabAssetUrl;
+function transformStringsDeep(value, fn) {
+  if (typeof value === "string") {
+    return fn(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => transformStringsDeep(item, fn));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = transformStringsDeep(item, fn);
+    }
+    return result;
+  }
+  return value;
+}
+__name(transformStringsDeep, "transformStringsDeep");
+var prefabCache = /* @__PURE__ */ new Map();
+function loadPrefab(url) {
+  const cached = prefabCache.get(url);
+  if (cached) {
+    return cached;
+  }
+  const pending = (async () => {
+    const response = await fetch(resolveUrl(url));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch prefab "${url}" (${response.status})`);
+    }
+    const json = await response.json();
+    const parsed = parsePrefabAsset(json);
+    if (!parsed) {
+      throw new Error(`Invalid prefab file at "${url}"`);
+    }
+    return {
+      ...parsed,
+      snapshot: transformStringsDeep(
+        parsed.snapshot,
+        resolveUrl
+      )
+    };
+  })();
+  prefabCache.set(url, pending);
+  pending.catch(() => {
+    if (prefabCache.get(url) === pending) {
+      prefabCache.delete(url);
+    }
+  });
+  return pending;
+}
+__name(loadPrefab, "loadPrefab");
+function clearPrefabCache(url) {
+  if (typeof url === "string") {
+    prefabCache.delete(url);
+  } else {
+    prefabCache.clear();
+  }
+}
+__name(clearPrefabCache, "clearPrefabCache");
+function resolveSource(source) {
+  if (typeof source === "string") {
+    return { url: source, asset: loadPrefab(source) };
+  }
+  if ("path" in source && typeof source.path === "string") {
+    return { url: source.path, asset: loadPrefab(source.path) };
+  }
+  const asset = source;
+  return { url: asset.name ?? "", asset };
+}
+__name(resolveSource, "resolveSource");
+async function spawnPrefab(world, source, options) {
+  const { url, asset } = resolveSource(source);
+  const prefab = await asset;
+  const objectManagementSystem = world.getObjectManagementSystem();
+  const { rootId } = instantiateSubtree(
+    world,
+    objectManagementSystem,
+    prefab.snapshot
+  );
+  if (rootId === null) {
+    throw new Error(
+      `Prefab "${url || prefab.name || "unknown"}" contained no spawnable entities`
+    );
+  }
+  if (!world.getComponent(rootId, PrefabInstance)) {
+    world.addComponent(rootId, new PrefabInstance(url, []));
+  }
+  if (options?.parentId !== void 0 && options.parentId !== null) {
+    objectManagementSystem.setParent(world, rootId, options.parentId, {
+      preserveWorldTransform: false
+    });
+  }
+  const transform = world.getComponent(rootId, TransformComponent);
+  if (transform && (options?.position || options?.rotation || options?.scale)) {
+    const write = /* @__PURE__ */ __name((target, src) => {
+      if (!src) return;
+      if (typeof src.x === "number") target.x = src.x;
+      if (typeof src.y === "number") target.y = src.y;
+      if (typeof src.z === "number") target.z = src.z;
+    }, "write");
+    write(transform.position, options.position);
+    write(transform.rotation, options.rotation);
+    write(transform.scale, options.scale);
+    const object = world.getComponent(rootId, Object3DRef)?.object;
+    if (object) {
+      applyTransform(object, transform);
+      object.updateMatrixWorld(true);
+    }
+  }
+  return rootId;
+}
+__name(spawnPrefab, "spawnPrefab");
+function despawnPrefab(world, rootId, dispose = true) {
+  const objectManagementSystem = world.getObjectManagementSystem();
+  const subtree = collectEntitySubtree(world, [rootId]).reverse();
+  let removed = 0;
+  for (const entityId of subtree) {
+    if (objectManagementSystem.deleteEntity(world, entityId, dispose)) {
+      removed += 1;
+    }
+  }
+  return removed;
+}
+__name(despawnPrefab, "despawnPrefab");
+var _Behaviour = class _Behaviour {
+  /**
+   * Engine-managed constructor. Hosts (`ScriptBehaviourSystem`) instantiate
+   * subclasses with the owning world, the entity id, and the script's `data`
+   * payload. User code should not call this directly.
+   *
+   * @param world - The owning ECS world.
+   * @param entityId - The entity this script is bound to.
+   * @param component - The `ScriptComponent.data` payload, or any object that
+   *   should be exposed to the script as `this.data`.
+   */
+  constructor(world, entityId, component) {
+    /**
+     * Inspector-bound payload from the entity's `ScriptComponent`. Override the
+     * type on subclasses with `declare data: MyDataShape` to get type safety
+     * inside hooks. Saved with the project so values persist across reloads.
+     */
+    this.data = {};
+    /**
+     * Seconds elapsed since the last frame. Set by the engine before each
+     * {@link Behaviour.onUpdate}.
+     */
+    this.deltaTime = 0;
+    this.world = world;
+    this.entityId = entityId;
+    if (component) this.data = component;
+    this.entity = this.getEntity();
+    this.threeRef = this.getComponent(Object3DRef);
+    this.transform = this.getComponent(TransformComponent);
+  }
+  /**
+   * Engine-managed per-frame entry point. Refreshes {@link Behaviour.deltaTime}
+   * and delegates to {@link Behaviour.onUpdate}.
+   *
+   * @remarks Do **not** override this method — override
+   * {@link Behaviour.onUpdate} instead.
+   *
+   * @param world - The owning world (may differ from the constructor world
+   *   after hot reload).
+   * @param deltaTime - Seconds since the last frame.
+   */
+  update(world, deltaTime) {
+    this.deltaTime = deltaTime;
+    this.world = world;
+    this.onUpdate();
+  }
+  /**
+   * Optional cleanup hook invoked when the script is detached or the entity
+   * is destroyed. Override to release timers, listeners, or other resources.
+   *
+   * @param world - The owning world at disposal time.
+   */
+  dispose(world) {
+  }
+  /**
+   * Instantiate a prefab asset into the world at runtime.
+   *
+   * `source` is typically an `AssetInput` field from this script's `data`
+   * (drag a `.prefab` from the asset browser onto the field in the editor),
+   * a URL string, or a pre-loaded `PrefabAsset`. Resolves with the new root
+   * entity id.
+   *
+   * ```ts
+   * data = { enemyPrefab: { path: "", type: "prefab" } };
+   * async onUpdate() {
+   *   if (shouldSpawn) {
+   *     const id = await this.spawnPrefab(this.data.enemyPrefab, {
+   *       position: { x: 0, y: 0, z: -5 },
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  spawnPrefab(source, options) {
+    return spawnPrefab(this.world, source, options);
+  }
+  /**
+   * The shared world, or `null` in a single-player run, so a script can work
+   * both ways:
+   *
+   * ```ts
+   * if (this.network && !this.network.isOwner) return; // someone else moves this
+   * ```
+   */
+  get network() {
+    return this.world.getNetwork()?.handleFor(this.entityId) ?? null;
+  }
+  /** Someone joined the room. `playerId` is their session id. */
+  onPlayerJoin(_playerId) {
+  }
+  /** Someone left the room. */
+  onPlayerLeave(_playerId) {
+  }
+  /** A shared value on this entity changed. */
+  onNetworkProp(_key, _value) {
+  }
+  /**
+   * Load a `.soundbank.json` asset so {@link Behaviour.playSlot} can play it.
+   * `source` is an asset path or an `AssetInput` field.
+   */
+  loadSoundBank(source) {
+    return this.world.getAudioSystem()?.loadSoundBank(source) ?? Promise.resolve();
+  }
+  /**
+   * Play a named sound from a loaded bank, as a random take. Returns whether it
+   * sounded: its chance, cooldown or priority may keep it quiet.
+   *
+   * ```ts
+   * this.playSlot("hit", { position: this.transform.position });
+   * ```
+   */
+  playSlot(id, options) {
+    return this.world.getAudioSystem()?.playSlot(id, options) ?? false;
+  }
+  /**
+   * Remove a spawned prefab instance (the root entity and all descendants).
+   * Returns the number of entities removed.
+   */
+  despawn(rootEntityId) {
+    return despawnPrefab(this.world, rootEntityId);
+  }
+  /**
+   * Returns the entity's world-space position as a new `THREE.Vector3`, or
+   * `null` if the entity has no scene presence.
+   */
+  getWorldPosition() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const position = new THREE.Vector3();
+    this.threeRef.object.getWorldPosition(position);
+    return position;
+  }
+  /**
+   * Returns the entity's forward direction in world space (the +Z axis of its
+   * world matrix), or `null` if the entity has no scene presence.
+   */
+  getWorldDirection() {
+    if (!this.threeRef) {
+      return null;
+    }
+    const target = new THREE.Vector3();
+    this.threeRef.object.getWorldDirection(target);
+    return target;
+  }
+  /**
+   * Returns a unit vector pointing from this entity toward the given world
+   * position, or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  directionTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return targetPosition.clone().sub(currentPosition).normalize();
+  }
+  /**
+   * Returns the world-space distance from this entity to the given position,
+   * or `null` if the entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   */
+  distanceTo(targetPosition) {
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return null;
+    }
+    return currentPosition.distanceTo(targetPosition);
+  }
+  /**
+   * Linearly interpolates the entity's position toward `targetPosition` and
+   * writes the result back through {@link TransformComponent}. No-op if the
+   * entity has no scene presence.
+   *
+   * @param targetPosition - Destination point in world space.
+   * @param alpha - Interpolation factor in [0, 1]. Multiply by `deltaTime`
+   *   for frame-rate-independent smoothing.
+   */
+  lerpTo(targetPosition, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const currentPosition = this.getWorldPosition();
+    if (!currentPosition) {
+      return;
+    }
+    const newPosition = currentPosition.lerp(targetPosition, alpha);
+    this.transform.setPosition(newPosition);
+  }
+  /**
+   * Spherically interpolates the entity's rotation toward `targetRotation`
+   * and writes the result back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetRotation - Destination orientation as a quaternion.
+   * @param alpha - Interpolation factor in [0, 1].
+   */
+  slerpTo(targetRotation, alpha) {
+    if (!this.threeRef) {
+      return;
+    }
+    const rotation = new THREE.Quaternion();
+    this.threeRef.object.getWorldQuaternion(rotation);
+    rotation.slerp(targetRotation, alpha);
+    this.transform.setRotation(rotation);
+  }
+  /**
+   * Rotates the entity to face `targetPosition` in world space and writes the
+   * resulting orientation back through {@link TransformComponent}. No-op if
+   * the entity has no scene presence.
+   *
+   * @param targetPosition - Point in world space to face.
+   */
+  lookAt(targetPosition) {
+    if (!this.threeRef) {
+      return;
+    }
+    const clone2 = this.threeRef.object.clone();
+    const rotation = new THREE.Quaternion();
+    clone2.lookAt(targetPosition);
+    clone2.getWorldQuaternion(rotation);
+    this.transform.setRotation(rotation);
+  }
+  /** Returns every component currently attached to this entity. */
+  getComponents() {
+    return this.world.getEntityById(this.entityId)?.components ?? [];
+  }
+  /**
+   * Returns the entity's component of the given class, or `null` if it has
+   * no such component.
+   *
+   * @typeParam T - Concrete component type.
+   * @param componentClass - Component class constructor to look up.
+   *
+   * @example
+   * ```ts
+   * const mesh = this.getComponent(MeshComponent);
+   * if (mesh) console.log(mesh.geometryRef);
+   * ```
+   */
+  getComponent(componentClass) {
+    return this.world.getComponent(this.entityId, componentClass) ?? null;
+  }
+  /**
+   * Returns the latest {@link WorldEntityView} snapshot for this entity, or
+   * `null` if it was destroyed.
+   */
+  getEntity() {
+    return this.world.getEntityById(this.entityId);
+  }
+  /**
+   * Resolves the entity's parent from the {@link ParentId} component, if any.
+   *
+   * @returns A {@link ParentLookup} with the parent component reference and
+   *   the parent entity view (or `null` if the entity is at the root).
+   */
+  getParent() {
+    const parentIdComponent = this.getComponent(ParentId);
+    const parentEntityId = parentIdComponent?.value ?? null;
+    if (parentEntityId === null) {
+      return {
+        parentIdComponent,
+        parent: null
+      };
+    }
+    return {
+      parentIdComponent,
+      parent: this.world.getEntityById(parentEntityId)
+    };
+  }
+  /**
+   * Returns every direct child entity of this one (entities whose
+   * {@link ParentId} matches `entityId`).
+   */
+  getChildren() {
+    return this.world.getAllEntities().filter((entity) => {
+      const parentIdComponent = entity.components.find(
+        (component) => component instanceof ParentId
+      );
+      return parentIdComponent?.value === this.entityId;
+    });
+  }
+  /**
+   * Called once before the first {@link Behaviour.onUpdate}. Override to
+   * default and validate {@link Behaviour.data}, cache references, or set
+   * initial state. Runs at preview/runtime only — never in the editor.
+   */
+  init() {
+  }
+  /**
+   * Called every frame while the script is enabled. Override with the
+   * script's main per-frame logic. Runs at preview/runtime only — never in the
+   * editor (use {@link ScriptObject} for editor-visible visuals).
+   */
+  onUpdate() {
+  }
+  /** Called when the editor selects this entity. Optional UX hook. */
+  onSelect() {
+  }
+  /** Called when the editor deselects this entity. Optional UX hook. */
+  onDeselect() {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on becomes
+   * visible. Optional AR hook.
+   *
+   * @param target - The newly-visible target entity view.
+   */
+  onTargetFound(target) {
+  }
+  /**
+   * Called when an image-tracking target this entity depends on is lost.
+   * Optional AR hook.
+   *
+   * @param target - The target entity view that became invisible.
+   */
+  onTargetLost(target) {
+  }
+  // ─── WebXR (VR / MR) hooks ────────────────────────────────────────────────
+  // Dispatched by XRSessionSystem / XRInteractionSystem, following the same
+  // pattern as the AR hooks above: public no-op methods that subclasses opt
+  // into by overriding. They never fire outside an immersive session.
+  /**
+   * Called once when an immersive session starts. Optional XR hook.
+   *
+   * Use it to set up XR-only state. Inspect `capabilities` rather than guessing
+   * by device: feature support differs sharply per headset (for example Vision
+   * Pro grants no passthrough on the web today).
+   *
+   * @param capabilities - What the session actually granted, read from
+   *   `XRSession.enabledFeatures`.
+   */
+  onXRSessionStart(capabilities) {
+  }
+  /** Called once when the immersive session ends. Optional XR hook. */
+  onXRSessionEnd() {
+  }
+  /**
+   * Called when a primary action begins — controller trigger, hand pinch, or
+   * Vision Pro gaze-pinch. Optional XR hook.
+   *
+   * @param input - Normalized state for the source that acted.
+   */
+  onSelectStart(input) {
+  }
+  /** Called when the primary action ends. Optional XR hook. */
+  onSelectEnd(input) {
+  }
+  /**
+   * Called when this entity is grabbed. Optional XR hook.
+   *
+   * Only fires for entities carrying an enabled, grabbable
+   * `XRInteractableComponent`.
+   *
+   * @param input - The source doing the grabbing.
+   */
+  /**
+   * A SECOND hand joined a two-hand grab on this entity.
+   *
+   * The first hand anchors the object and keeps holding it; this fires for the
+   * hand that came second — the foregrip on a rifle, say.
+   */
+  onSecondaryGrab(_input) {
+  }
+  /** The second hand let go, leaving the object in the first hand alone. */
+  onSecondaryRelease(_input) {
+  }
+  /**
+   * A hand pose declared on this entity started being held.
+   *
+   * Fires once the pose has been sustained for its hold time, not the instant
+   * the fingers pass through it.
+   */
+  onHandPoseStart(_event) {
+  }
+  /** A held hand pose ended, or its hand stopped being tracked. */
+  onHandPoseEnd(_event) {
+  }
+  onGrab(input) {
+  }
+  /** Called when this entity is released. Optional XR hook. */
+  onRelease(input) {
+  }
+  /** A UI button on this entity (or a descendant) was clicked. Clicks fire on
+   * RELEASE while still pointing at the widget — sliding off cancels. */
+  onUiPress(_event) {
+  }
+  /** A pointer began hovering a UI widget on this entity (or a descendant). */
+  onUiHoverStart(_event) {
+  }
+  /** The pointer left the widget. */
+  onUiHoverEnd(_event) {
+  }
+  /** A UI toggle flipped; `event.value` is the new boolean. */
+  onUiToggle(_event) {
+  }
+  /** A UI slider moved; `event.value` is the new number. Fires on real value
+   * changes during the drag and once more on release. */
+  onUiChange(_event) {
+  }
+};
+__name(_Behaviour, "Behaviour");
+/**
+ * Static marker used by `ScriptBehaviourSystem` to detect `Behaviour`
+ * subclasses across bundle-identity splits (esbuild may produce a second
+ * copy of the package when scripts are bundled, breaking `instanceof`).
+ * Inherited by every subclass via the prototype chain.
+ *
+ * @internal
+ */
+_Behaviour.__reluBehaviourClass = true;
+var Behaviour = _Behaviour;
+
+export { ADDED_NODE_MARKER_COMPONENT, Behaviour, HYDRATABLE_ENTITY_KINDS, NODE_KEY_SEPARATOR, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeInstanceOverrides, decanonicalizeComponentValue, defaultModuleLoader, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, mergeDataByCurrentDefaults, normalizeScriptData, parseOverride, parsePrefabAsset, prefabFileVersionFor, readScriptPhase, reportBehaviourHookError, reportScriptError, resolveInputData, resolvePrefabAssetUrl, resolveScriptCtor, restoreComponentState, restorePostCreateComponents, serializeDataForStorage, setPrefabAssetUrlResolver, spawnPrefab, toErrorMessage, toErrorStack, withScriptPhase };
+//# sourceMappingURL=chunk-WWP46AEF.js.map
+//# sourceMappingURL=chunk-WWP46AEF.js.map