@ggez/three-runtime 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,225 +1,5 @@
-// ../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 { resolveInstancingSourceNode as resolveInstancingSourceNode2, resolveSceneGraph as resolveSceneGraph2, vec3 as vec32 } from "@ggez/shared";
 import {
   AmbientLight as AmbientLight2,
   BackSide as BackSide2,
@@ -230,7 +10,7 @@ import {
   DirectionalLight as DirectionalLight2,
   DoubleSide as DoubleSide2,
   EquirectangularReflectionMapping,
-  Euler as Euler3,
+  Euler as Euler2,
   Fog,
   Float32BufferAttribute as Float32BufferAttribute2,
   FrontSide as FrontSide2,
@@ -238,108 +18,30 @@ import {
   InstancedMesh as InstancedMesh2,
   HemisphereLight as HemisphereLight2,
   LOD as LOD2,
-  Matrix4 as Matrix43,
+  Matrix4 as Matrix42,
   Mesh as Mesh2,
   MeshStandardMaterial as MeshStandardMaterial2,
   Object3D as Object3D2,
   PointLight as PointLight2,
-  Quaternion as Quaternion3,
+  Quaternion as Quaternion2,
   SRGBColorSpace as SRGBColorSpace2,
   SpotLight as SpotLight2,
   TextureLoader as TextureLoader2,
   RepeatWrapping as RepeatWrapping2,
-  Vector3 as Vector33
+  Vector3 as Vector32
 } 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
-  };
-}
+import {
+  isRuntimeBundle,
+  isRuntimeScene,
+  parseRuntimeScene
+} from "@ggez/runtime-format";
 
 // src/object-factory.ts
+import { resolveInstancingSourceNode, resolveSceneGraph, vec3 } from "@ggez/shared";
 import {
   AmbientLight,
   BackSide,
@@ -348,24 +50,24 @@ import {
   BufferGeometry,
   DirectionalLight,
   DoubleSide,
-  Euler as Euler2,
+  Euler,
   Float32BufferAttribute,
   FrontSide,
   Group,
   HemisphereLight,
   InstancedMesh,
   LOD,
-  Matrix4 as Matrix42,
+  Matrix4,
   Mesh,
   MeshStandardMaterial,
   Object3D,
   PointLight,
-  Quaternion as Quaternion2,
+  Quaternion,
   RepeatWrapping,
   SRGBColorSpace,
   SpotLight,
   TextureLoader,
-  Vector3 as Vector32
+  Vector3
 } from "three";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { MTLLoader } from "three/examples/jsm/loaders/MTLLoader.js";
@@ -374,12 +76,12 @@ 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();
+var tempModelInstanceMatrix = new Matrix4();
+var tempModelChildMatrix = new Matrix4();
+var tempPivotMatrix = new Matrix4();
+var tempInstancePosition = new Vector3();
+var tempInstanceQuaternion = new Quaternion();
+var tempInstanceScale = new Vector3();
 function createWebHammerSceneObjectFactory(engineScene, options = {}) {
   const resources = {
     assetsById: new Map(engineScene.assets.map((asset) => [asset.id, asset])),
@@ -858,7 +560,7 @@ function centerObject(object, center) {
 }
 function computeObjectCenter(object) {
   const box = new Box3().setFromObject(object);
-  const center = box.getCenter(new Vector32());
+  const center = box.getCenter(new Vector3());
   return {
     x: center.x,
     y: center.y,
@@ -939,9 +641,9 @@ function composeGeometryInstanceMatrix(transform, pivot) {
 }
 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"));
+  tempInstanceQuaternion.setFromEuler(new Euler(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);
+  return new Matrix4().compose(tempInstancePosition, tempInstanceQuaternion, tempInstanceScale);
 }
 function resolveSceneLodOptions(lod) {
   if (!lod) {
@@ -1043,7 +745,7 @@ async function createThreeRuntimeSceneInstance(input, options = {}) {
   const lights = [];
   const physicsDescriptors = [];
   const runtimeNodesById = new Map(engineScene.nodes.map((node) => [node.id, node]));
-  const sceneGraph = resolveSceneGraph(engineScene.nodes, engineScene.entities);
+  const sceneGraph = resolveSceneGraph2(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)])
@@ -1280,1461 +982,20 @@ async function loadSkyboxTexture(path, skybox) {
   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
+import {
+  createWebHammerEngineBundleZip as packWebHammerEngineBundle,
+  externalizeWebHammerEngineScene as externalizeWebHammerEngineSceneAssets,
+  parseWebHammerEngineBundleZip as unpackWebHammerEngineBundle
+} from "@ggez/runtime-build";
+import {
+  buildRuntimeBundle,
+  buildRuntimeScene,
+  buildRuntimeWorldIndex,
+  externalizeRuntimeAssets,
+  packRuntimeBundle,
+  unpackRuntimeBundle
+} from "@ggez/runtime-build";
 function createThreeAssetResolver(bundle) {
   const urlByPath = /* @__PURE__ */ new Map();
   return {
@@ -2764,14 +1025,14 @@ function createThreeAssetResolver(bundle) {
 function createWebHammerBundleAssetResolver(bundle) {
   return createThreeAssetResolver(bundle);
 }
-function createWebHammerEngineBundleZip2(bundle, options) {
-  return createWebHammerEngineBundleZip(bundle, options);
+function createWebHammerEngineBundleZip(bundle, options) {
+  return packWebHammerEngineBundle(bundle, options);
 }
-function parseWebHammerEngineBundleZip2(bundleBytes, options) {
-  return parseWebHammerEngineBundleZip(bundleBytes, options);
+function parseWebHammerEngineBundleZip(bundleBytes, options) {
+  return unpackWebHammerEngineBundle(bundleBytes, options);
 }
-function externalizeWebHammerEngineScene2(scene, options) {
-  return externalizeWebHammerEngineScene(scene, options);
+function externalizeWebHammerEngineScene(scene, options) {
+  return externalizeWebHammerEngineSceneAssets(scene, options);
 }
 export {
   applyRuntimeWorldSettingsToThreeScene,
@@ -2785,10 +1046,10 @@ export {
   createThreeRuntimeObjectFactory,
   createThreeRuntimeSceneInstance,
   createWebHammerBundleAssetResolver,
-  createWebHammerEngineBundleZip2 as createWebHammerEngineBundleZip,
+  createWebHammerEngineBundleZip,
   createWebHammerSceneObjectFactory,
   externalizeRuntimeAssets,
-  externalizeWebHammerEngineScene2 as externalizeWebHammerEngineScene,
+  externalizeWebHammerEngineScene,
   extractPhysics,
   fetchWebHammerEngineScene,
   findPrimaryLight,
@@ -2798,7 +1059,7 @@ export {
   loadWebHammerEngineScene,
   loadWebHammerEngineSceneFromUrl,
   packRuntimeBundle,
-  parseWebHammerEngineBundleZip2 as parseWebHammerEngineBundleZip,
+  parseWebHammerEngineBundleZip,
   parseWebHammerEngineScene,
   unpackRuntimeBundle
 };