@ggez/three-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,2805 @@
+// ../shared/src/utils.ts
+import { Euler, Matrix4, Quaternion, Vector3 } from "three";
+function createBlockoutTextureDataUri(color, edgeColor = "#f5f2ea", edgeThickness = 0.018) {
+  const size = 256;
+  const frame = Math.max(2, Math.min(6, Math.round(size * edgeThickness)));
+  const innerInset = frame + 3;
+  const seamInset = innerInset + 5;
+  const corner = 18;
+  const highlight = mixHexColors(edgeColor, "#ffffff", 0.42);
+  const frameColor = mixHexColors(edgeColor, color, 0.12);
+  const innerShadow = mixHexColors(edgeColor, color, 0.28);
+  const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}">
+      <rect width="${size}" height="${size}" rx="${corner}" fill="${color}" />
+      <rect x="${frame / 2}" y="${frame / 2}" width="${size - frame}" height="${size - frame}" rx="${corner - 2}" fill="none" stroke="${frameColor}" stroke-width="${frame}" />
+      <rect x="${innerInset}" y="${innerInset}" width="${size - innerInset * 2}" height="${size - innerInset * 2}" rx="${corner - 5}" fill="none" stroke="${highlight}" stroke-opacity="0.42" stroke-width="1" />
+      <rect x="${seamInset}" y="${seamInset}" width="${size - seamInset * 2}" height="${size - seamInset * 2}" rx="${corner - 9}" fill="none" stroke="${innerShadow}" stroke-opacity="0.12" stroke-width="1" />
+      <path d="M ${innerInset} ${size * 0.28} H ${size - innerInset}" stroke="${highlight}" stroke-opacity="0.08" stroke-width="1" />
+      <path d="M ${size * 0.28} ${innerInset} V ${size - innerInset}" stroke="${highlight}" stroke-opacity="0.06" stroke-width="1" />
+    </svg>
+  `.trim();
+  return `data:image/svg+xml;charset=UTF-8,${encodeURIComponent(svg)}`;
+}
+function vec3(x, y, z) {
+  return { x, y, z };
+}
+function mixHexColors(left, right, t) {
+  const normalizedLeft = normalizeHex(left);
+  const normalizedRight = normalizeHex(right);
+  const leftValue = Number.parseInt(normalizedLeft.slice(1), 16);
+  const rightValue = Number.parseInt(normalizedRight.slice(1), 16);
+  const channels = [16, 8, 0].map((shift) => {
+    const leftChannel = leftValue >> shift & 255;
+    const rightChannel = rightValue >> shift & 255;
+    return Math.round(leftChannel + (rightChannel - leftChannel) * t).toString(16).padStart(2, "0");
+  });
+  return `#${channels.join("")}`;
+}
+function normalizeHex(color) {
+  if (/^#[0-9a-f]{6}$/i.test(color)) {
+    return color;
+  }
+  if (/^#[0-9a-f]{3}$/i.test(color)) {
+    return `#${color.slice(1).split("").map((channel) => `${channel}${channel}`).join("")}`;
+  }
+  return "#808080";
+}
+function addVec3(left, right) {
+  return vec3(left.x + right.x, left.y + right.y, left.z + right.z);
+}
+function subVec3(left, right) {
+  return vec3(left.x - right.x, left.y - right.y, left.z - right.z);
+}
+function scaleVec3(vector, scalar) {
+  return vec3(vector.x * scalar, vector.y * scalar, vector.z * scalar);
+}
+function dotVec3(left, right) {
+  return left.x * right.x + left.y * right.y + left.z * right.z;
+}
+function crossVec3(left, right) {
+  return vec3(
+    left.y * right.z - left.z * right.y,
+    left.z * right.x - left.x * right.z,
+    left.x * right.y - left.y * right.x
+  );
+}
+function lengthVec3(vector) {
+  return Math.sqrt(dotVec3(vector, vector));
+}
+function normalizeVec3(vector, epsilon = 1e-6) {
+  const length = lengthVec3(vector);
+  if (length <= epsilon) {
+    return vec3(0, 0, 0);
+  }
+  return scaleVec3(vector, 1 / length);
+}
+function averageVec3(vectors) {
+  if (vectors.length === 0) {
+    return vec3(0, 0, 0);
+  }
+  const total = vectors.reduce((sum, vector) => addVec3(sum, vector), vec3(0, 0, 0));
+  return scaleVec3(total, 1 / vectors.length);
+}
+var tempPosition = new Vector3();
+var tempQuaternion = new Quaternion();
+var tempScale = new Vector3();
+function composeTransforms(parent, child) {
+  const matrix = transformToMatrix(parent).multiply(transformToMatrix(child));
+  return matrixToTransform(matrix, child.pivot);
+}
+function resolveSceneGraph(nodes, entities = []) {
+  const nodeList = Array.from(nodes);
+  const entityList = Array.from(entities);
+  const nodesById = new Map(nodeList.map((node) => [node.id, node]));
+  const nodeWorldTransforms = /* @__PURE__ */ new Map();
+  const entityWorldTransforms = /* @__PURE__ */ new Map();
+  const nodeChildrenByParentId = /* @__PURE__ */ new Map();
+  const entityChildrenByParentId = /* @__PURE__ */ new Map();
+  const rootNodeIds = [];
+  const rootEntityIds = [];
+  const nodeStack = /* @__PURE__ */ new Set();
+  const appendNodeChild = (parentId, childId) => {
+    const children = nodeChildrenByParentId.get(parentId);
+    if (children) {
+      children.push(childId);
+      return;
+    }
+    nodeChildrenByParentId.set(parentId, [childId]);
+  };
+  const appendEntityChild = (parentId, childId) => {
+    const children = entityChildrenByParentId.get(parentId);
+    if (children) {
+      children.push(childId);
+      return;
+    }
+    entityChildrenByParentId.set(parentId, [childId]);
+  };
+  const resolveNodeTransform = (node) => {
+    const cached = nodeWorldTransforms.get(node.id);
+    if (cached) {
+      return cached;
+    }
+    if (nodeStack.has(node.id)) {
+      const fallback = structuredClone(node.transform);
+      nodeWorldTransforms.set(node.id, fallback);
+      return fallback;
+    }
+    nodeStack.add(node.id);
+    const parent = node.parentId && node.parentId !== node.id ? nodesById.get(node.parentId) : void 0;
+    const resolved = parent ? composeTransforms(resolveNodeTransform(parent), node.transform) : structuredClone(node.transform);
+    nodeWorldTransforms.set(node.id, resolved);
+    nodeStack.delete(node.id);
+    return resolved;
+  };
+  nodeList.forEach((node) => {
+    resolveNodeTransform(node);
+    const hasValidParent = Boolean(
+      node.parentId && node.parentId !== node.id && nodesById.has(node.parentId)
+    );
+    if (hasValidParent) {
+      appendNodeChild(node.parentId, node.id);
+      return;
+    }
+    rootNodeIds.push(node.id);
+  });
+  entityList.forEach((entity) => {
+    const parent = entity.parentId && nodesById.has(entity.parentId) ? nodesById.get(entity.parentId) : void 0;
+    entityWorldTransforms.set(
+      entity.id,
+      parent ? composeTransforms(resolveNodeTransform(parent), entity.transform) : structuredClone(entity.transform)
+    );
+    if (parent) {
+      appendEntityChild(parent.id, entity.id);
+      return;
+    }
+    rootEntityIds.push(entity.id);
+  });
+  return {
+    entityChildrenByParentId,
+    entityWorldTransforms,
+    nodeChildrenByParentId,
+    nodeWorldTransforms,
+    rootEntityIds,
+    rootNodeIds
+  };
+}
+function isBrushNode(node) {
+  return node.kind === "brush";
+}
+function isMeshNode(node) {
+  return node.kind === "mesh";
+}
+function isGroupNode(node) {
+  return node.kind === "group";
+}
+function isModelNode(node) {
+  return node.kind === "model";
+}
+function isPrimitiveNode(node) {
+  return node.kind === "primitive";
+}
+function isInstancingNode(node) {
+  return node.kind === "instancing";
+}
+function isInstancingSourceNode(node) {
+  return isBrushNode(node) || isMeshNode(node) || isPrimitiveNode(node) || isModelNode(node);
+}
+function resolveInstancingSourceNode(nodes, nodeOrId, maxDepth = 32) {
+  const nodesById = new Map(Array.from(nodes, (node) => [node.id, node]));
+  let current = typeof nodeOrId === "string" ? nodesById.get(nodeOrId) : nodeOrId;
+  let depth = 0;
+  while (current && depth <= maxDepth) {
+    if (isInstancingSourceNode(current)) {
+      return current;
+    }
+    if (!isInstancingNode(current)) {
+      return void 0;
+    }
+    current = nodesById.get(current.data.sourceNodeId);
+    depth += 1;
+  }
+  return void 0;
+}
+function transformToMatrix(transform) {
+  return new Matrix4().compose(
+    new Vector3(transform.position.x, transform.position.y, transform.position.z),
+    new Quaternion().setFromEuler(new Euler(transform.rotation.x, transform.rotation.y, transform.rotation.z, "XYZ")),
+    new Vector3(transform.scale.x, transform.scale.y, transform.scale.z)
+  );
+}
+function matrixToTransform(matrix, pivot) {
+  matrix.decompose(tempPosition, tempQuaternion, tempScale);
+  const rotation = new Euler().setFromQuaternion(tempQuaternion, "XYZ");
+  return {
+    pivot: pivot ? vec3(pivot.x, pivot.y, pivot.z) : void 0,
+    position: vec3(tempPosition.x, tempPosition.y, tempPosition.z),
+    rotation: vec3(rotation.x, rotation.y, rotation.z),
+    scale: vec3(tempScale.x, tempScale.y, tempScale.z)
+  };
+}
+
+// src/loader.ts
+import {
+  AmbientLight as AmbientLight2,
+  BackSide as BackSide2,
+  Box3 as Box32,
+  BoxGeometry as BoxGeometry2,
+  BufferGeometry as BufferGeometry2,
+  Color,
+  DirectionalLight as DirectionalLight2,
+  DoubleSide as DoubleSide2,
+  EquirectangularReflectionMapping,
+  Euler as Euler3,
+  Fog,
+  Float32BufferAttribute as Float32BufferAttribute2,
+  FrontSide as FrontSide2,
+  Group as Group2,
+  InstancedMesh as InstancedMesh2,
+  HemisphereLight as HemisphereLight2,
+  LOD as LOD2,
+  Matrix4 as Matrix43,
+  Mesh as Mesh2,
+  MeshStandardMaterial as MeshStandardMaterial2,
+  Object3D as Object3D2,
+  PointLight as PointLight2,
+  Quaternion as Quaternion3,
+  SRGBColorSpace as SRGBColorSpace2,
+  SpotLight as SpotLight2,
+  TextureLoader as TextureLoader2,
+  RepeatWrapping as RepeatWrapping2,
+  Vector3 as Vector33
+} from "three";
+import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { HDRLoader } from "three/examples/jsm/loaders/HDRLoader.js";
+import { MTLLoader as MTLLoader2 } from "three/examples/jsm/loaders/MTLLoader.js";
+import { OBJLoader as OBJLoader2 } from "three/examples/jsm/loaders/OBJLoader.js";
+
+// ../runtime-format/src/types.ts
+var RUNTIME_SCENE_FORMAT = "web-hammer-engine";
+var CURRENT_RUNTIME_SCENE_VERSION = 6;
+var MIN_RUNTIME_SCENE_VERSION = 4;
+
+// ../runtime-format/src/format.ts
+function isRuntimeScene(value) {
+  return validateRuntimeScene(value).ok;
+}
+function validateRuntimeScene(value) {
+  const errors = [];
+  if (!value || typeof value !== "object") {
+    return invalid("Runtime scene must be an object.");
+  }
+  const candidate = value;
+  if (candidate.metadata?.format !== RUNTIME_SCENE_FORMAT) {
+    errors.push(`Runtime scene metadata.format must be "${RUNTIME_SCENE_FORMAT}".`);
+  }
+  if (typeof candidate.metadata?.version !== "number") {
+    errors.push("Runtime scene metadata.version must be a number.");
+  } else if (candidate.metadata.version < MIN_RUNTIME_SCENE_VERSION) {
+    errors.push(`Runtime scene metadata.version must be >= ${MIN_RUNTIME_SCENE_VERSION}.`);
+  }
+  if (!Array.isArray(candidate.nodes)) {
+    errors.push("Runtime scene nodes must be an array.");
+  }
+  if (!Array.isArray(candidate.assets)) {
+    errors.push("Runtime scene assets must be an array.");
+  }
+  if (!Array.isArray(candidate.materials)) {
+    errors.push("Runtime scene materials must be an array.");
+  }
+  if (!Array.isArray(candidate.entities)) {
+    errors.push("Runtime scene entities must be an array.");
+  }
+  if (!Array.isArray(candidate.layers)) {
+    errors.push("Runtime scene layers must be an array.");
+  }
+  if (!candidate.settings || typeof candidate.settings !== "object") {
+    errors.push("Runtime scene settings must be an object.");
+  }
+  if (errors.length > 0) {
+    return {
+      errors,
+      ok: false
+    };
+  }
+  return {
+    errors: [],
+    ok: true,
+    value: candidate
+  };
+}
+function migrateRuntimeScene(scene) {
+  const migrated = structuredClone(scene);
+  migrated.metadata = {
+    ...migrated.metadata,
+    format: RUNTIME_SCENE_FORMAT,
+    version: CURRENT_RUNTIME_SCENE_VERSION
+  };
+  return migrated;
+}
+function parseRuntimeScene(text) {
+  const parsed = JSON.parse(text);
+  const validation = validateRuntimeScene(parsed);
+  if (!validation.ok) {
+    throw new Error(validation.errors.join(" "));
+  }
+  return migrateRuntimeScene(validation.value);
+}
+function isRuntimeBundle(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return Array.isArray(candidate.files) && isRuntimeScene(candidate.manifest);
+}
+function invalid(message) {
+  return {
+    errors: [message],
+    ok: false
+  };
+}
+
+// src/object-factory.ts
+import {
+  AmbientLight,
+  BackSide,
+  Box3,
+  BoxGeometry,
+  BufferGeometry,
+  DirectionalLight,
+  DoubleSide,
+  Euler as Euler2,
+  Float32BufferAttribute,
+  FrontSide,
+  Group,
+  HemisphereLight,
+  InstancedMesh,
+  LOD,
+  Matrix4 as Matrix42,
+  Mesh,
+  MeshStandardMaterial,
+  Object3D,
+  PointLight,
+  Quaternion as Quaternion2,
+  RepeatWrapping,
+  SRGBColorSpace,
+  SpotLight,
+  TextureLoader,
+  Vector3 as Vector32
+} from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MTLLoader } from "three/examples/jsm/loaders/MTLLoader.js";
+import { OBJLoader } from "three/examples/jsm/loaders/OBJLoader.js";
+var textureLoader = new TextureLoader();
+var gltfLoader = new GLTFLoader();
+var mtlLoader = new MTLLoader();
+var modelTextureLoader = new TextureLoader();
+var tempModelInstanceMatrix = new Matrix42();
+var tempModelChildMatrix = new Matrix42();
+var tempPivotMatrix = new Matrix42();
+var tempInstancePosition = new Vector32();
+var tempInstanceQuaternion = new Quaternion2();
+var tempInstanceScale = new Vector32();
+function createWebHammerSceneObjectFactory(engineScene, options = {}) {
+  const resources = {
+    assetsById: new Map(engineScene.assets.map((asset) => [asset.id, asset])),
+    materialCache: /* @__PURE__ */ new Map(),
+    modelTemplateCache: /* @__PURE__ */ new Map(),
+    textureCache: /* @__PURE__ */ new Map()
+  };
+  return {
+    createInstancingObjects: () => createInstancingObjects(engineScene, resources, options),
+    createNodeObject: (node, overrides) => createObjectForNode(node, resources, options, overrides)
+  };
+}
+var createThreeRuntimeObjectFactory = createWebHammerSceneObjectFactory;
+async function createObjectForNode(node, resources, options, overrides) {
+  const anchor = new Group();
+  const content = new Group();
+  const transform = overrides?.transform ?? node.transform;
+  const pivot = transform.pivot;
+  anchor.name = node.name;
+  applyTransform(anchor, transform);
+  anchor.userData.webHammer = {
+    data: node.data,
+    hooks: node.hooks,
+    id: node.id,
+    kind: node.kind,
+    metadata: node.metadata,
+    tags: node.tags
+  };
+  if (pivot) {
+    content.position.set(-pivot.x, -pivot.y, -pivot.z);
+  }
+  anchor.add(content);
+  if (node.kind === "light") {
+    const light = createThreeLight(node);
+    if (light) {
+      content.add(light);
+    }
+    return anchor;
+  }
+  if (node.kind === "group") {
+    return anchor;
+  }
+  if (node.kind === "instancing") {
+    anchor.visible = false;
+    return anchor;
+  }
+  if (node.kind === "model") {
+    const modelObject = await createModelObject(node, resources, options);
+    const lodObject2 = await createLodObjectForModelNode(node, modelObject, resources, options);
+    content.add(lodObject2 ?? modelObject);
+    return anchor;
+  }
+  const lodObject = await createLodObjectForGeometryNode(node, resources, options);
+  if (lodObject) {
+    content.add(lodObject);
+  }
+  return anchor;
+}
+async function createInstancingObjects(engineScene, resources, options) {
+  const sceneGraph = resolveSceneGraph(engineScene.nodes);
+  const batches = /* @__PURE__ */ new Map();
+  engineScene.nodes.forEach((node) => {
+    if (node.kind !== "instancing") {
+      return;
+    }
+    const sourceNode = resolveInstancingSourceNode(engineScene.nodes, node.data.sourceNodeId);
+    if (!sourceNode) {
+      return;
+    }
+    const instances = batches.get(sourceNode.id);
+    if (instances) {
+      instances.push(node);
+      return;
+    }
+    batches.set(sourceNode.id, [node]);
+  });
+  const objects = [];
+  for (const [sourceNodeId, instances] of batches) {
+    const sourceNode = resolveInstancingSourceNode(engineScene.nodes, sourceNodeId);
+    if (!sourceNode) {
+      continue;
+    }
+    const exportedSourceNode = engineScene.nodes.find((node) => node.id === sourceNode.id);
+    if (!exportedSourceNode || exportedSourceNode.kind === "group" || exportedSourceNode.kind === "instancing" || exportedSourceNode.kind === "light") {
+      continue;
+    }
+    const object = exportedSourceNode.kind === "model" ? await createInstancedObjectForModelNode(exportedSourceNode, instances, sceneGraph, resources, options) : await createInstancedObjectForGeometryNode(exportedSourceNode, instances, sceneGraph, resources, options);
+    if (object) {
+      objects.push(object);
+    }
+  }
+  return objects;
+}
+async function createInstancedObjectForGeometryNode(sourceNode, instances, sceneGraph, resources, options) {
+  const baseGroup = await createInstancedGeometryObject(sourceNode.geometry, sourceNode, instances, sceneGraph, resources, options);
+  const lodOptions = resolveSceneLodOptions(options.lod);
+  if (!lodOptions || !sourceNode.lods?.length) {
+    return baseGroup;
+  }
+  const lod = new LOD();
+  lod.name = `${sourceNode.name}:InstancingLOD`;
+  lod.autoUpdate = true;
+  lod.addLevel(baseGroup, 0);
+  for (const level of sourceNode.lods) {
+    const levelGroup = await createInstancedGeometryObject(
+      level.geometry,
+      sourceNode,
+      instances,
+      sceneGraph,
+      resources,
+      options,
+      level
+    );
+    const distance = level.level === "mid" ? lodOptions.midDistance : lodOptions.lowDistance;
+    lod.addLevel(levelGroup, distance);
+  }
+  lod.userData.webHammer = {
+    instanceNodeIds: instances.map((instance) => instance.id),
+    levelOrder: ["high", ...(sourceNode.lods ?? []).map((level) => level.level)],
+    sourceNodeId: sourceNode.id
+  };
+  return lod;
+}
+async function createInstancedGeometryObject(geometry, sourceNode, instances, sceneGraph, resources, options, lodLevel) {
+  const group = new Group();
+  const pivot = sourceNode.transform.pivot ?? vec3(0, 0, 0);
+  for (const primitive of geometry.primitives) {
+    const primitiveGeometry = new BufferGeometry();
+    primitiveGeometry.setAttribute("position", new Float32BufferAttribute(primitive.positions, 3));
+    primitiveGeometry.setAttribute("normal", new Float32BufferAttribute(primitive.normals, 3));
+    if (primitive.uvs.length > 0) {
+      primitiveGeometry.setAttribute("uv", new Float32BufferAttribute(primitive.uvs, 2));
+    }
+    primitiveGeometry.setIndex(primitive.indices);
+    primitiveGeometry.computeBoundingBox();
+    primitiveGeometry.computeBoundingSphere();
+    const material = await createThreeMaterial(primitive.material, resources, options);
+    const mesh = new InstancedMesh(primitiveGeometry, material, instances.length);
+    mesh.castShadow = options.castShadow ?? true;
+    mesh.receiveShadow = options.receiveShadow ?? true;
+    mesh.name = `${sourceNode.name}:${lodLevel?.level ?? "high"}:${primitive.material.name}:instanced`;
+    mesh.userData.webHammer = {
+      instanceNodeIds: instances.map((instance) => instance.id),
+      lodLevel: lodLevel?.level ?? "high",
+      materialId: primitive.material.id,
+      sourceNodeId: sourceNode.id
+    };
+    instances.forEach((instance, index) => {
+      const worldTransform = sceneGraph.nodeWorldTransforms.get(instance.id) ?? instance.transform;
+      mesh.setMatrixAt(index, composeGeometryInstanceMatrix(worldTransform, pivot));
+    });
+    mesh.instanceMatrix.needsUpdate = true;
+    group.add(mesh);
+  }
+  group.name = `${sourceNode.name}:instances`;
+  group.userData.webHammer = {
+    instanceNodeIds: instances.map((instance) => instance.id),
+    sourceNodeId: sourceNode.id
+  };
+  return group;
+}
+async function createInstancedObjectForModelNode(sourceNode, instances, sceneGraph, resources, options) {
+  const baseGroup = await createInstancedModelObject(sourceNode, instances, sceneGraph, resources, options);
+  const lodOptions = resolveSceneLodOptions(options.lod);
+  if (!lodOptions || !sourceNode.lods?.length) {
+    return baseGroup;
+  }
+  const lod = new LOD();
+  lod.name = `${sourceNode.name}:InstancingLOD`;
+  lod.autoUpdate = true;
+  lod.addLevel(baseGroup, 0);
+  for (const level of sourceNode.lods) {
+    const levelGroup = await createInstancedModelObject(sourceNode, instances, sceneGraph, resources, options, level);
+    const distance = level.level === "mid" ? lodOptions.midDistance : lodOptions.lowDistance;
+    lod.addLevel(levelGroup, distance);
+  }
+  lod.userData.webHammer = {
+    instanceNodeIds: instances.map((instance) => instance.id),
+    levelOrder: ["high", ...(sourceNode.lods ?? []).map((level) => level.level)],
+    sourceNodeId: sourceNode.id
+  };
+  return lod;
+}
+async function createInstancedModelObject(sourceNode, instances, sceneGraph, resources, options, lodLevel) {
+  const group = new Group();
+  const template = await loadModelTemplate(resolveModelReference(sourceNode, resources.assetsById, lodLevel), options, resources);
+  const templateInstanceNodeIds = instances.map((instance) => instance.id);
+  let modelMeshIndex = 0;
+  template.updateMatrixWorld(true);
+  template.traverse((child) => {
+    if (!(child instanceof Mesh) || !(child.geometry instanceof BufferGeometry)) {
+      return;
+    }
+    const instancedMesh = new InstancedMesh(child.geometry, child.material, instances.length);
+    instancedMesh.castShadow = options.castShadow ?? true;
+    instancedMesh.receiveShadow = options.receiveShadow ?? true;
+    instancedMesh.name = `${sourceNode.name}:${lodLevel?.level ?? "high"}:${child.name || modelMeshIndex}:instanced`;
+    instancedMesh.userData.webHammer = {
+      instanceNodeIds: templateInstanceNodeIds,
+      lodLevel: lodLevel?.level ?? "high",
+      modelMeshIndex,
+      sourceNodeId: sourceNode.id
+    };
+    tempModelChildMatrix.copy(child.matrixWorld);
+    instances.forEach((instance, index) => {
+      const worldTransform = sceneGraph.nodeWorldTransforms.get(instance.id) ?? instance.transform;
+      tempModelInstanceMatrix.copy(composeTransformMatrix(worldTransform)).multiply(tempModelChildMatrix);
+      instancedMesh.setMatrixAt(index, tempModelInstanceMatrix);
+    });
+    instancedMesh.instanceMatrix.needsUpdate = true;
+    group.add(instancedMesh);
+    modelMeshIndex += 1;
+  });
+  group.name = `${sourceNode.name}:instances`;
+  group.userData.webHammer = {
+    instanceNodeIds: templateInstanceNodeIds,
+    sourceNodeId: sourceNode.id
+  };
+  return group;
+}
+async function createLodObjectForGeometryNode(node, resources, options) {
+  const baseGroup = await createGeometryObject(node.geometry, node, resources, options);
+  const lodOptions = resolveSceneLodOptions(options.lod);
+  if (!lodOptions || !node.lods?.length) {
+    return baseGroup;
+  }
+  const lod = new LOD();
+  lod.name = `${node.name}:LOD`;
+  lod.autoUpdate = true;
+  lod.addLevel(baseGroup, 0);
+  for (const level of node.lods) {
+    const levelGroup = await createGeometryObject(level.geometry, node, resources, options, level);
+    const distance = level.level === "mid" ? lodOptions.midDistance : lodOptions.lowDistance;
+    lod.addLevel(levelGroup, distance);
+  }
+  lod.userData.webHammer = {
+    levelOrder: ["high", ...(node.lods ?? []).map((level) => level.level)],
+    nodeId: node.id
+  };
+  return lod;
+}
+async function createLodObjectForModelNode(node, baseModel, resources, options) {
+  const lodOptions = resolveSceneLodOptions(options.lod);
+  if (!lodOptions || !node.lods?.length) {
+    return void 0;
+  }
+  const lod = new LOD();
+  lod.name = `${node.name}:LOD`;
+  lod.autoUpdate = true;
+  lod.addLevel(baseModel, 0);
+  for (const level of node.lods) {
+    const levelModel = await createModelObject(node, resources, options, level);
+    const distance = level.level === "mid" ? lodOptions.midDistance : lodOptions.lowDistance;
+    lod.addLevel(levelModel, distance);
+  }
+  lod.userData.webHammer = {
+    levelOrder: ["high", ...(node.lods ?? []).map((level) => level.level)],
+    nodeId: node.id
+  };
+  return lod;
+}
+async function createGeometryObject(geometry, node, resources, options, lodLevel) {
+  const group = new Group();
+  const meshes = [];
+  for (const primitive of geometry.primitives) {
+    const primitiveGeometry = new BufferGeometry();
+    primitiveGeometry.setAttribute("position", new Float32BufferAttribute(primitive.positions, 3));
+    primitiveGeometry.setAttribute("normal", new Float32BufferAttribute(primitive.normals, 3));
+    if (primitive.uvs.length > 0) {
+      primitiveGeometry.setAttribute("uv", new Float32BufferAttribute(primitive.uvs, 2));
+    }
+    primitiveGeometry.setIndex(primitive.indices);
+    primitiveGeometry.computeBoundingBox();
+    primitiveGeometry.computeBoundingSphere();
+    const material = await createThreeMaterial(primitive.material, resources, options);
+    const mesh = new Mesh(primitiveGeometry, material);
+    mesh.castShadow = options.castShadow ?? true;
+    mesh.receiveShadow = options.receiveShadow ?? true;
+    mesh.name = `${node.name}:${lodLevel?.level ?? "high"}:${primitive.material.name}`;
+    mesh.userData.webHammer = {
+      lodLevel: lodLevel?.level ?? "high",
+      materialId: primitive.material.id,
+      nodeId: node.id
+    };
+    meshes.push(mesh);
+  }
+  meshes.forEach((mesh) => {
+    group.add(mesh);
+  });
+  return group;
+}
+async function createThreeMaterial(materialSpec, resources, options) {
+  const cached = resources.materialCache.get(materialSpec.id);
+  if (cached) {
+    return cached;
+  }
+  const material = new MeshStandardMaterial({
+    color: materialSpec.color,
+    metalness: materialSpec.metallicFactor,
+    roughness: materialSpec.roughnessFactor,
+    side: resolveMaterialSide(materialSpec.side)
+  });
+  if (materialSpec.baseColorTexture) {
+    const texture = await loadTexture(materialSpec.baseColorTexture, materialSpec, "baseColorTexture", resources, options);
+    texture.colorSpace = SRGBColorSpace;
+    material.map = texture;
+  }
+  if (materialSpec.normalTexture) {
+    material.normalMap = await loadTexture(materialSpec.normalTexture, materialSpec, "normalTexture", resources, options);
+  }
+  if (materialSpec.metallicRoughnessTexture) {
+    const ormTexture = await loadTexture(
+      materialSpec.metallicRoughnessTexture,
+      materialSpec,
+      "metallicRoughnessTexture",
+      resources,
+      options
+    );
+    material.metalnessMap = ormTexture;
+    material.roughnessMap = ormTexture;
+  }
+  material.name = materialSpec.name;
+  material.needsUpdate = true;
+  resources.materialCache.set(materialSpec.id, material);
+  return material;
+}
+async function loadTexture(path, material, slot, resources, options) {
+  const resolvedPath = options.resolveAssetUrl ? await options.resolveAssetUrl({
+    kind: "texture",
+    material,
+    path,
+    slot
+  }) : path;
+  const cacheKey = `${slot}:${resolvedPath}`;
+  const cached = resources.textureCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const pendingTexture = textureLoader.loadAsync(resolvedPath);
+  const configuredTexture = pendingTexture.then((texture) => {
+    texture.wrapS = RepeatWrapping;
+    texture.wrapT = RepeatWrapping;
+    return texture;
+  });
+  resources.textureCache.set(cacheKey, configuredTexture);
+  return configuredTexture;
+}
+async function createModelObject(node, resources, options, lodLevel) {
+  const template = await loadModelTemplate(resolveModelReference(node, resources.assetsById, lodLevel), options, resources);
+  const clone = template.clone(true);
+  clone.name = `${node.name}:${lodLevel?.level ?? "high"}`;
+  clone.userData.webHammer = {
+    ...clone.userData.webHammer ?? {},
+    lodLevel: lodLevel?.level ?? "high",
+    nodeId: node.id
+  };
+  clone.traverse((child) => {
+    if (child instanceof Mesh) {
+      child.castShadow = options.castShadow ?? true;
+      child.receiveShadow = options.receiveShadow ?? true;
+    }
+  });
+  return clone;
+}
+function resolveModelReference(node, assetsById, lodLevel) {
+  const asset = lodLevel ? assetsById.get(lodLevel.assetId) : assetsById.get(node.data.assetId);
+  const modelPath = asset?.path ?? node.data.path;
+  return {
+    asset,
+    assetId: asset?.id ?? (lodLevel ? lodLevel.assetId : node.data.assetId),
+    center: readAssetVec3(asset, "nativeCenter"),
+    fallbackName: `${node.name}:${lodLevel?.level ?? "high"}:fallback`,
+    format: resolveModelFormat(asset?.metadata.modelFormat, modelPath),
+    modelPath,
+    nodeId: node.id,
+    nodeName: node.name,
+    texturePath: readAssetString(asset, "texturePath")
+  };
+}
+async function loadModelTemplate(reference, options, resources) {
+  if (!reference.modelPath) {
+    return createMissingModelFallback(reference.asset, reference.fallbackName);
+  }
+  const resolvedPath = options.resolveAssetUrl ? await options.resolveAssetUrl({
+    asset: reference.asset,
+    format: reference.format,
+    kind: "model",
+    node: {
+      data: {
+        assetId: reference.assetId ?? "",
+        path: reference.modelPath
+      },
+      id: reference.nodeId,
+      kind: "model",
+      name: reference.nodeName,
+      transform: {
+        position: vec3(0, 0, 0),
+        rotation: vec3(0, 0, 0),
+        scale: vec3(1, 1, 1)
+      }
+    },
+    path: reference.modelPath
+  }) : reference.modelPath;
+  const resolvedTexturePath = reference.texturePath && options.resolveAssetUrl ? await options.resolveAssetUrl({
+    kind: "texture",
+    material: {
+      color: "#ffffff",
+      id: `material:model-texture:${reference.nodeId}`,
+      metallicFactor: 0,
+      name: `${reference.nodeName} Model Texture`,
+      roughnessFactor: 1
+    },
+    path: reference.texturePath,
+    slot: "baseColorTexture"
+  }) : reference.texturePath;
+  const cacheKey = `${reference.format}:${resolvedPath}:${resolvedTexturePath ?? ""}:${readAssetString(reference.asset, "materialMtlText") ?? ""}`;
+  const cached = resources.modelTemplateCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const pending = (async () => {
+    try {
+      const object = reference.format === "obj" ? await loadObjModel(reference.asset, resolvedPath, resolvedTexturePath) : await loadGltfModel(reference.asset, resolvedPath);
+      centerObject(object, reference.center);
+      return object;
+    } catch {
+      return createMissingModelFallback(reference.asset, reference.fallbackName);
+    }
+  })();
+  resources.modelTemplateCache.set(cacheKey, pending);
+  return pending;
+}
+async function loadObjModel(asset, resolvedPath, resolvedTexturePath) {
+  const objLoader = new OBJLoader();
+  const mtlText = readAssetString(asset, "materialMtlText");
+  if (mtlText) {
+    const materialCreator = mtlLoader.parse(patchMtlTextureReferences(mtlText, resolvedTexturePath), "");
+    materialCreator.preload();
+    objLoader.setMaterials(materialCreator);
+  }
+  const object = await objLoader.loadAsync(resolvedPath);
+  if (!mtlText && resolvedTexturePath) {
+    const texture = await loadModelTexture(resolvedTexturePath);
+    object.traverse((child) => {
+      if (child instanceof Mesh) {
+        child.material = new MeshStandardMaterial({
+          map: texture,
+          metalness: 0.12,
+          roughness: 0.76
+        });
+      }
+    });
+  }
+  return object;
+}
+async function loadGltfModel(asset, resolvedPath) {
+  const gltf = await gltfLoader.loadAsync(resolvedPath);
+  const object = gltf.scene;
+  object.userData.webHammer = {
+    ...object.userData.webHammer ?? {},
+    animations: gltf.animations,
+    nativeCenter: readAssetVec3(asset, "nativeCenter")
+  };
+  return object;
+}
+async function loadModelTexture(path) {
+  const texture = await modelTextureLoader.loadAsync(path);
+  texture.wrapS = RepeatWrapping;
+  texture.wrapT = RepeatWrapping;
+  texture.colorSpace = SRGBColorSpace;
+  return texture;
+}
+function centerObject(object, center) {
+  const resolvedCenter = center ?? computeObjectCenter(object);
+  object.position.set(-resolvedCenter.x, -resolvedCenter.y, -resolvedCenter.z);
+}
+function computeObjectCenter(object) {
+  const box = new Box3().setFromObject(object);
+  const center = box.getCenter(new Vector32());
+  return {
+    x: center.x,
+    y: center.y,
+    z: center.z
+  };
+}
+function createMissingModelFallback(asset, name = "Missing Model") {
+  const previewColor = readAssetString(asset, "previewColor") ?? "#7f8ea3";
+  const size = readAssetVec3(asset, "nativeSize") ?? { x: 1.4, y: 1.4, z: 1.4 };
+  const geometry = new BoxGeometry(size.x, size.y, size.z);
+  const material = new MeshStandardMaterial({
+    color: previewColor,
+    metalness: 0.08,
+    roughness: 0.72
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.name = name;
+  return mesh;
+}
+function createThreeLight(node) {
+  if (!node.data.enabled) {
+    return void 0;
+  }
+  switch (node.data.type) {
+    case "ambient": {
+      return new AmbientLight(node.data.color, node.data.intensity);
+    }
+    case "hemisphere": {
+      return new HemisphereLight(node.data.color, node.data.groundColor ?? "#0f1721", node.data.intensity);
+    }
+    case "point": {
+      const light = new PointLight(node.data.color, node.data.intensity, node.data.distance ?? 0, node.data.decay ?? 2);
+      light.castShadow = node.data.castShadow;
+      return light;
+    }
+    case "directional": {
+      const group = new Group();
+      const light = new DirectionalLight(node.data.color, node.data.intensity);
+      const target = new Object3D();
+      light.castShadow = node.data.castShadow;
+      target.position.set(0, 0, -6);
+      group.add(target);
+      group.add(light);
+      light.target = target;
+      return group;
+    }
+    case "spot": {
+      const group = new Group();
+      const light = new SpotLight(
+        node.data.color,
+        node.data.intensity,
+        node.data.distance,
+        node.data.angle,
+        node.data.penumbra,
+        node.data.decay
+      );
+      const target = new Object3D();
+      light.castShadow = node.data.castShadow;
+      target.position.set(0, 0, -6);
+      group.add(target);
+      group.add(light);
+      light.target = target;
+      return group;
+    }
+    default:
+      return void 0;
+  }
+}
+function applyTransform(object, transform) {
+  object.position.set(transform.position.x, transform.position.y, transform.position.z);
+  object.rotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z);
+  object.scale.set(transform.scale.x, transform.scale.y, transform.scale.z);
+}
+function composeGeometryInstanceMatrix(transform, pivot) {
+  return composeTransformMatrix(transform).multiply(
+    tempPivotMatrix.makeTranslation(-pivot.x, -pivot.y, -pivot.z)
+  );
+}
+function composeTransformMatrix(transform) {
+  tempInstancePosition.set(transform.position.x, transform.position.y, transform.position.z);
+  tempInstanceQuaternion.setFromEuler(new Euler2(transform.rotation.x, transform.rotation.y, transform.rotation.z, "XYZ"));
+  tempInstanceScale.set(transform.scale.x, transform.scale.y, transform.scale.z);
+  return new Matrix42().compose(tempInstancePosition, tempInstanceQuaternion, tempInstanceScale);
+}
+function resolveSceneLodOptions(lod) {
+  if (!lod) {
+    return void 0;
+  }
+  const midDistance = Math.max(0, lod.midDistance);
+  const lowDistance = Math.max(midDistance + 0.01, lod.lowDistance);
+  return {
+    lowDistance,
+    midDistance
+  };
+}
+function resolveMaterialSide(side) {
+  switch (side) {
+    case "back":
+      return BackSide;
+    case "double":
+      return DoubleSide;
+    default:
+      return FrontSide;
+  }
+}
+function resolveModelFormat(format, path) {
+  if (typeof format === "string" && format.toLowerCase() === "obj") {
+    return "obj";
+  }
+  return path?.toLowerCase().endsWith(".obj") ? "obj" : "gltf";
+}
+function readAssetString(asset, key) {
+  const value = asset?.metadata[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readAssetVec3(asset, keyPrefix) {
+  const x = asset?.metadata[`${keyPrefix}X`];
+  const y = asset?.metadata[`${keyPrefix}Y`];
+  const z = asset?.metadata[`${keyPrefix}Z`];
+  if (typeof x !== "number" || typeof y !== "number" || typeof z !== "number") {
+    return void 0;
+  }
+  return { x, y, z };
+}
+function patchMtlTextureReferences(mtlText, texturePath) {
+  if (!texturePath) {
+    return mtlText;
+  }
+  const mapPattern = /^(map_Ka|map_Kd|map_d|map_Bump|bump)\s+.+$/gm;
+  const hasDiffuseMap = /^map_Kd\s+.+$/m.test(mtlText);
+  const normalized = mtlText.replace(mapPattern, (line) => {
+    if (line.startsWith("map_Kd ")) {
+      return `map_Kd ${texturePath}`;
+    }
+    return line;
+  });
+  return hasDiffuseMap ? normalized : `${normalized.trim()}
+map_Kd ${texturePath}
+`;
+}
+function extractPhysics(node) {
+  if (node.kind === "primitive") {
+    return node.data.physics;
+  }
+  if (node.kind === "mesh") {
+    return node.data.physics;
+  }
+  return void 0;
+}
+function findPrimaryLight(object) {
+  if ("isLight" in object && object.isLight) {
+    return object;
+  }
+  return object.children.find((child) => "isLight" in child && child.isLight);
+}
+
+// src/loader.ts
+var textureLoader2 = new TextureLoader2();
+var gltfLoader2 = new GLTFLoader2();
+var hdrLoader = new HDRLoader();
+var mtlLoader2 = new MTLLoader2();
+function isWebHammerEngineScene(value) {
+  return isRuntimeScene(value);
+}
+function isWebHammerEngineBundle(value) {
+  return isRuntimeBundle(value);
+}
+function parseWebHammerEngineScene(text) {
+  return parseRuntimeScene(text);
+}
+async function fetchWebHammerEngineScene(url, init) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch engine scene: ${response.status} ${response.statusText}`);
+  }
+  return parseWebHammerEngineScene(await response.text());
+}
+async function createThreeRuntimeSceneInstance(input, options = {}) {
+  const engineScene = typeof input === "string" ? parseRuntimeScene(input) : parseRuntimeScene(JSON.stringify(input));
+  const root = new Group2();
+  const nodesById = /* @__PURE__ */ new Map();
+  const lights = [];
+  const physicsDescriptors = [];
+  const runtimeNodesById = new Map(engineScene.nodes.map((node) => [node.id, node]));
+  const sceneGraph = resolveSceneGraph(engineScene.nodes, engineScene.entities);
+  const objectFactory = createWebHammerSceneObjectFactory(engineScene, options);
+  const createdObjects = await Promise.all(
+    engineScene.nodes.map(async (node) => [node.id, await objectFactory.createNodeObject(node)])
+  );
+  const attachedNodeIds = /* @__PURE__ */ new Set();
+  const attachStack = /* @__PURE__ */ new Set();
+  root.name = "Web Hammer Scene";
+  root.userData.webHammer = {
+    metadata: engineScene.metadata,
+    settings: engineScene.settings
+  };
+  if (options.applyToScene) {
+    await applyWebHammerWorldSettings(options.applyToScene, engineScene, options);
+  }
+  const worldAmbient = createWorldAmbientLight(engineScene);
+  if (worldAmbient) {
+    root.add(worldAmbient);
+    lights.push(worldAmbient);
+  }
+  createdObjects.forEach(([nodeId, object]) => {
+    nodesById.set(nodeId, object);
+  });
+  const attachNode = (nodeId) => {
+    if (attachedNodeIds.has(nodeId)) {
+      return;
+    }
+    const node = runtimeNodesById.get(nodeId);
+    const object = nodesById.get(nodeId);
+    if (!node || !object) {
+      return;
+    }
+    if (attachStack.has(nodeId)) {
+      root.add(object);
+      attachedNodeIds.add(nodeId);
+      return;
+    }
+    attachStack.add(nodeId);
+    const parentObject = node.parentId && node.parentId !== node.id ? nodesById.get(node.parentId) : void 0;
+    if (parentObject && !attachStack.has(node.parentId)) {
+      attachNode(node.parentId);
+      parentObject.add(object);
+    } else {
+      root.add(object);
+    }
+    attachStack.delete(nodeId);
+    attachedNodeIds.add(nodeId);
+  };
+  for (const node of engineScene.nodes) {
+    attachNode(node.id);
+  }
+  const instancingObjects = await objectFactory.createInstancingObjects();
+  instancingObjects.forEach((object) => {
+    root.add(object);
+  });
+  for (const node of engineScene.nodes) {
+    const object = nodesById.get(node.id);
+    if (!object) {
+      continue;
+    }
+    const light = findPrimaryLight(object);
+    if (light) {
+      lights.push(light);
+    }
+    const physics = extractPhysics(node);
+    if (physics?.enabled) {
+      physicsDescriptors.push({
+        nodeId: node.id,
+        object,
+        physics
+      });
+    }
+  }
+  return {
+    dispose() {
+      disposeThreeRuntimeSceneInstance(root);
+    },
+    entities: engineScene.entities.map((entity) => ({
+      ...entity,
+      transform: sceneGraph.entityWorldTransforms.get(entity.id) ?? entity.transform
+    })),
+    lights,
+    nodesById,
+    physicsDescriptors,
+    root,
+    scene: engineScene
+  };
+}
+async function loadWebHammerEngineScene(input, options = {}) {
+  const instance = await createThreeRuntimeSceneInstance(input, options);
+  return {
+    ...instance,
+    nodes: instance.nodesById,
+    physicsNodes: instance.physicsDescriptors
+  };
+}
+async function loadWebHammerEngineSceneFromUrl(url, options = {}) {
+  const scene = await fetchWebHammerEngineScene(url);
+  return loadWebHammerEngineScene(scene, options);
+}
+async function loadThreeRuntimeSceneInstanceFromUrl(url, options = {}) {
+  const scene = await fetchWebHammerEngineScene(url);
+  return createThreeRuntimeSceneInstance(scene, options);
+}
+var APPLIED_WORLD_SETTINGS_KEY = "__webHammerWorldSettings";
+async function applyWebHammerWorldSettings(target, engineScene, options = {}) {
+  const state = getAppliedWorldSettingsState(target);
+  state.requestId += 1;
+  disposeAppliedSkybox(target, state);
+  const { fogColor, fogFar, fogNear } = engineScene.settings.world;
+  target.fog = fogFar > fogNear ? new Fog(new Color(fogColor), fogNear, fogFar) : null;
+  const skybox = engineScene.settings.world.skybox;
+  if (!skybox.enabled || !skybox.source) {
+    return;
+  }
+  const requestId = state.requestId;
+  try {
+    const resolvedPath = options.resolveAssetUrl ? await options.resolveAssetUrl({
+      kind: "skybox",
+      path: skybox.source,
+      skybox
+    }) : skybox.source;
+    const texture = await loadSkyboxTexture(resolvedPath, skybox);
+    if (getAppliedWorldSettingsState(target).requestId !== requestId) {
+      texture.dispose();
+      return;
+    }
+    target.background = texture;
+    target.backgroundBlurriness = skybox.blur;
+    target.backgroundIntensity = skybox.intensity;
+    target.environment = skybox.affectsLighting ? texture : null;
+    target.environmentIntensity = skybox.affectsLighting ? skybox.lightingIntensity : 1;
+    state.skyboxTexture = texture;
+  } catch {
+    if (getAppliedWorldSettingsState(target).requestId === requestId) {
+      disposeAppliedSkybox(target, state);
+    }
+  }
+}
+function clearWebHammerWorldSettings(target) {
+  const state = getAppliedWorldSettingsState(target);
+  state.requestId += 1;
+  disposeAppliedSkybox(target, state);
+  target.fog = null;
+}
+var applyRuntimeWorldSettingsToThreeScene = applyWebHammerWorldSettings;
+var clearRuntimeWorldSettingsFromThreeScene = clearWebHammerWorldSettings;
+function createWorldAmbientLight(engineScene) {
+  const { ambientColor, ambientIntensity } = engineScene.settings.world;
+  if (ambientIntensity <= 0) {
+    return void 0;
+  }
+  const light = new AmbientLight2(ambientColor, ambientIntensity);
+  light.name = "World Ambient";
+  light.userData.webHammer = {
+    source: "world-settings"
+  };
+  return light;
+}
+function getAppliedWorldSettingsState(target) {
+  const userData = target.userData;
+  const existing = userData[APPLIED_WORLD_SETTINGS_KEY];
+  if (existing) {
+    return existing;
+  }
+  const created = {
+    requestId: 0
+  };
+  userData[APPLIED_WORLD_SETTINGS_KEY] = created;
+  return created;
+}
+function disposeAppliedSkybox(target, state) {
+  if (state.skyboxTexture) {
+    if (target.background === state.skyboxTexture) {
+      target.background = null;
+    }
+    if (target.environment === state.skyboxTexture) {
+      target.environment = null;
+    }
+    state.skyboxTexture.dispose();
+    state.skyboxTexture = void 0;
+  }
+  target.backgroundBlurriness = 0;
+  target.backgroundIntensity = 1;
+  target.environmentIntensity = 1;
+}
+function disposeThreeRuntimeSceneInstance(root) {
+  const geometries = /* @__PURE__ */ new Set();
+  const materials = /* @__PURE__ */ new Set();
+  const textures = /* @__PURE__ */ new Set();
+  root.traverse((object) => {
+    if (!(object instanceof Mesh2 || object instanceof InstancedMesh2)) {
+      return;
+    }
+    if (object.geometry instanceof BufferGeometry2) {
+      geometries.add(object.geometry);
+    }
+    const objectMaterials = Array.isArray(object.material) ? object.material : [object.material];
+    objectMaterials.forEach((material) => {
+      if (!(material instanceof MeshStandardMaterial2)) {
+        return;
+      }
+      materials.add(material);
+      if (material.map) {
+        textures.add(material.map);
+      }
+      if (material.normalMap) {
+        textures.add(material.normalMap);
+      }
+      if (material.metalnessMap) {
+        textures.add(material.metalnessMap);
+      }
+      if (material.roughnessMap) {
+        textures.add(material.roughnessMap);
+      }
+    });
+  });
+  root.removeFromParent();
+  geometries.forEach((geometry) => {
+    geometry.dispose();
+  });
+  materials.forEach((material) => {
+    material.dispose();
+  });
+  textures.forEach((texture) => {
+    texture.dispose();
+  });
+}
+async function loadSkyboxTexture(path, skybox) {
+  const texture = skybox.format === "hdr" ? await hdrLoader.loadAsync(path) : await textureLoader2.loadAsync(path);
+  texture.mapping = EquirectangularReflectionMapping;
+  if (skybox.format === "image") {
+    texture.colorSpace = SRGBColorSpace2;
+  }
+  return texture;
+}
+
+// ../runtime-build/src/bundle.ts
+import { unzipSync, zipSync } from "fflate";
+var TEXTURE_FIELDS = ["baseColorTexture", "metallicRoughnessTexture", "normalTexture"];
+async function externalizeRuntimeAssets(scene, options = {}) {
+  const manifest = structuredClone(scene);
+  const files = [];
+  const assetDir = trimSlashes(options.assetDir ?? "assets");
+  const copyExternalAssets = options.copyExternalAssets ?? true;
+  const pathBySource = /* @__PURE__ */ new Map();
+  const usedPaths = /* @__PURE__ */ new Set();
+  for (const material of manifest.materials) {
+    for (const field of TEXTURE_FIELDS) {
+      const source = material[field];
+      if (!source) {
+        continue;
+      }
+      const bundledPath = await materializeSource(source, {
+        copyExternalAssets,
+        files,
+        pathBySource,
+        preferredStem: `${assetDir}/textures/${slugify(material.id)}-${textureFieldSuffix(field)}`,
+        usedPaths
+      });
+      if (bundledPath) {
+        material[field] = bundledPath;
+      }
+    }
+  }
+  for (const asset of manifest.assets) {
+    if (asset.type !== "model") {
+      continue;
+    }
+    const bundledPath = await materializeSource(asset.path, {
+      copyExternalAssets,
+      files,
+      pathBySource,
+      preferredExtension: inferModelExtension(asset.path, asset.metadata.modelFormat),
+      preferredStem: `${assetDir}/models/${slugify(asset.id)}`,
+      usedPaths
+    });
+    if (bundledPath) {
+      asset.path = bundledPath;
+    }
+    const texturePath = asset.metadata.texturePath;
+    if (typeof texturePath === "string" && texturePath.length > 0) {
+      const bundledTexturePath = await materializeSource(texturePath, {
+        copyExternalAssets,
+        files,
+        pathBySource,
+        preferredStem: `${assetDir}/model-textures/${slugify(asset.id)}`,
+        usedPaths
+      });
+      if (bundledTexturePath) {
+        asset.metadata.texturePath = bundledTexturePath;
+      }
+    }
+  }
+  const skyboxSource = manifest.settings.world.skybox.source;
+  if (skyboxSource) {
+    const bundledSkyboxPath = await materializeSource(skyboxSource, {
+      copyExternalAssets,
+      files,
+      pathBySource,
+      preferredExtension: manifest.settings.world.skybox.format === "hdr" ? "hdr" : inferExtensionFromPath(skyboxSource),
+      preferredStem: `${assetDir}/skyboxes/${slugify(manifest.settings.world.skybox.name || "skybox")}`,
+      usedPaths
+    });
+    if (bundledSkyboxPath) {
+      manifest.settings.world.skybox.source = bundledSkyboxPath;
+    }
+  }
+  return {
+    files,
+    manifest
+  };
+}
+async function buildRuntimeBundle(scene, options = {}) {
+  return externalizeRuntimeAssets(scene, options);
+}
+function normalizeRuntimeScene(scene) {
+  return typeof scene === "string" ? parseRuntimeScene(scene) : parseRuntimeScene(JSON.stringify(scene));
+}
+function packRuntimeBundle(bundle, options = {}) {
+  const manifestPath = options.manifestPath ?? "scene.runtime.json";
+  const encoder = new TextEncoder();
+  const entries = {
+    [manifestPath]: encoder.encode(JSON.stringify(bundle.manifest))
+  };
+  bundle.files.forEach((file) => {
+    entries[file.path] = file.bytes;
+  });
+  return zipSync(entries, {
+    level: options.compressionLevel ?? 6
+  });
+}
+function unpackRuntimeBundle(bytes, options = {}) {
+  const manifestPath = options.manifestPath ?? "scene.runtime.json";
+  const archive = unzipSync(bytes);
+  const manifestBytes = archive[manifestPath];
+  if (!manifestBytes) {
+    throw new Error(`Bundle is missing ${manifestPath}.`);
+  }
+  const manifest = parseRuntimeScene(new TextDecoder().decode(manifestBytes));
+  const files = Object.entries(archive).filter(([path]) => path !== manifestPath).map(([path, fileBytes]) => ({
+    bytes: fileBytes,
+    mimeType: inferMimeTypeFromPath(path),
+    path
+  }));
+  return {
+    files,
+    manifest
+  };
+}
+function buildRuntimeWorldIndex(chunks, options = {}) {
+  return {
+    chunks,
+    sharedAssets: options.sharedAssets,
+    version: options.version ?? 1
+  };
+}
+async function externalizeWebHammerEngineScene(scene, options = {}) {
+  return externalizeRuntimeAssets(scene, options);
+}
+function createWebHammerEngineBundleZip(bundle, options = {}) {
+  return packRuntimeBundle(bundle, options);
+}
+function parseWebHammerEngineBundleZip(bytes, options = {}) {
+  return unpackRuntimeBundle(bytes, options);
+}
+async function materializeSource(source, context) {
+  const existing = context.pathBySource.get(source);
+  if (existing) {
+    return existing;
+  }
+  if (isDataUrl(source)) {
+    const parsed = parseDataUrl(source);
+    const path2 = ensureUniquePath(
+      `${context.preferredStem}.${inferExtension(parsed.mimeType, context.preferredExtension)}`,
+      context.usedPaths
+    );
+    context.files.push({
+      bytes: parsed.bytes,
+      mimeType: parsed.mimeType,
+      path: path2
+    });
+    context.pathBySource.set(source, path2);
+    return path2;
+  }
+  if (!context.copyExternalAssets) {
+    return void 0;
+  }
+  const response = await fetch(source);
+  if (!response.ok) {
+    throw new Error(`Failed to bundle asset: ${source}`);
+  }
+  const blob = await response.blob();
+  const bytes = new Uint8Array(await blob.arrayBuffer());
+  const path = ensureUniquePath(
+    `${context.preferredStem}.${inferExtension(blob.type, context.preferredExtension ?? inferExtensionFromPath(source))}`,
+    context.usedPaths
+  );
+  context.files.push({
+    bytes,
+    mimeType: blob.type || "application/octet-stream",
+    path
+  });
+  context.pathBySource.set(source, path);
+  return path;
+}
+function parseDataUrl(source) {
+  const match = /^data:([^;,]+)?(?:;charset=[^;,]+)?(;base64)?,(.*)$/i.exec(source);
+  if (!match) {
+    throw new Error("Invalid data URL.");
+  }
+  const mimeType = match[1] || "application/octet-stream";
+  const payload = match[3] || "";
+  if (match[2]) {
+    const binary = atob(payload);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return { bytes, mimeType };
+  }
+  return {
+    bytes: new TextEncoder().encode(decodeURIComponent(payload)),
+    mimeType
+  };
+}
+function textureFieldSuffix(field) {
+  switch (field) {
+    case "baseColorTexture":
+      return "color";
+    case "metallicRoughnessTexture":
+      return "orm";
+    default:
+      return "normal";
+  }
+}
+function inferModelExtension(path, modelFormat) {
+  if (typeof modelFormat === "string" && modelFormat.length > 0) {
+    return modelFormat.toLowerCase();
+  }
+  return inferExtensionFromPath(path) ?? "bin";
+}
+function inferExtension(mimeType, fallback) {
+  const normalized = mimeType?.toLowerCase();
+  if (normalized === "image/png") {
+    return "png";
+  }
+  if (normalized === "image/jpeg") {
+    return "jpg";
+  }
+  if (normalized === "image/svg+xml") {
+    return "svg";
+  }
+  if (normalized === "image/vnd.radiance") {
+    return "hdr";
+  }
+  if (normalized === "model/gltf+json") {
+    return "gltf";
+  }
+  if (normalized === "model/gltf-binary" || normalized === "application/octet-stream") {
+    return fallback ?? "bin";
+  }
+  return fallback ?? "bin";
+}
+function inferExtensionFromPath(path) {
+  const cleanPath = path.split("?")[0]?.split("#")[0] ?? path;
+  const parts = cleanPath.split(".");
+  return parts.length > 1 ? parts.at(-1)?.toLowerCase() : void 0;
+}
+function inferMimeTypeFromPath(path) {
+  switch (inferExtensionFromPath(path)) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "svg":
+      return "image/svg+xml";
+    case "hdr":
+      return "image/vnd.radiance";
+    case "glb":
+      return "model/gltf-binary";
+    case "gltf":
+      return "model/gltf+json";
+    case "obj":
+      return "text/plain";
+    case "mtl":
+      return "text/plain";
+    case "json":
+      return "application/json";
+    default:
+      return "application/octet-stream";
+  }
+}
+function ensureUniquePath(path, usedPaths) {
+  if (!usedPaths.has(path)) {
+    usedPaths.add(path);
+    return path;
+  }
+  const lastDot = path.lastIndexOf(".");
+  const stem = lastDot >= 0 ? path.slice(0, lastDot) : path;
+  const extension = lastDot >= 0 ? path.slice(lastDot) : "";
+  let counter = 2;
+  while (usedPaths.has(`${stem}-${counter}${extension}`)) {
+    counter += 1;
+  }
+  const resolved = `${stem}-${counter}${extension}`;
+  usedPaths.add(resolved);
+  return resolved;
+}
+function isDataUrl(value) {
+  return value.startsWith("data:");
+}
+function slugify(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "asset";
+}
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+
+// ../geometry-kernel/src/polygon/polygon-utils.ts
+import earcut from "earcut";
+function computePolygonNormal(vertices) {
+  if (vertices.length < 3) {
+    return vec3(0, 1, 0);
+  }
+  let normal = vec3(0, 0, 0);
+  for (let index = 0; index < vertices.length; index += 1) {
+    const current = vertices[index];
+    const next = vertices[(index + 1) % vertices.length];
+    normal = addVec3(
+      normal,
+      vec3(
+        (current.y - next.y) * (current.z + next.z),
+        (current.z - next.z) * (current.x + next.x),
+        (current.x - next.x) * (current.y + next.y)
+      )
+    );
+  }
+  const normalized = normalizeVec3(normal);
+  return lengthVec3(normalized) === 0 ? vec3(0, 1, 0) : normalized;
+}
+function projectPolygonToPlane(vertices, normal = computePolygonNormal(vertices)) {
+  const origin = averageVec3(vertices);
+  const tangentReference = Math.abs(normal.y) < 0.99 ? vec3(0, 1, 0) : vec3(1, 0, 0);
+  let tangent = normalizeVec3(crossVec3(tangentReference, normal));
+  if (lengthVec3(tangent) === 0) {
+    tangent = normalizeVec3(crossVec3(vec3(0, 0, 1), normal));
+  }
+  const bitangent = normalizeVec3(crossVec3(normal, tangent));
+  return vertices.map((vertex) => {
+    const offset = subVec3(vertex, origin);
+    return [dotVec3(offset, tangent), dotVec3(offset, bitangent)];
+  });
+}
+function polygonSignedArea(points) {
+  let area = 0;
+  for (let index = 0; index < points.length; index += 1) {
+    const [x1, y1] = points[index];
+    const [x2, y2] = points[(index + 1) % points.length];
+    area += x1 * y2 - x2 * y1;
+  }
+  return area * 0.5;
+}
+function sortVerticesOnPlane(vertices, normal) {
+  const center = averageVec3(vertices);
+  const tangentReference = Math.abs(normal.y) < 0.99 ? vec3(0, 1, 0) : vec3(1, 0, 0);
+  let tangent = normalizeVec3(crossVec3(tangentReference, normal));
+  if (lengthVec3(tangent) === 0) {
+    tangent = normalizeVec3(crossVec3(vec3(0, 0, 1), normal));
+  }
+  const bitangent = normalizeVec3(crossVec3(normal, tangent));
+  const sorted = [...vertices].sort((left, right) => {
+    const leftOffset = subVec3(left, center);
+    const rightOffset = subVec3(right, center);
+    const leftAngle = Math.atan2(dotVec3(leftOffset, bitangent), dotVec3(leftOffset, tangent));
+    const rightAngle = Math.atan2(dotVec3(rightOffset, bitangent), dotVec3(rightOffset, tangent));
+    return leftAngle - rightAngle;
+  });
+  if (sorted.length < 3) {
+    return sorted;
+  }
+  const windingNormal = normalizeVec3(
+    crossVec3(subVec3(sorted[1], sorted[0]), subVec3(sorted[2], sorted[0]))
+  );
+  return dotVec3(windingNormal, normal) < 0 ? sorted.reverse() : sorted;
+}
+function triangulatePolygon(points) {
+  const flattened = points.flatMap(([x, y]) => [x, y]);
+  return earcut(flattened);
+}
+function triangulatePolygon3D(vertices, normal = computePolygonNormal(vertices)) {
+  if (vertices.length < 3) {
+    return [];
+  }
+  const projected = projectPolygonToPlane(vertices, normal);
+  if (Math.abs(polygonSignedArea(projected)) <= 1e-6) {
+    return [];
+  }
+  return triangulatePolygon(projected);
+}
+function computeFaceCenter(vertices) {
+  return averageVec3(vertices);
+}
+
+// ../geometry-kernel/src/brush/brush-kernel.ts
+function reconstructBrushFaces(brush, epsilon = 1e-4) {
+  if (brush.planes.length < 4) {
+    return {
+      faces: [],
+      vertices: [],
+      valid: false,
+      errors: ["Brush reconstruction requires at least four planes."]
+    };
+  }
+  const vertexRegistry = /* @__PURE__ */ new Map();
+  const faces = [];
+  for (let planeIndex = 0; planeIndex < brush.planes.length; planeIndex += 1) {
+    const plane = brush.planes[planeIndex];
+    const faceVertices = collectFaceVertices(brush.planes, planeIndex, epsilon);
+    if (faceVertices.length < 3) {
+      continue;
+    }
+    const orderedVertices = sortVerticesOnPlane(faceVertices, normalizeVec3(plane.normal));
+    const triangleIndices = triangulatePolygon3D(orderedVertices, plane.normal);
+    if (triangleIndices.length < 3) {
+      continue;
+    }
+    const vertices = orderedVertices.map((position) => registerBrushVertex(vertexRegistry, position, epsilon));
+    const seedFace = brush.faces[planeIndex];
+    faces.push({
+      id: seedFace?.id ?? `face:brush:${planeIndex}`,
+      plane,
+      materialId: seedFace?.materialId,
+      uvOffset: seedFace?.uvOffset,
+      uvScale: seedFace?.uvScale,
+      vertexIds: vertices.map((vertex) => vertex.id),
+      vertices,
+      center: computeFaceCenter(orderedVertices),
+      normal: normalizeVec3(plane.normal),
+      triangleIndices
+    });
+  }
+  return {
+    faces,
+    vertices: Array.from(vertexRegistry.values()),
+    valid: faces.length >= 4,
+    errors: faces.length >= 4 ? [] : ["Brush reconstruction did not produce a closed convex solid."]
+  };
+}
+function classifyPointAgainstPlane(point, plane, epsilon = 1e-4) {
+  const signedDistance = signedDistanceToPlane(point, plane);
+  return signedDistance > epsilon ? "outside" : "inside";
+}
+function signedDistanceToPlane(point, plane) {
+  return dotVec3(plane.normal, point) - plane.distance;
+}
+function intersectPlanes(first, second, third, epsilon = 1e-6) {
+  const denominator = dotVec3(first.normal, crossVec3(second.normal, third.normal));
+  if (Math.abs(denominator) <= epsilon) {
+    return void 0;
+  }
+  const firstTerm = scaleVec3(crossVec3(second.normal, third.normal), first.distance);
+  const secondTerm = scaleVec3(crossVec3(third.normal, first.normal), second.distance);
+  const thirdTerm = scaleVec3(crossVec3(first.normal, second.normal), third.distance);
+  return scaleVec3(addVec3(addVec3(firstTerm, secondTerm), thirdTerm), 1 / denominator);
+}
+function collectFaceVertices(planes, planeIndex, epsilon) {
+  const plane = planes[planeIndex];
+  const vertices = /* @__PURE__ */ new Map();
+  for (let firstIndex = 0; firstIndex < planes.length; firstIndex += 1) {
+    if (firstIndex === planeIndex) {
+      continue;
+    }
+    for (let secondIndex = firstIndex + 1; secondIndex < planes.length; secondIndex += 1) {
+      if (secondIndex === planeIndex) {
+        continue;
+      }
+      const intersection = intersectPlanes(plane, planes[firstIndex], planes[secondIndex], epsilon);
+      if (!intersection) {
+        continue;
+      }
+      const liesOnPlane = Math.abs(signedDistanceToPlane(intersection, plane)) <= epsilon * 4;
+      const insideAllPlanes = planes.every(
+        (candidatePlane) => classifyPointAgainstPlane(intersection, candidatePlane, epsilon * 4) === "inside"
+      );
+      if (!liesOnPlane || !insideAllPlanes) {
+        continue;
+      }
+      vertices.set(makeVertexKey(intersection, epsilon), intersection);
+    }
+  }
+  return Array.from(vertices.values());
+}
+function registerBrushVertex(registry, position, epsilon) {
+  const key = makeVertexKey(position, epsilon);
+  const existing = registry.get(key);
+  if (existing) {
+    return existing;
+  }
+  const vertex = {
+    id: `vertex:brush:${registry.size}`,
+    position: vec3(position.x, position.y, position.z)
+  };
+  registry.set(key, vertex);
+  return vertex;
+}
+function makeVertexKey(position, epsilon) {
+  return [
+    Math.round(position.x / epsilon),
+    Math.round(position.y / epsilon),
+    Math.round(position.z / epsilon)
+  ].join(":");
+}
+
+// ../geometry-kernel/src/mesh/editable-mesh.ts
+var editableMeshIndexCache = /* @__PURE__ */ new WeakMap();
+function getFaceVertexIds(mesh, faceId) {
+  const index = getEditableMeshIndex(mesh);
+  const cachedIds = index.faceVertexIds.get(faceId);
+  if (cachedIds) {
+    return cachedIds;
+  }
+  const face = index.faceById.get(faceId);
+  if (!face) {
+    return [];
+  }
+  const ids = [];
+  let currentEdgeId = face.halfEdge;
+  let guard = 0;
+  while (currentEdgeId && guard < mesh.halfEdges.length + 1) {
+    const halfEdge = index.halfEdgeById.get(currentEdgeId);
+    if (!halfEdge) {
+      return [];
+    }
+    ids.push(halfEdge.vertex);
+    currentEdgeId = halfEdge.next;
+    guard += 1;
+    if (currentEdgeId === face.halfEdge) {
+      break;
+    }
+  }
+  index.faceVertexIds.set(faceId, ids);
+  return ids;
+}
+function getFaceVertices(mesh, faceId) {
+  const index = getEditableMeshIndex(mesh);
+  return getFaceVertexIds(mesh, faceId).map((vertexId) => index.vertexById.get(vertexId)).filter((vertex) => Boolean(vertex));
+}
+function triangulateMeshFace(mesh, faceId) {
+  const faceVertices = getFaceVertices(mesh, faceId);
+  if (faceVertices.length < 3) {
+    return void 0;
+  }
+  const normal = computePolygonNormal(faceVertices.map((vertex) => vertex.position));
+  const indices = triangulatePolygon3D(
+    faceVertices.map((vertex) => vertex.position),
+    normal
+  );
+  if (indices.length < 3) {
+    return void 0;
+  }
+  return {
+    faceId,
+    vertexIds: faceVertices.map((vertex) => vertex.id),
+    normal,
+    indices
+  };
+}
+function getEditableMeshIndex(mesh) {
+  const cached = editableMeshIndexCache.get(mesh);
+  if (cached && cached.faces === mesh.faces && cached.halfEdges === mesh.halfEdges && cached.vertices === mesh.vertices) {
+    return cached;
+  }
+  const nextIndex = {
+    faceById: new Map(mesh.faces.map((face) => [face.id, face])),
+    faceVertexIds: /* @__PURE__ */ new Map(),
+    faces: mesh.faces,
+    halfEdgeById: new Map(mesh.halfEdges.map((halfEdge) => [halfEdge.id, halfEdge])),
+    halfEdges: mesh.halfEdges,
+    vertexById: new Map(mesh.vertices.map((vertex) => [vertex.id, vertex])),
+    vertices: mesh.vertices
+  };
+  editableMeshIndexCache.set(mesh, nextIndex);
+  return nextIndex;
+}
+
+// ../runtime-build/src/snapshot-build.ts
+import { MeshBVH } from "three-mesh-bvh";
+import {
+  Box3 as Box33,
+  BoxGeometry as BoxGeometry3,
+  BufferGeometry as BufferGeometry3,
+  ConeGeometry,
+  Float32BufferAttribute as Float32BufferAttribute3,
+  Group as Group3,
+  Mesh as Mesh3,
+  MeshStandardMaterial as MeshStandardMaterial3,
+  RepeatWrapping as RepeatWrapping3,
+  Scene as Scene2,
+  SphereGeometry,
+  SRGBColorSpace as SRGBColorSpace3,
+  TextureLoader as TextureLoader3,
+  Vector3 as Vector34,
+  CylinderGeometry
+} from "three";
+import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
+import { GLTFLoader as GLTFLoader3 } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MTLLoader as MTLLoader3 } from "three/examples/jsm/loaders/MTLLoader.js";
+import { OBJLoader as OBJLoader3 } from "three/examples/jsm/loaders/OBJLoader.js";
+var gltfLoader3 = new GLTFLoader3();
+var gltfExporter = new GLTFExporter();
+var mtlLoader3 = new MTLLoader3();
+var modelTextureLoader2 = new TextureLoader3();
+async function buildRuntimeScene(input) {
+  if (typeof input === "string") {
+    return parseRuntimeScene(input);
+  }
+  if (isSceneDocumentSnapshotLike(input)) {
+    return buildRuntimeSceneFromSnapshot(input);
+  }
+  return normalizeRuntimeScene(input);
+}
+async function buildRuntimeSceneFromSnapshot(snapshot) {
+  const assetsById = new Map(snapshot.assets.map((asset) => [asset.id, asset]));
+  const materialsById = new Map(snapshot.materials.map((material) => [material.id, material]));
+  const exportedMaterials = await Promise.all(snapshot.materials.map((material) => resolveRuntimeMaterial(material)));
+  const shouldBakeLods = snapshot.settings.world.lod.enabled;
+  const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const exportedSettings = shouldBakeLods ? {
+    ...snapshot.settings,
+    world: {
+      ...snapshot.settings.world,
+      lod: {
+        ...snapshot.settings.world.lod,
+        bakedAt: exportedAt
+      }
+    }
+  } : snapshot.settings;
+  const generatedAssets = [];
+  const exportedNodes = [];
+  for (const node of snapshot.nodes) {
+    if (isGroupNode(node)) {
+      exportedNodes.push({
+        data: node.data,
+        hooks: node.hooks,
+        id: node.id,
+        kind: "group",
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: node.transform
+      });
+      continue;
+    }
+    if (isBrushNode(node)) {
+      const geometry = await buildExportGeometry(node, materialsById);
+      exportedNodes.push({
+        data: node.data,
+        geometry,
+        hooks: node.hooks,
+        id: node.id,
+        kind: "brush",
+        lods: shouldBakeLods ? await buildGeometryLods(geometry, snapshot.settings.world.lod) : void 0,
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: node.transform
+      });
+      continue;
+    }
+    if (isMeshNode(node)) {
+      const geometry = await buildExportGeometry(node, materialsById);
+      exportedNodes.push({
+        data: node.data,
+        geometry,
+        hooks: node.hooks,
+        id: node.id,
+        kind: "mesh",
+        lods: shouldBakeLods ? await buildGeometryLods(geometry, snapshot.settings.world.lod) : void 0,
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: node.transform
+      });
+      continue;
+    }
+    if (isPrimitiveNode(node)) {
+      const geometry = await buildExportGeometry(node, materialsById);
+      exportedNodes.push({
+        data: node.data,
+        geometry,
+        hooks: node.hooks,
+        id: node.id,
+        kind: "primitive",
+        lods: shouldBakeLods ? await buildGeometryLods(geometry, snapshot.settings.world.lod) : void 0,
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: node.transform
+      });
+      continue;
+    }
+    if (isModelNode(node)) {
+      const modelLodBake = shouldBakeLods ? await buildModelLods(node.name, assetsById.get(node.data.assetId), node.id, snapshot.settings.world.lod) : void 0;
+      generatedAssets.push(...modelLodBake?.assets ?? []);
+      exportedNodes.push({
+        data: node.data,
+        hooks: node.hooks,
+        id: node.id,
+        kind: "model",
+        lods: modelLodBake?.lods,
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: node.transform
+      });
+      continue;
+    }
+    if (isInstancingNode(node)) {
+      const sourceNode = resolveInstancingSourceNode(snapshot.nodes, node);
+      if (!sourceNode || !(isBrushNode(sourceNode) || isMeshNode(sourceNode) || isPrimitiveNode(sourceNode) || isModelNode(sourceNode))) {
+        continue;
+      }
+      exportedNodes.push({
+        data: {
+          sourceNodeId: sourceNode.id
+        },
+        hooks: node.hooks,
+        id: node.id,
+        kind: "instancing",
+        metadata: node.metadata,
+        name: node.name,
+        parentId: node.parentId,
+        tags: node.tags,
+        transform: sanitizeInstanceTransform(node.transform)
+      });
+      continue;
+    }
+    exportedNodes.push({
+      data: node.data,
+      id: node.id,
+      kind: "light",
+      metadata: node.metadata,
+      name: node.name,
+      parentId: node.parentId,
+      tags: node.tags,
+      transform: node.transform
+    });
+  }
+  return {
+    assets: [...snapshot.assets, ...generatedAssets],
+    entities: snapshot.entities,
+    layers: snapshot.layers,
+    materials: exportedMaterials,
+    metadata: {
+      exportedAt,
+      format: "web-hammer-engine",
+      version: CURRENT_RUNTIME_SCENE_VERSION
+    },
+    nodes: exportedNodes,
+    settings: exportedSettings
+  };
+}
+function isSceneDocumentSnapshotLike(value) {
+  return Boolean(
+    value && typeof value === "object" && Array.isArray(value.nodes) && Array.isArray(value.materials) && Array.isArray(value.textures)
+  );
+}
+async function buildExportGeometry(node, materialsById) {
+  const fallbackMaterial = await resolveRuntimeMaterial({
+    color: node.kind === "brush" ? "#f69036" : node.kind === "primitive" && node.data.role === "prop" ? "#7f8ea3" : "#6ed5c0",
+    id: `material:fallback:${node.id}`,
+    metalness: node.kind === "brush" ? 0 : node.kind === "primitive" && node.data.role === "prop" ? 0.12 : 0.05,
+    name: `${node.name} Default`,
+    roughness: node.kind === "brush" ? 0.95 : node.kind === "primitive" && node.data.role === "prop" ? 0.64 : 0.82
+  });
+  const primitiveByMaterial = /* @__PURE__ */ new Map();
+  const appendFace = async (params) => {
+    const material = params.faceMaterialId ? await resolveRuntimeMaterial(materialsById.get(params.faceMaterialId)) : fallbackMaterial;
+    const primitive = primitiveByMaterial.get(material.id) ?? {
+      indices: [],
+      material,
+      normals: [],
+      positions: [],
+      uvs: []
+    };
+    const vertexOffset = primitive.positions.length / 3;
+    const uvs = params.uvs && params.uvs.length === params.vertices.length ? params.uvs.flatMap((uv) => [uv.x, uv.y]) : projectPlanarUvs(params.vertices, params.normal, params.uvScale, params.uvOffset);
+    params.vertices.forEach((vertex) => {
+      primitive.positions.push(vertex.x, vertex.y, vertex.z);
+      primitive.normals.push(params.normal.x, params.normal.y, params.normal.z);
+    });
+    primitive.uvs.push(...uvs);
+    params.triangleIndices.forEach((index) => {
+      primitive.indices.push(vertexOffset + index);
+    });
+    primitiveByMaterial.set(material.id, primitive);
+  };
+  if (isBrushNode(node)) {
+    const rebuilt = reconstructBrushFaces(node.data);
+    if (!rebuilt.valid) {
+      return { primitives: [] };
+    }
+    for (const face of rebuilt.faces) {
+      await appendFace({
+        faceMaterialId: face.materialId,
+        normal: face.normal,
+        triangleIndices: face.triangleIndices,
+        uvOffset: face.uvOffset,
+        uvScale: face.uvScale,
+        vertices: face.vertices.map((vertex) => vertex.position)
+      });
+    }
+  }
+  if (isMeshNode(node)) {
+    for (const face of node.data.faces) {
+      const triangulated = triangulateMeshFace(node.data, face.id);
+      if (!triangulated) {
+        continue;
+      }
+      await appendFace({
+        faceMaterialId: face.materialId,
+        normal: triangulated.normal,
+        triangleIndices: triangulated.indices,
+        uvOffset: face.uvOffset,
+        uvScale: face.uvScale,
+        uvs: face.uvs,
+        vertices: getFaceVertices(node.data, face.id).map((vertex) => vertex.position)
+      });
+    }
+  }
+  if (isPrimitiveNode(node)) {
+    const material = node.data.materialId ? await resolveRuntimeMaterial(materialsById.get(node.data.materialId)) : fallbackMaterial;
+    const primitive = buildPrimitiveGeometry(node.data.shape, node.data.size, node.data.radialSegments ?? 24);
+    if (primitive) {
+      primitiveByMaterial.set(material.id, {
+        indices: primitive.indices,
+        material,
+        normals: primitive.normals,
+        positions: primitive.positions,
+        uvs: primitive.uvs
+      });
+    }
+  }
+  return {
+    primitives: Array.from(primitiveByMaterial.values())
+  };
+}
+async function buildGeometryLods(geometry, settings) {
+  if (!geometry.primitives.length) {
+    return void 0;
+  }
+  const midGeometry = simplifyExportGeometry(geometry, settings.midDetailRatio);
+  const lowGeometry = simplifyExportGeometry(geometry, settings.lowDetailRatio);
+  const lods = [];
+  if (midGeometry) {
+    lods.push({
+      geometry: midGeometry,
+      level: "mid"
+    });
+  }
+  if (lowGeometry) {
+    lods.push({
+      geometry: lowGeometry,
+      level: "low"
+    });
+  }
+  return lods.length ? lods : void 0;
+}
+async function buildModelLods(name, asset, nodeId, settings) {
+  if (!asset?.path) {
+    return { assets: [], lods: void 0 };
+  }
+  const source = await loadModelSceneForLodBake(asset);
+  const bakedLevels = [];
+  for (const [level, ratio] of [
+    ["mid", settings.midDetailRatio],
+    ["low", settings.lowDetailRatio]
+  ]) {
+    const simplified = simplifyModelSceneForRatio(source, ratio);
+    if (!simplified) {
+      continue;
+    }
+    const bytes = await exportModelSceneAsGlb(simplified);
+    bakedLevels.push({
+      asset: createGeneratedModelLodAsset(asset, name, nodeId, level, bytes),
+      level
+    });
+  }
+  return {
+    assets: bakedLevels.map((entry) => entry.asset),
+    lods: bakedLevels.length ? bakedLevels.map((entry) => ({
+      assetId: entry.asset.id,
+      level: entry.level
+    })) : void 0
+  };
+}
+async function loadModelSceneForLodBake(asset) {
+  const format = resolveModelAssetFormat(asset);
+  if (format === "obj") {
+    const objLoader = new OBJLoader3();
+    const texturePath = readModelAssetString(asset, "texturePath");
+    const resolvedTexturePath = typeof texturePath === "string" && texturePath.length > 0 ? texturePath : void 0;
+    const mtlText = readModelAssetString(asset, "materialMtlText");
+    if (mtlText) {
+      const materialCreator = mtlLoader3.parse(patchMtlTextureReferences2(mtlText, resolvedTexturePath), "");
+      materialCreator.preload();
+      objLoader.setMaterials(materialCreator);
+    } else {
+      objLoader.setMaterials(void 0);
+    }
+    const object = await objLoader.loadAsync(asset.path);
+    if (!mtlText && resolvedTexturePath) {
+      const texture = await modelTextureLoader2.loadAsync(resolvedTexturePath);
+      texture.wrapS = RepeatWrapping3;
+      texture.wrapT = RepeatWrapping3;
+      texture.colorSpace = SRGBColorSpace3;
+      object.traverse((child) => {
+        if (child instanceof Mesh3) {
+          child.material = new MeshStandardMaterial3({
+            map: texture,
+            metalness: 0.12,
+            roughness: 0.76
+          });
+        }
+      });
+    }
+    return object;
+  }
+  return (await gltfLoader3.loadAsync(asset.path)).scene;
+}
+function simplifyModelSceneForRatio(source, ratio) {
+  if (ratio >= 0.98) {
+    return void 0;
+  }
+  const simplifiedRoot = source.clone(true);
+  expandGroupedModelMeshesForLodBake(simplifiedRoot);
+  let simplifiedMeshCount = 0;
+  simplifiedRoot.traverse((child) => {
+    if (!(child instanceof Mesh3)) {
+      return;
+    }
+    if ("isSkinnedMesh" in child && child.isSkinnedMesh) {
+      return;
+    }
+    const simplifiedGeometry = simplifyModelGeometry(child.geometry, ratio);
+    if (!simplifiedGeometry) {
+      return;
+    }
+    child.geometry = simplifiedGeometry;
+    simplifiedMeshCount += 1;
+  });
+  return simplifiedMeshCount > 0 ? simplifiedRoot : void 0;
+}
+function expandGroupedModelMeshesForLodBake(root) {
+  const replacements = [];
+  root.traverse((child) => {
+    if (!(child instanceof Mesh3) || !Array.isArray(child.material) || child.geometry.groups.length <= 1 || !child.parent) {
+      return;
+    }
+    const container = new Group3();
+    container.name = child.name ? `${child.name}:lod-groups` : "lod-groups";
+    container.position.copy(child.position);
+    container.quaternion.copy(child.quaternion);
+    container.scale.copy(child.scale);
+    container.visible = child.visible;
+    container.renderOrder = child.renderOrder;
+    container.userData = structuredClone(child.userData ?? {});
+    child.geometry.groups.forEach((group, groupIndex) => {
+      const material = child.material[group.materialIndex] ?? child.material[0];
+      if (!material) {
+        return;
+      }
+      const partGeometry = extractGeometryGroup(child.geometry, group.start, group.count);
+      const partMesh = new Mesh3(partGeometry, material);
+      partMesh.name = child.name ? `${child.name}:group:${groupIndex}` : `group:${groupIndex}`;
+      partMesh.castShadow = child.castShadow;
+      partMesh.receiveShadow = child.receiveShadow;
+      partMesh.userData = structuredClone(child.userData ?? {});
+      container.add(partMesh);
+    });
+    replacements.push({
+      container,
+      mesh: child,
+      parent: child.parent
+    });
+  });
+  replacements.forEach(({ container, mesh, parent }) => {
+    parent.add(container);
+    parent.remove(mesh);
+  });
+}
+function extractGeometryGroup(geometry, start, count) {
+  const groupGeometry = new BufferGeometry3();
+  const index = geometry.getIndex();
+  const attributes = geometry.attributes;
+  Object.entries(attributes).forEach(([name, attribute]) => {
+    groupGeometry.setAttribute(name, attribute);
+  });
+  if (index) {
+    groupGeometry.setIndex(Array.from(index.array).slice(start, start + count));
+  } else {
+    groupGeometry.setIndex(Array.from({ length: count }, (_, offset) => start + offset));
+  }
+  groupGeometry.computeBoundingBox();
+  groupGeometry.computeBoundingSphere();
+  return groupGeometry;
+}
+function simplifyModelGeometry(geometry, ratio) {
+  const positionAttribute = geometry.getAttribute("position");
+  const vertexCount = positionAttribute?.count ?? 0;
+  if (!positionAttribute || vertexCount < 12 || ratio >= 0.98) {
+    return void 0;
+  }
+  const workingGeometry = geometry.getAttribute("normal") ? geometry : geometry.clone();
+  if (!workingGeometry.getAttribute("normal")) {
+    workingGeometry.computeVertexNormals();
+  }
+  workingGeometry.computeBoundingBox();
+  const bounds = workingGeometry.boundingBox?.clone();
+  if (!bounds) {
+    if (workingGeometry !== geometry) {
+      workingGeometry.dispose();
+    }
+    return void 0;
+  }
+  const normalAttribute = workingGeometry.getAttribute("normal");
+  const uvAttribute = workingGeometry.getAttribute("uv");
+  const index = workingGeometry.getIndex();
+  const simplified = simplifyPrimitiveWithVertexClustering(
+    {
+      indices: index ? Array.from(index.array) : Array.from({ length: vertexCount }, (_, value) => value),
+      material: {
+        color: "#ffffff",
+        id: "material:model-simplify",
+        metallicFactor: 0,
+        name: "Model Simplify",
+        roughnessFactor: 1
+      },
+      normals: Array.from(normalAttribute.array),
+      positions: Array.from(positionAttribute.array),
+      uvs: uvAttribute ? Array.from(uvAttribute.array) : []
+    },
+    ratio,
+    bounds
+  );
+  if (workingGeometry !== geometry) {
+    workingGeometry.dispose();
+  }
+  if (!simplified) {
+    return void 0;
+  }
+  const simplifiedGeometry = createBufferGeometryFromPrimitive(simplified);
+  simplifiedGeometry.computeBoundingBox();
+  simplifiedGeometry.computeBoundingSphere();
+  return simplifiedGeometry;
+}
+async function exportModelSceneAsGlb(object) {
+  try {
+    return await exportGlbBytesFromObject(object);
+  } catch {
+    return await exportGlbBytesFromObject(stripTextureReferencesFromObject(object.clone(true)));
+  }
+}
+async function exportGlbBytesFromObject(object) {
+  const scene = new Scene2();
+  scene.add(object);
+  const exported = await gltfExporter.parseAsync(scene, {
+    binary: true,
+    includeCustomExtensions: false
+  });
+  if (!(exported instanceof ArrayBuffer)) {
+    throw new Error("Expected GLB binary output for baked model LOD.");
+  }
+  return new Uint8Array(exported);
+}
+function stripTextureReferencesFromObject(object) {
+  object.traverse((child) => {
+    if (!(child instanceof Mesh3)) {
+      return;
+    }
+    const strip = (material) => {
+      const clone = material.clone();
+      clone.alphaMap = null;
+      clone.aoMap = null;
+      clone.bumpMap = null;
+      clone.displacementMap = null;
+      clone.emissiveMap = null;
+      clone.lightMap = null;
+      clone.map = null;
+      clone.metalnessMap = null;
+      clone.normalMap = null;
+      clone.roughnessMap = null;
+      return clone;
+    };
+    if (Array.isArray(child.material)) {
+      child.material = child.material.map(
+        (material) => material instanceof MeshStandardMaterial3 ? strip(material) : new MeshStandardMaterial3({
+          color: "color" in material ? material.color : "#7f8ea3",
+          metalness: "metalness" in material && typeof material.metalness === "number" ? material.metalness : 0.1,
+          roughness: "roughness" in material && typeof material.roughness === "number" ? material.roughness : 0.8
+        })
+      );
+      return;
+    }
+    const fallbackMaterial = child.material;
+    child.material = child.material instanceof MeshStandardMaterial3 ? strip(child.material) : new MeshStandardMaterial3({
+      color: "color" in fallbackMaterial ? fallbackMaterial.color : "#7f8ea3",
+      metalness: "metalness" in fallbackMaterial && typeof fallbackMaterial.metalness === "number" ? fallbackMaterial.metalness : 0.1,
+      roughness: "roughness" in fallbackMaterial && typeof fallbackMaterial.roughness === "number" ? fallbackMaterial.roughness : 0.8
+    });
+  });
+  return object;
+}
+function createGeneratedModelLodAsset(asset, name, nodeId, level, bytes) {
+  return {
+    id: `asset:model-lod:${slugify2(`${name}-${nodeId}`)}:${level}`,
+    metadata: {
+      ...asset.metadata,
+      lodGenerated: true,
+      lodLevel: level,
+      lodSourceAssetId: asset.id,
+      materialMtlText: "",
+      modelFormat: "glb",
+      texturePath: ""
+    },
+    path: createBinaryDataUrl(bytes, "model/gltf-binary"),
+    type: "model"
+  };
+}
+function createBinaryDataUrl(bytes, mimeType) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let index = 0; index < bytes.length; index += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));
+  }
+  return `data:${mimeType};base64,${btoa(binary)}`;
+}
+function sanitizeInstanceTransform(transform) {
+  return {
+    position: structuredClone(transform.position),
+    rotation: structuredClone(transform.rotation),
+    scale: structuredClone(transform.scale)
+  };
+}
+function resolveModelAssetFormat(asset) {
+  const format = readModelAssetString(asset, "modelFormat")?.toLowerCase();
+  return format === "obj" || asset.path.toLowerCase().endsWith(".obj") ? "obj" : "gltf";
+}
+function readModelAssetString(asset, key) {
+  const value = asset?.metadata[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function patchMtlTextureReferences2(mtlText, texturePath) {
+  if (!texturePath) {
+    return mtlText;
+  }
+  const mapPattern = /^(map_Ka|map_Kd|map_d|map_Bump|bump)\s+.+$/gm;
+  const hasDiffuseMap = /^map_Kd\s+.+$/m.test(mtlText);
+  const normalized = mtlText.replace(mapPattern, (line) => {
+    if (line.startsWith("map_Kd ")) {
+      return `map_Kd ${texturePath}`;
+    }
+    return line;
+  });
+  return hasDiffuseMap ? normalized : `${normalized.trim()}
+map_Kd ${texturePath}
+`;
+}
+function slugify2(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "model";
+}
+function simplifyExportGeometry(geometry, ratio) {
+  const primitives = geometry.primitives.map((primitive) => simplifyExportPrimitive(primitive, ratio)).filter((primitive) => primitive !== void 0);
+  return primitives.length ? { primitives } : void 0;
+}
+function simplifyExportPrimitive(primitive, ratio) {
+  const vertexCount = Math.floor(primitive.positions.length / 3);
+  const triangleCount = Math.floor(primitive.indices.length / 3);
+  if (vertexCount < 12 || triangleCount < 8 || ratio >= 0.98) {
+    return void 0;
+  }
+  const geometry = createBufferGeometryFromPrimitive(primitive);
+  const boundsTree = new MeshBVH(geometry, { maxLeafSize: 12, setBoundingBox: true });
+  const bounds = boundsTree.getBoundingBox(new Box33());
+  const simplified = simplifyPrimitiveWithVertexClustering(primitive, ratio, bounds);
+  geometry.dispose();
+  if (!simplified) {
+    return void 0;
+  }
+  return simplified;
+}
+function createBufferGeometryFromPrimitive(primitive) {
+  const geometry = new BufferGeometry3();
+  geometry.setAttribute("position", new Float32BufferAttribute3(primitive.positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute3(primitive.normals, 3));
+  if (primitive.uvs.length) {
+    geometry.setAttribute("uv", new Float32BufferAttribute3(primitive.uvs, 2));
+  }
+  geometry.setIndex(primitive.indices);
+  return geometry;
+}
+function simplifyPrimitiveWithVertexClustering(primitive, ratio, bounds) {
+  const targetVertexCount = Math.max(8, Math.floor(primitive.positions.length / 3 * Math.max(0.04, ratio)));
+  const size = bounds.getSize(new Vector34());
+  let resolution = Math.max(1, Math.round(Math.cbrt(targetVertexCount)));
+  let best;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    const simplified = clusterPrimitiveVertices(primitive, bounds, size, Math.max(1, resolution - attempt));
+    if (!simplified) {
+      continue;
+    }
+    best = simplified;
+    if (simplified.positions.length / 3 <= targetVertexCount) {
+      break;
+    }
+  }
+  if (!best) {
+    return void 0;
+  }
+  if (best.positions.length >= primitive.positions.length || best.indices.length >= primitive.indices.length) {
+    return void 0;
+  }
+  return best;
+}
+function clusterPrimitiveVertices(primitive, bounds, size, resolution) {
+  const min = bounds.min;
+  const cellSizeX = Math.max(size.x / resolution, 1e-4);
+  const cellSizeY = Math.max(size.y / resolution, 1e-4);
+  const cellSizeZ = Math.max(size.z / resolution, 1e-4);
+  const vertexCount = primitive.positions.length / 3;
+  const clusters = /* @__PURE__ */ new Map();
+  const clusterKeyByVertex = new Array(vertexCount);
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex += 1) {
+    const positionOffset = vertexIndex * 3;
+    const uvOffset = vertexIndex * 2;
+    const x = primitive.positions[positionOffset];
+    const y = primitive.positions[positionOffset + 1];
+    const z = primitive.positions[positionOffset + 2];
+    const normalX = primitive.normals[positionOffset];
+    const normalY = primitive.normals[positionOffset + 1];
+    const normalZ = primitive.normals[positionOffset + 2];
+    const cellX = Math.floor((x - min.x) / cellSizeX);
+    const cellY = Math.floor((y - min.y) / cellSizeY);
+    const cellZ = Math.floor((z - min.z) / cellSizeZ);
+    const clusterKey = `${cellX}:${cellY}:${cellZ}:${resolveNormalBucket(normalX, normalY, normalZ)}`;
+    const cluster = clusters.get(clusterKey) ?? {
+      count: 0,
+      normalX: 0,
+      normalY: 0,
+      normalZ: 0,
+      positionX: 0,
+      positionY: 0,
+      positionZ: 0,
+      uvX: 0,
+      uvY: 0
+    };
+    cluster.count += 1;
+    cluster.positionX += x;
+    cluster.positionY += y;
+    cluster.positionZ += z;
+    cluster.normalX += normalX;
+    cluster.normalY += normalY;
+    cluster.normalZ += normalZ;
+    cluster.uvX += primitive.uvs[uvOffset] ?? 0;
+    cluster.uvY += primitive.uvs[uvOffset + 1] ?? 0;
+    clusters.set(clusterKey, cluster);
+    clusterKeyByVertex[vertexIndex] = clusterKey;
+  }
+  const remappedIndices = [];
+  const positions = [];
+  const normals = [];
+  const uvs = [];
+  const clusterIndexByKey = /* @__PURE__ */ new Map();
+  const ensureClusterIndex = (clusterKey) => {
+    const existing = clusterIndexByKey.get(clusterKey);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const cluster = clusters.get(clusterKey);
+    if (!cluster || cluster.count === 0) {
+      return void 0;
+    }
+    const averagedNormal = normalizeVec3(vec3(cluster.normalX, cluster.normalY, cluster.normalZ));
+    const index = positions.length / 3;
+    positions.push(cluster.positionX / cluster.count, cluster.positionY / cluster.count, cluster.positionZ / cluster.count);
+    normals.push(averagedNormal.x, averagedNormal.y, averagedNormal.z);
+    uvs.push(cluster.uvX / cluster.count, cluster.uvY / cluster.count);
+    clusterIndexByKey.set(clusterKey, index);
+    return index;
+  };
+  for (let index = 0; index < primitive.indices.length; index += 3) {
+    const a = ensureClusterIndex(clusterKeyByVertex[primitive.indices[index]]);
+    const b = ensureClusterIndex(clusterKeyByVertex[primitive.indices[index + 1]]);
+    const c = ensureClusterIndex(clusterKeyByVertex[primitive.indices[index + 2]]);
+    if (a === void 0 || b === void 0 || c === void 0) {
+      continue;
+    }
+    if (a === b || b === c || a === c) {
+      continue;
+    }
+    if (triangleArea(positions, a, b, c) <= 1e-6) {
+      continue;
+    }
+    remappedIndices.push(a, b, c);
+  }
+  if (remappedIndices.length < 12 || positions.length >= primitive.positions.length) {
+    return void 0;
+  }
+  return {
+    indices: remappedIndices,
+    material: primitive.material,
+    normals,
+    positions,
+    uvs
+  };
+}
+function resolveNormalBucket(x, y, z) {
+  const ax = Math.abs(x);
+  const ay = Math.abs(y);
+  const az = Math.abs(z);
+  if (ax >= ay && ax >= az) {
+    return x >= 0 ? "xp" : "xn";
+  }
+  if (ay >= ax && ay >= az) {
+    return y >= 0 ? "yp" : "yn";
+  }
+  return z >= 0 ? "zp" : "zn";
+}
+function triangleArea(positions, a, b, c) {
+  const ax = positions[a * 3];
+  const ay = positions[a * 3 + 1];
+  const az = positions[a * 3 + 2];
+  const bx = positions[b * 3];
+  const by = positions[b * 3 + 1];
+  const bz = positions[b * 3 + 2];
+  const cx = positions[c * 3];
+  const cy = positions[c * 3 + 1];
+  const cz = positions[c * 3 + 2];
+  const ab = vec3(bx - ax, by - ay, bz - az);
+  const ac = vec3(cx - ax, cy - ay, cz - az);
+  const cross = crossVec3(ab, ac);
+  return Math.sqrt(cross.x * cross.x + cross.y * cross.y + cross.z * cross.z) * 0.5;
+}
+function buildPrimitiveGeometry(shape, size, radialSegments) {
+  const geometry = shape === "cube" ? new BoxGeometry3(Math.abs(size.x), Math.abs(size.y), Math.abs(size.z)) : shape === "sphere" ? new SphereGeometry(Math.max(Math.abs(size.x), Math.abs(size.z)) * 0.5, radialSegments, Math.max(8, Math.floor(radialSegments * 0.75))) : shape === "cylinder" ? new CylinderGeometry(Math.max(Math.abs(size.x), Math.abs(size.z)) * 0.5, Math.max(Math.abs(size.x), Math.abs(size.z)) * 0.5, Math.abs(size.y), radialSegments) : new ConeGeometry(Math.max(Math.abs(size.x), Math.abs(size.z)) * 0.5, Math.abs(size.y), radialSegments);
+  const positionAttribute = geometry.getAttribute("position");
+  const normalAttribute = geometry.getAttribute("normal");
+  const uvAttribute = geometry.getAttribute("uv");
+  const index = geometry.getIndex();
+  const primitive = {
+    indices: index ? Array.from(index.array) : Array.from({ length: positionAttribute.count }, (_, value) => value),
+    normals: Array.from(normalAttribute.array),
+    positions: Array.from(positionAttribute.array),
+    uvs: uvAttribute ? Array.from(uvAttribute.array) : []
+  };
+  geometry.dispose();
+  return primitive;
+}
+async function resolveRuntimeMaterial(material) {
+  const resolved = material ?? {
+    color: "#ffffff",
+    id: "material:fallback:default",
+    metalness: 0.05,
+    name: "Default Material",
+    roughness: 0.8
+  };
+  return {
+    baseColorTexture: await resolveEmbeddedTextureUri(resolved.colorTexture ?? resolveGeneratedBlockoutTexture(resolved)),
+    color: resolved.color,
+    id: resolved.id,
+    metallicFactor: resolved.metalness ?? 0,
+    metallicRoughnessTexture: await createMetallicRoughnessTextureDataUri(
+      resolved.metalnessTexture,
+      resolved.roughnessTexture,
+      resolved.metalness ?? 0,
+      resolved.roughness ?? 0.8
+    ),
+    name: resolved.name,
+    normalTexture: await resolveEmbeddedTextureUri(resolved.normalTexture),
+    roughnessFactor: resolved.roughness ?? 0.8,
+    side: resolved.side
+  };
+}
+function resolveGeneratedBlockoutTexture(material) {
+  return material.category === "blockout" ? createBlockoutTextureDataUri(material.color, material.edgeColor ?? "#2f3540", material.edgeThickness ?? 0.035) : void 0;
+}
+function projectPlanarUvs(vertices, normal, uvScale, uvOffset) {
+  const basis = createFacePlaneBasis(normal);
+  const origin = vertices[0] ?? vec3(0, 0, 0);
+  const scaleX = Math.abs(uvScale?.x ?? 1) <= 1e-4 ? 1 : uvScale?.x ?? 1;
+  const scaleY = Math.abs(uvScale?.y ?? 1) <= 1e-4 ? 1 : uvScale?.y ?? 1;
+  const offsetX = uvOffset?.x ?? 0;
+  const offsetY = uvOffset?.y ?? 0;
+  return vertices.flatMap((vertex) => {
+    const offset = subVec3(vertex, origin);
+    return [dotVec3(offset, basis.u) * scaleX + offsetX, dotVec3(offset, basis.v) * scaleY + offsetY];
+  });
+}
+function createFacePlaneBasis(normal) {
+  const normalizedNormal = normalizeVec3(normal);
+  const reference = Math.abs(normalizedNormal.y) < 0.99 ? vec3(0, 1, 0) : vec3(1, 0, 0);
+  const u = normalizeVec3(crossVec3(reference, normalizedNormal));
+  const v = normalizeVec3(crossVec3(normalizedNormal, u));
+  return { u, v };
+}
+async function resolveEmbeddedTextureUri(source) {
+  if (!source) {
+    return void 0;
+  }
+  if (source.startsWith("data:")) {
+    return source;
+  }
+  const response = await fetch(source);
+  const blob = await response.blob();
+  const buffer = await blob.arrayBuffer();
+  return `data:${blob.type || "application/octet-stream"};base64,${toBase64(new Uint8Array(buffer))}`;
+}
+async function createMetallicRoughnessTextureDataUri(metalnessSource, roughnessSource, metalnessFactor, roughnessFactor) {
+  if (!metalnessSource && !roughnessSource) {
+    return void 0;
+  }
+  if (typeof OffscreenCanvas === "undefined" || typeof createImageBitmap === "undefined") {
+    return void 0;
+  }
+  const [metalness, roughness] = await Promise.all([
+    loadImagePixels(metalnessSource),
+    loadImagePixels(roughnessSource)
+  ]);
+  const width = Math.max(metalness?.width ?? 1, roughness?.width ?? 1);
+  const height = Math.max(metalness?.height ?? 1, roughness?.height ?? 1);
+  const canvas = new OffscreenCanvas(width, height);
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return void 0;
+  }
+  const imageData = context.createImageData(width, height);
+  const metalDefault = Math.round(clamp01(metalnessFactor) * 255);
+  const roughDefault = Math.round(clamp01(roughnessFactor) * 255);
+  for (let index = 0; index < imageData.data.length; index += 4) {
+    imageData.data[index] = 0;
+    imageData.data[index + 1] = roughness?.pixels[index] ?? roughDefault;
+    imageData.data[index + 2] = metalness?.pixels[index] ?? metalDefault;
+    imageData.data[index + 3] = 255;
+  }
+  context.putImageData(imageData, 0, 0);
+  const blob = await canvas.convertToBlob({ type: "image/png" });
+  const buffer = await blob.arrayBuffer();
+  return `data:image/png;base64,${toBase64(new Uint8Array(buffer))}`;
+}
+async function loadImagePixels(source) {
+  if (!source || typeof OffscreenCanvas === "undefined" || typeof createImageBitmap === "undefined") {
+    return void 0;
+  }
+  const response = await fetch(source);
+  const blob = await response.blob();
+  const bitmap = await createImageBitmap(blob);
+  const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    bitmap.close();
+    return void 0;
+  }
+  context.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const imageData = context.getImageData(0, 0, bitmap.width, bitmap.height);
+  return {
+    height: imageData.height,
+    pixels: imageData.data,
+    width: imageData.width
+  };
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function toBase64(bytes) {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+
+// src/bundle.ts
+function createThreeAssetResolver(bundle) {
+  const urlByPath = /* @__PURE__ */ new Map();
+  return {
+    dispose() {
+      urlByPath.forEach((url) => {
+        URL.revokeObjectURL(url);
+      });
+      urlByPath.clear();
+    },
+    resolve(path) {
+      const existing = urlByPath.get(path);
+      if (existing) {
+        return existing;
+      }
+      const file = bundle.files.find((entry) => entry.path === path);
+      if (!file) {
+        return path;
+      }
+      const bytes = new Uint8Array(file.bytes.byteLength);
+      bytes.set(file.bytes);
+      const url = URL.createObjectURL(new Blob([bytes.buffer], { type: file.mimeType }));
+      urlByPath.set(path, url);
+      return url;
+    }
+  };
+}
+function createWebHammerBundleAssetResolver(bundle) {
+  return createThreeAssetResolver(bundle);
+}
+function createWebHammerEngineBundleZip2(bundle, options) {
+  return createWebHammerEngineBundleZip(bundle, options);
+}
+function parseWebHammerEngineBundleZip2(bundleBytes, options) {
+  return parseWebHammerEngineBundleZip(bundleBytes, options);
+}
+function externalizeWebHammerEngineScene2(scene, options) {
+  return externalizeWebHammerEngineScene(scene, options);
+}
+export {
+  applyRuntimeWorldSettingsToThreeScene,
+  applyWebHammerWorldSettings,
+  buildRuntimeBundle,
+  buildRuntimeScene,
+  buildRuntimeWorldIndex,
+  clearRuntimeWorldSettingsFromThreeScene,
+  clearWebHammerWorldSettings,
+  createThreeAssetResolver,
+  createThreeRuntimeObjectFactory,
+  createThreeRuntimeSceneInstance,
+  createWebHammerBundleAssetResolver,
+  createWebHammerEngineBundleZip2 as createWebHammerEngineBundleZip,
+  createWebHammerSceneObjectFactory,
+  externalizeRuntimeAssets,
+  externalizeWebHammerEngineScene2 as externalizeWebHammerEngineScene,
+  extractPhysics,
+  fetchWebHammerEngineScene,
+  findPrimaryLight,
+  isWebHammerEngineBundle,
+  isWebHammerEngineScene,
+  loadThreeRuntimeSceneInstanceFromUrl,
+  loadWebHammerEngineScene,
+  loadWebHammerEngineSceneFromUrl,
+  packRuntimeBundle,
+  parseWebHammerEngineBundleZip2 as parseWebHammerEngineBundleZip,
+  parseWebHammerEngineScene,
+  unpackRuntimeBundle
+};
+//# sourceMappingURL=index.js.map