@ggez/workers 0.1.0

package/dist/index.js

@@ -0,0 +1,2320 @@
+// src/manager.ts
+function createWorkerTaskManager() {
+  let counter = 0;
+  const jobs = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    const snapshot = Array.from(jobs.values());
+    listeners.forEach((listener) => {
+      listener(snapshot);
+    });
+  };
+  return {
+    enqueue(task, label, durationMs = 900) {
+      const id = `job:${counter++}`;
+      jobs.set(id, {
+        id,
+        label,
+        status: "queued",
+        task
+      });
+      emit();
+      queueMicrotask(() => {
+        const job = jobs.get(id);
+        if (!job) {
+          return;
+        }
+        job.status = "running";
+        emit();
+        window.setTimeout(() => {
+          const runningJob = jobs.get(id);
+          if (!runningJob) {
+            return;
+          }
+          runningJob.status = "completed";
+          emit();
+          window.setTimeout(() => {
+            jobs.delete(id);
+            emit();
+          }, 900);
+        }, durationMs);
+      });
+      return id;
+    },
+    getJobs() {
+      return Array.from(jobs.values());
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(Array.from(jobs.values()));
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// ../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 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;
+}
+
+// ../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/bundle.ts
+import { unzipSync, zipSync } from "fflate";
+
+// ../runtime-format/src/types.ts
+var CURRENT_RUNTIME_SCENE_VERSION = 6;
+
+// ../runtime-build/src/bundle.ts
+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 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 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, "");
+}
+
+// ../runtime-build/src/snapshot-build.ts
+import { MeshBVH } from "three-mesh-bvh";
+import {
+  Box3,
+  BoxGeometry,
+  BufferGeometry,
+  ConeGeometry,
+  Float32BufferAttribute,
+  Group,
+  Mesh,
+  MeshStandardMaterial,
+  RepeatWrapping,
+  Scene,
+  SphereGeometry,
+  SRGBColorSpace,
+  TextureLoader,
+  Vector3 as Vector32,
+  CylinderGeometry
+} from "three";
+import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
+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 gltfLoader = new GLTFLoader();
+var gltfExporter = new GLTFExporter();
+var mtlLoader = new MTLLoader();
+var modelTextureLoader = new TextureLoader();
+async function buildRuntimeBundleFromSnapshot(snapshot, options = {}) {
+  return externalizeRuntimeAssets(await buildRuntimeSceneFromSnapshot(snapshot), options);
+}
+async function serializeRuntimeScene(snapshot) {
+  return JSON.stringify(await buildRuntimeSceneFromSnapshot(snapshot));
+}
+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
+  };
+}
+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 OBJLoader();
+    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 = mtlLoader.parse(patchMtlTextureReferences(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 modelTextureLoader.loadAsync(resolvedTexturePath);
+      texture.wrapS = RepeatWrapping;
+      texture.wrapT = RepeatWrapping;
+      texture.colorSpace = SRGBColorSpace;
+      object.traverse((child) => {
+        if (child instanceof Mesh) {
+          child.material = new MeshStandardMaterial({
+            map: texture,
+            metalness: 0.12,
+            roughness: 0.76
+          });
+        }
+      });
+    }
+    return object;
+  }
+  return (await gltfLoader.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 Mesh)) {
+      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 Mesh) || !Array.isArray(child.material) || child.geometry.groups.length <= 1 || !child.parent) {
+      return;
+    }
+    const container = new Group();
+    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 Mesh(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 BufferGeometry();
+  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 Scene();
+  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 Mesh)) {
+      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 MeshStandardMaterial ? strip(material) : new MeshStandardMaterial({
+          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 MeshStandardMaterial ? strip(child.material) : new MeshStandardMaterial({
+      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 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 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 Box3());
+  const simplified = simplifyPrimitiveWithVertexClustering(primitive, ratio, bounds);
+  geometry.dispose();
+  if (!simplified) {
+    return void 0;
+  }
+  return simplified;
+}
+function createBufferGeometryFromPrimitive(primitive) {
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new Float32BufferAttribute(primitive.positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute(primitive.normals, 3));
+  if (primitive.uvs.length) {
+    geometry.setAttribute("uv", new Float32BufferAttribute(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 Vector32());
+  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 BoxGeometry(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/export-tasks.ts
+import { MeshBVH as MeshBVH2 } from "three-mesh-bvh";
+import {
+  Box3 as Box32,
+  BoxGeometry as BoxGeometry2,
+  BufferGeometry as BufferGeometry2,
+  ConeGeometry as ConeGeometry2,
+  CylinderGeometry as CylinderGeometry2,
+  Euler as Euler2,
+  Float32BufferAttribute as Float32BufferAttribute2,
+  Group as Group2,
+  Mesh as Mesh2,
+  MeshStandardMaterial as MeshStandardMaterial2,
+  Quaternion as Quaternion2,
+  RepeatWrapping as RepeatWrapping2,
+  Scene as Scene2,
+  SphereGeometry as SphereGeometry2,
+  SRGBColorSpace as SRGBColorSpace2,
+  TextureLoader as TextureLoader2,
+  Vector3 as Vector33
+} from "three";
+import { GLTFExporter as GLTFExporter2 } from "three/examples/jsm/exporters/GLTFExporter.js";
+import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MTLLoader as MTLLoader2 } from "three/examples/jsm/loaders/MTLLoader.js";
+import { OBJLoader as OBJLoader2 } from "three/examples/jsm/loaders/OBJLoader.js";
+var gltfLoader2 = new GLTFLoader2();
+var gltfExporter2 = new GLTFExporter2();
+var mtlLoader2 = new MTLLoader2();
+var modelTextureLoader2 = new TextureLoader2();
+async function executeWorkerRequest(request) {
+  try {
+    if (request.kind === "whmap-save") {
+      return {
+        id: request.id,
+        kind: request.kind,
+        ok: true,
+        payload: serializeWhmap(request.snapshot)
+      };
+    }
+    if (request.kind === "whmap-load") {
+      return {
+        id: request.id,
+        kind: request.kind,
+        ok: true,
+        payload: parseWhmap(request.text)
+      };
+    }
+    if (request.kind === "engine-export") {
+      return {
+        id: request.id,
+        kind: request.kind,
+        ok: true,
+        payload: await exportEngineBundle(request.snapshot)
+      };
+    }
+    if (request.kind === "ai-model-generate") {
+      return {
+        id: request.id,
+        kind: request.kind,
+        ok: true,
+        payload: await generateAiModel(request.prompt)
+      };
+    }
+    return {
+      id: request.id,
+      kind: request.kind,
+      ok: true,
+      payload: await serializeGltfScene(request.snapshot)
+    };
+  } catch (error) {
+    return {
+      id: request.id,
+      kind: request.kind,
+      ok: false,
+      error: error instanceof Error ? error.message : "Unknown worker error."
+    };
+  }
+}
+async function generateAiModel(prompt) {
+  const response = await fetch(new URL("/api/ai/models", self.location.origin), {
+    body: JSON.stringify({ prompt }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+  const payload = await response.text();
+  if (!response.ok) {
+    try {
+      const parsed = JSON.parse(payload);
+      throw new Error(parsed.error ?? "Failed to generate AI model.");
+    } catch {
+      throw new Error(payload || "Failed to generate AI model.");
+    }
+  }
+  return payload;
+}
+function serializeWhmap(snapshot) {
+  return JSON.stringify(
+    {
+      format: "whmap",
+      version: 1,
+      scene: snapshot
+    },
+    null,
+    2
+  );
+}
+function parseWhmap(text) {
+  const parsed = JSON.parse(text);
+  if (parsed.format !== "whmap" || !parsed.scene) {
+    throw new Error("Invalid .whmap file.");
+  }
+  return parsed.scene;
+}
+async function serializeEngineScene(snapshot) {
+  return serializeRuntimeScene(snapshot);
+}
+async function exportEngineBundle(snapshot) {
+  return buildRuntimeBundleFromSnapshot(snapshot);
+}
+async function serializeGltfScene(snapshot) {
+  const materialsById = new Map(snapshot.materials.map((material) => [material.id, material]));
+  const assetsById = new Map(snapshot.assets.map((asset) => [asset.id, asset]));
+  const exportedNodes = [];
+  for (const node of snapshot.nodes) {
+    if (isGroupNode(node)) {
+      exportedNodes.push({
+        id: node.id,
+        name: node.name,
+        parentId: node.parentId,
+        rotation: toQuaternion(node.transform.rotation),
+        scale: [node.transform.scale.x, node.transform.scale.y, node.transform.scale.z],
+        translation: [node.transform.position.x, node.transform.position.y, node.transform.position.z]
+      });
+      continue;
+    }
+    if (isBrushNode(node) || isMeshNode(node) || isPrimitiveNode(node)) {
+      const geometry = await buildExportGeometry2(node, materialsById);
+      if (geometry.primitives.length === 0) {
+        continue;
+      }
+      exportedNodes.push({
+        id: node.id,
+        mesh: {
+          name: node.name,
+          primitives: geometry.primitives
+        },
+        meshKey: node.id,
+        name: node.name,
+        parentId: node.parentId,
+        rotation: toQuaternion(node.transform.rotation),
+        scale: [node.transform.scale.x, node.transform.scale.y, node.transform.scale.z],
+        translation: [node.transform.position.x, node.transform.position.y, node.transform.position.z]
+      });
+      continue;
+    }
+    if (isInstancingNode(node)) {
+      const sourceNode = resolveInstancingSourceNode(snapshot.nodes, node);
+      if (!sourceNode || !(isBrushNode(sourceNode) || isMeshNode(sourceNode) || isPrimitiveNode(sourceNode) || isModelNode(sourceNode))) {
+        continue;
+      }
+      const instanceTransform = sanitizeInstanceTransform2(node.transform);
+      if (isModelNode(sourceNode)) {
+        const previewColor = assetsById.get(sourceNode.data.assetId)?.metadata.previewColor;
+        const primitive = createCylinderPrimitive();
+        exportedNodes.push({
+          id: node.id,
+          mesh: {
+            name: sourceNode.name,
+            primitives: [
+              {
+                indices: primitive.indices,
+                material: await resolveExportMaterial({
+                  color: typeof previewColor === "string" ? previewColor : "#7f8ea3",
+                  id: `material:model:${sourceNode.id}`,
+                  metalness: 0.1,
+                  name: `${sourceNode.name} Material`,
+                  roughness: 0.55
+                }),
+                normals: computePrimitiveNormals(primitive.positions, primitive.indices),
+                positions: primitive.positions,
+                uvs: computeCylinderUvs(primitive.positions)
+              }
+            ]
+          },
+          meshKey: sourceNode.id,
+          name: node.name,
+          parentId: node.parentId,
+          rotation: toQuaternion(instanceTransform.rotation),
+          scale: [instanceTransform.scale.x, instanceTransform.scale.y, instanceTransform.scale.z],
+          translation: [instanceTransform.position.x, instanceTransform.position.y, instanceTransform.position.z]
+        });
+        continue;
+      }
+      const geometry = await buildExportGeometry2(sourceNode, materialsById);
+      if (geometry.primitives.length === 0) {
+        continue;
+      }
+      exportedNodes.push({
+        id: node.id,
+        mesh: {
+          name: sourceNode.name,
+          primitives: geometry.primitives
+        },
+        meshKey: sourceNode.id,
+        name: node.name,
+        parentId: node.parentId,
+        rotation: toQuaternion(instanceTransform.rotation),
+        scale: [instanceTransform.scale.x, instanceTransform.scale.y, instanceTransform.scale.z],
+        translation: [instanceTransform.position.x, instanceTransform.position.y, instanceTransform.position.z]
+      });
+      continue;
+    }
+    if (isModelNode(node)) {
+      const previewColor = assetsById.get(node.data.assetId)?.metadata.previewColor;
+      const primitive = createCylinderPrimitive();
+      exportedNodes.push({
+        id: node.id,
+        mesh: {
+          name: node.name,
+          primitives: [
+            {
+              indices: primitive.indices,
+              material: await resolveExportMaterial({
+                color: typeof previewColor === "string" ? previewColor : "#7f8ea3",
+                id: `material:model:${node.id}`,
+                metalness: 0.1,
+                name: `${node.name} Material`,
+                roughness: 0.55
+              }),
+              normals: computePrimitiveNormals(primitive.positions, primitive.indices),
+              positions: primitive.positions,
+              uvs: computeCylinderUvs(primitive.positions)
+            }
+          ]
+        },
+        meshKey: node.id,
+        name: node.name,
+        parentId: node.parentId,
+        rotation: toQuaternion(node.transform.rotation),
+        scale: [node.transform.scale.x, node.transform.scale.y, node.transform.scale.z],
+        translation: [node.transform.position.x, node.transform.position.y, node.transform.position.z]
+      });
+    }
+  }
+  return buildGltfDocument(exportedNodes);
+}
+async function buildGltfDocument(exportedNodes) {
+  const nodes = [];
+  const gltfMeshes = [];
+  const materials = [];
+  const textures = [];
+  const images = [];
+  const samplers = [
+    {
+      magFilter: 9729,
+      minFilter: 9987,
+      wrapS: 10497,
+      wrapT: 10497
+    }
+  ];
+  const accessors = [];
+  const bufferViews = [];
+  const chunks = [];
+  const imageIndexByUri = /* @__PURE__ */ new Map();
+  const textureIndexByUri = /* @__PURE__ */ new Map();
+  const materialIndexById = /* @__PURE__ */ new Map();
+  const meshIndexByKey = /* @__PURE__ */ new Map();
+  const pushBuffer = (bytes, target) => {
+    const padding = (4 - bytes.byteLength % 4) % 4;
+    const padded = new Uint8Array(bytes.byteLength + padding);
+    padded.set(bytes);
+    const byteOffset = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    chunks.push(padded);
+    bufferViews.push({
+      buffer: 0,
+      byteLength: bytes.byteLength,
+      byteOffset,
+      ...target ? { target } : {}
+    });
+    return bufferViews.length - 1;
+  };
+  const nodeIndexById = /* @__PURE__ */ new Map();
+  for (const exportedNode of exportedNodes) {
+    let meshIndex;
+    if (exportedNode.mesh) {
+      const meshKey = exportedNode.meshKey ?? exportedNode.id;
+      const cachedMeshIndex = meshIndexByKey.get(meshKey);
+      if (cachedMeshIndex !== void 0) {
+        meshIndex = cachedMeshIndex;
+      } else {
+        const gltfPrimitives = [];
+        for (const primitive of exportedNode.mesh.primitives) {
+          const positions = new Float32Array(primitive.positions);
+          const normals = new Float32Array(primitive.normals);
+          const uvs = new Float32Array(primitive.uvs);
+          const indices = new Uint32Array(primitive.indices);
+          const positionView = pushBuffer(new Uint8Array(positions.buffer.slice(0)), 34962);
+          const normalView = pushBuffer(new Uint8Array(normals.buffer.slice(0)), 34962);
+          const uvView = pushBuffer(new Uint8Array(uvs.buffer.slice(0)), 34962);
+          const indexView = pushBuffer(new Uint8Array(indices.buffer.slice(0)), 34963);
+          const bounds = computePositionBounds(primitive.positions);
+          accessors.push({
+            bufferView: positionView,
+            componentType: 5126,
+            count: positions.length / 3,
+            max: bounds.max,
+            min: bounds.min,
+            type: "VEC3"
+          });
+          const positionAccessor = accessors.length - 1;
+          accessors.push({
+            bufferView: normalView,
+            componentType: 5126,
+            count: normals.length / 3,
+            type: "VEC3"
+          });
+          const normalAccessor = accessors.length - 1;
+          accessors.push({
+            bufferView: uvView,
+            componentType: 5126,
+            count: uvs.length / 2,
+            type: "VEC2"
+          });
+          const uvAccessor = accessors.length - 1;
+          accessors.push({
+            bufferView: indexView,
+            componentType: 5125,
+            count: indices.length,
+            type: "SCALAR"
+          });
+          const indexAccessor = accessors.length - 1;
+          const materialIndex = await ensureGltfMaterial(
+            primitive.material,
+            materials,
+            textures,
+            images,
+            imageIndexByUri,
+            textureIndexByUri,
+            materialIndexById
+          );
+          gltfPrimitives.push({
+            attributes: {
+              NORMAL: normalAccessor,
+              POSITION: positionAccessor,
+              TEXCOORD_0: uvAccessor
+            },
+            indices: indexAccessor,
+            material: materialIndex
+          });
+        }
+        gltfMeshes.push({
+          name: exportedNode.mesh.name,
+          primitives: gltfPrimitives
+        });
+        meshIndex = gltfMeshes.length - 1;
+        meshIndexByKey.set(meshKey, meshIndex);
+      }
+    }
+    nodes.push({
+      ...meshIndex !== void 0 ? { mesh: meshIndex } : {},
+      name: exportedNode.name,
+      ...exportedNode.rotation ? { rotation: exportedNode.rotation } : {},
+      scale: exportedNode.scale,
+      translation: exportedNode.translation
+    });
+    nodeIndexById.set(exportedNode.id, nodes.length - 1);
+  }
+  const rootNodeIndices = [];
+  exportedNodes.forEach((exportedNode, index) => {
+    const parentIndex = exportedNode.parentId ? nodeIndexById.get(exportedNode.parentId) : void 0;
+    if (parentIndex === void 0) {
+      rootNodeIndices.push(index);
+      return;
+    }
+    const parent = nodes[parentIndex];
+    parent.children = [...parent.children ?? [], index];
+  });
+  const totalByteLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const merged = new Uint8Array(totalByteLength);
+  let cursor = 0;
+  chunks.forEach((chunk) => {
+    merged.set(chunk, cursor);
+    cursor += chunk.byteLength;
+  });
+  const gltf = {
+    accessors,
+    asset: {
+      generator: "web-hammer",
+      version: "2.0"
+    },
+    bufferViews,
+    buffers: [
+      {
+        byteLength: merged.byteLength,
+        uri: `data:application/octet-stream;base64,${toBase642(merged)}`
+      }
+    ],
+    images,
+    materials,
+    meshes: gltfMeshes,
+    nodes,
+    samplers,
+    scene: 0,
+    scenes: [
+      {
+        nodes: rootNodeIndices
+      }
+    ],
+    textures
+  };
+  return JSON.stringify(gltf, null, 2);
+}
+async function buildExportGeometry2(node, materialsById) {
+  const fallbackMaterial = await resolveExportMaterial({
+    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 resolveExportMaterial(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]) : projectPlanarUvs2(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 resolveExportMaterial(materialsById.get(node.data.materialId)) : fallbackMaterial;
+    const primitive = buildPrimitiveGeometry2(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())
+  };
+}
+function sanitizeInstanceTransform2(transform) {
+  return {
+    position: structuredClone(transform.position),
+    rotation: structuredClone(transform.rotation),
+    scale: structuredClone(transform.scale)
+  };
+}
+function buildPrimitiveGeometry2(shape, size, radialSegments) {
+  const geometry = shape === "cube" ? new BoxGeometry2(Math.abs(size.x), Math.abs(size.y), Math.abs(size.z)) : shape === "sphere" ? new SphereGeometry2(Math.max(Math.abs(size.x), Math.abs(size.z)) * 0.5, radialSegments, Math.max(8, Math.floor(radialSegments * 0.75))) : shape === "cylinder" ? new CylinderGeometry2(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 ConeGeometry2(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 resolveExportMaterial(material) {
+  const resolved = material ?? {
+    color: "#ffffff",
+    id: "material:fallback:default",
+    metalness: 0.05,
+    name: "Default Material",
+    roughness: 0.8
+  };
+  return {
+    baseColorTexture: await resolveEmbeddedTextureUri2(resolved.colorTexture ?? resolveGeneratedBlockoutTexture2(resolved)),
+    color: resolved.color,
+    id: resolved.id,
+    metallicFactor: resolved.metalness ?? 0,
+    metallicRoughnessTexture: await createMetallicRoughnessTextureDataUri2(
+      resolved.metalnessTexture,
+      resolved.roughnessTexture,
+      resolved.metalness ?? 0,
+      resolved.roughness ?? 0.8
+    ),
+    name: resolved.name,
+    normalTexture: await resolveEmbeddedTextureUri2(resolved.normalTexture),
+    roughnessFactor: resolved.roughness ?? 0.8,
+    side: resolved.side
+  };
+}
+function resolveGeneratedBlockoutTexture2(material) {
+  return material.category === "blockout" ? createBlockoutTextureDataUri(material.color, material.edgeColor ?? "#2f3540", material.edgeThickness ?? 0.035) : void 0;
+}
+async function ensureGltfMaterial(material, materials, textures, images, imageIndexByUri, textureIndexByUri, materialIndexById) {
+  const existing = materialIndexById.get(material.id);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const baseColorTextureIndex = material.baseColorTexture ? ensureGltfTexture(material.baseColorTexture, textures, images, imageIndexByUri, textureIndexByUri) : void 0;
+  const normalTextureIndex = material.normalTexture ? ensureGltfTexture(material.normalTexture, textures, images, imageIndexByUri, textureIndexByUri) : void 0;
+  const metallicRoughnessTextureIndex = material.metallicRoughnessTexture ? ensureGltfTexture(material.metallicRoughnessTexture, textures, images, imageIndexByUri, textureIndexByUri) : void 0;
+  materials.push({
+    name: material.name,
+    normalTexture: normalTextureIndex !== void 0 ? { index: normalTextureIndex } : void 0,
+    pbrMetallicRoughness: {
+      ...baseColorTextureIndex !== void 0 ? { baseColorTexture: { index: baseColorTextureIndex } } : {},
+      ...metallicRoughnessTextureIndex !== void 0 ? { metallicRoughnessTexture: { index: metallicRoughnessTextureIndex } } : {},
+      baseColorFactor: hexToRgba(material.color),
+      metallicFactor: material.metallicFactor,
+      roughnessFactor: material.roughnessFactor
+    }
+  });
+  const index = materials.length - 1;
+  materialIndexById.set(material.id, index);
+  return index;
+}
+function ensureGltfTexture(uri, textures, images, imageIndexByUri, textureIndexByUri) {
+  const existingTexture = textureIndexByUri.get(uri);
+  if (existingTexture !== void 0) {
+    return existingTexture;
+  }
+  const imageIndex = imageIndexByUri.get(uri) ?? images.length;
+  if (!imageIndexByUri.has(uri)) {
+    images.push({ uri });
+    imageIndexByUri.set(uri, imageIndex);
+  }
+  textures.push({ sampler: 0, source: imageIndex });
+  const textureIndex = textures.length - 1;
+  textureIndexByUri.set(uri, textureIndex);
+  return textureIndex;
+}
+function projectPlanarUvs2(vertices, normal, uvScale, uvOffset) {
+  const basis = createFacePlaneBasis2(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 createFacePlaneBasis2(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 resolveEmbeddedTextureUri2(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,${toBase642(new Uint8Array(buffer))}`;
+}
+async function createMetallicRoughnessTextureDataUri2(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([
+    loadImagePixels2(metalnessSource),
+    loadImagePixels2(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(clamp012(metalnessFactor) * 255);
+  const roughDefault = Math.round(clamp012(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,${toBase642(new Uint8Array(buffer))}`;
+}
+async function loadImagePixels2(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 computePrimitiveNormals(positions, indices) {
+  const normals = new Array(positions.length).fill(0);
+  for (let index = 0; index < indices.length; index += 3) {
+    const a = indices[index] * 3;
+    const b = indices[index + 1] * 3;
+    const c = indices[index + 2] * 3;
+    const normal = normalizeVec3(
+      crossVec3(
+        vec3(positions[b] - positions[a], positions[b + 1] - positions[a + 1], positions[b + 2] - positions[a + 2]),
+        vec3(positions[c] - positions[a], positions[c + 1] - positions[a + 1], positions[c + 2] - positions[a + 2])
+      )
+    );
+    [a, b, c].forEach((offset) => {
+      normals[offset] = normal.x;
+      normals[offset + 1] = normal.y;
+      normals[offset + 2] = normal.z;
+    });
+  }
+  return normals;
+}
+function computeCylinderUvs(positions) {
+  const uvs = [];
+  for (let index = 0; index < positions.length; index += 3) {
+    const x = positions[index];
+    const y = positions[index + 1];
+    const z = positions[index + 2];
+    const u = (Math.atan2(z, x) / (Math.PI * 2) + 1) % 1;
+    const v = y > 0 ? 1 : 0;
+    uvs.push(u, v);
+  }
+  return uvs;
+}
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function toQuaternion(rotation) {
+  const quaternion = new Quaternion2().setFromEuler(new Euler2(rotation.x, rotation.y, rotation.z, "XYZ"));
+  return [quaternion.x, quaternion.y, quaternion.z, quaternion.w];
+}
+function createCylinderPrimitive() {
+  const radius = 0.65;
+  const halfHeight = 1.1;
+  const segments = 12;
+  const positions = [];
+  const indices = [];
+  for (let index = 0; index < segments; index += 1) {
+    const angle = index / segments * Math.PI * 2;
+    const x = Math.cos(angle) * radius;
+    const z = Math.sin(angle) * radius;
+    positions.push(x, -halfHeight, z, x, halfHeight, z);
+  }
+  for (let index = 0; index < segments; index += 1) {
+    const next = (index + 1) % segments;
+    const bottom = index * 2;
+    const top = bottom + 1;
+    const nextBottom = next * 2;
+    const nextTop = nextBottom + 1;
+    indices.push(bottom, nextBottom, top, top, nextBottom, nextTop);
+  }
+  return { indices, positions };
+}
+function computePositionBounds(positions) {
+  const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (let index = 0; index < positions.length; index += 3) {
+    min[0] = Math.min(min[0], positions[index]);
+    min[1] = Math.min(min[1], positions[index + 1]);
+    min[2] = Math.min(min[2], positions[index + 2]);
+    max[0] = Math.max(max[0], positions[index]);
+    max[1] = Math.max(max[1], positions[index + 1]);
+    max[2] = Math.max(max[2], positions[index + 2]);
+  }
+  return { max, min };
+}
+function toBase642(bytes) {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function hexToRgba(hex) {
+  const normalized = hex.replace("#", "");
+  const parsed = Number.parseInt(normalized, 16);
+  return [(parsed >> 16 & 255) / 255, (parsed >> 8 & 255) / 255, (parsed & 255) / 255, 1];
+}
+
+// src/tasks.ts
+var workerIds = ["geometryWorker", "meshWorker", "navWorker", "exportWorker"];
+export {
+  createWorkerTaskManager,
+  executeWorkerRequest,
+  exportEngineBundle,
+  parseWhmap,
+  serializeEngineScene,
+  serializeGltfScene,
+  serializeWhmap,
+  workerIds
+};
+//# sourceMappingURL=index.js.map