@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-LBPEZQAF.js

@@ -1,2232 +0,0 @@
-import { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from './chunk-HJJLD366.js';
-import { init_R3FCompiler, init_ObjectPool, ASTNodePool, MATERIAL_PRESETS } from './chunk-HBZYCASG.js';
-import { init_TraitCompositor, TraitCompositor } from './chunk-XSF76QRU.js';
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileMaterialBlock, materialToGLTF } from './chunk-KDB6BUMB.js';
-import { init_CompilerBase, init_ANSNamespace, CompilerBase, ANSCapabilityPath } from './chunk-QWKUKVRE.js';
-
-// src/compiler/GLTFPipeline.ts
-init_TraitCompositor();
-init_R3FCompiler();
-init_CompilerBase();
-init_ANSNamespace();
-init_DomainBlockCompilerMixin();
-
-// src/compiler/gltf/extensions.ts
-function createEmissiveStrengthExtension(strength) {
-  return {
-    KHR_materials_emissive_strength: {
-      emissiveStrength: Math.max(0, strength)
-    }
-  };
-}
-function createClearcoatExtension(options) {
-  return {
-    KHR_materials_clearcoat: {
-      clearcoatFactor: options.factor ?? 1,
-      clearcoatRoughnessFactor: options.roughness ?? 0
-    }
-  };
-}
-function createTransmissionExtension(factor) {
-  return {
-    KHR_materials_transmission: {
-      transmissionFactor: Math.max(0, Math.min(1, factor))
-    }
-  };
-}
-function createIORExtension(ior) {
-  return {
-    KHR_materials_ior: {
-      ior: Math.max(1, ior)
-    }
-  };
-}
-function createSheenExtension(options) {
-  return {
-    KHR_materials_sheen: {
-      sheenColorFactor: options.color ?? [1, 1, 1],
-      sheenRoughnessFactor: options.roughness ?? 0.5
-    }
-  };
-}
-function createAnisotropyExtension(options) {
-  return {
-    KHR_materials_anisotropy: {
-      anisotropyStrength: Math.max(0, Math.min(1, options.strength ?? 0.5)),
-      anisotropyRotation: options.rotation ?? 0
-    }
-  };
-}
-function createVolumeExtension(options) {
-  return {
-    KHR_materials_volume: {
-      thicknessFactor: options.thickness ?? 1,
-      attenuationDistance: options.attenuationDistance ?? 1,
-      attenuationColor: options.attenuationColor ?? [1, 1, 1]
-    }
-  };
-}
-function createIridescenceExtension(options) {
-  return {
-    KHR_materials_iridescence: {
-      iridescenceFactor: options.factor ?? 1,
-      iridescenceIor: options.ior ?? 1.3,
-      iridescenceThicknessMinimum: options.thicknessRange?.[0] ?? 100,
-      iridescenceThicknessMaximum: options.thicknessRange?.[1] ?? 400
-    }
-  };
-}
-function collectUsedExtensions(gltf) {
-  const extensions = /* @__PURE__ */ new Set();
-  const materials = gltf.materials;
-  if (materials) {
-    for (const material of materials) {
-      if (material.extensions) {
-        Object.keys(material.extensions).forEach((ext) => extensions.add(ext));
-      }
-    }
-  }
-  const nodes = gltf.nodes;
-  if (nodes) {
-    for (const node of nodes) {
-      if (node.extensions) {
-        Object.keys(node.extensions).forEach((ext) => extensions.add(ext));
-      }
-    }
-  }
-  if (gltf.extensions) {
-    Object.keys(gltf.extensions).forEach((ext) => extensions.add(ext));
-  }
-  return Array.from(extensions);
-}
-function isExtensionRequired(extension) {
-  const requiredExtensions = [
-    "KHR_draco_mesh_compression",
-    "KHR_mesh_quantization",
-    "KHR_texture_basisu"
-  ];
-  return requiredExtensions.includes(extension);
-}
-function declareExtensions(gltf) {
-  const usedExtensions = collectUsedExtensions(gltf);
-  if (usedExtensions.length === 0) return;
-  gltf.extensionsUsed = usedExtensions;
-  const required = usedExtensions.filter(isExtensionRequired);
-  if (required.length > 0) {
-    gltf.extensionsRequired = required;
-  }
-}
-
-// src/compiler/GLTFPipeline.ts
-init_ObjectPool();
-var gltfNodePool = new ASTNodePool(
-  () => ({ name: "" }),
-  (node) => {
-    node.name = "";
-    node.translation = void 0;
-    node.rotation = void 0;
-    node.scale = void 0;
-    node.mesh = void 0;
-    node.skin = void 0;
-    node.children = void 0;
-    node.camera = void 0;
-    node.extras = void 0;
-  },
-  0
-  // Was 10000 — demand-allocate instead of pre-allocating
-);
-var PRIMITIVE_GENERATORS = {
-  cube: generateCubeGeometry,
-  box: generateCubeGeometry,
-  sphere: generateSphereGeometry,
-  orb: generateSphereGeometry,
-  cylinder: generateCylinderGeometry,
-  cone: generateConeGeometry,
-  pyramid: generateConeGeometry,
-  plane: generatePlaneGeometry,
-  ground: generatePlaneGeometry
-};
-function generateScaleTexture(size = 512, baseColor = [30, 15, 61], borderColor = [20, 12, 40], highlightColor = [70, 50, 120]) {
-  const data = new Uint8Array(size * size * 4);
-  const scaleSize = size / 16;
-  const hexH = scaleSize;
-  const hexW = scaleSize * Math.sqrt(3);
-  function scaleHash(row, col) {
-    let h = row * 73856093 ^ col * 19349663;
-    h = (h >> 16 ^ h) * 73244475;
-    h = (h >> 16 ^ h) * 73244475;
-    return (h >> 16 ^ h) & 255;
-  }
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      const row = Math.floor(y / (hexH * 0.75));
-      const isOddRow = row % 2 === 1;
-      const xOff = isOddRow ? hexW * 0.5 : 0;
-      const col = Math.floor((x + xOff) / hexW);
-      const cx = col * hexW - xOff + hexW * 0.5;
-      const cy = row * hexH * 0.75 + hexH * 0.5;
-      const dx = (x - cx) / (hexW * 0.5);
-      const dy = (y - cy) / (hexH * 0.5);
-      const q = Math.abs(dx);
-      const r = Math.abs(dy);
-      const hexDist = Math.max(q, (q + r * Math.sqrt(3)) / 2);
-      const jitter = (scaleHash(row, col) / 255 - 0.5) * 40;
-      const jR = Math.round(jitter * 0.4);
-      const jG = Math.round(jitter * 0.3);
-      const jB = Math.round(jitter * 0.6);
-      const idx = (y * size + x) * 4;
-      if (hexDist > 0.94) {
-        data[idx] = Math.max(0, borderColor[0] + jR);
-        data[idx + 1] = Math.max(0, borderColor[1] + jG);
-        data[idx + 2] = Math.max(0, borderColor[2] + jB);
-        data[idx + 3] = 255;
-      } else if (hexDist < 0.12) {
-        const t = hexDist / 0.12;
-        const specR = 100, specG = 80, specB = 160;
-        data[idx] = Math.min(255, Math.round(specR * (1 - t) + highlightColor[0] * t) + jR);
-        data[idx + 1] = Math.min(255, Math.round(specG * (1 - t) + highlightColor[1] * t) + jG);
-        data[idx + 2] = Math.min(255, Math.round(specB * (1 - t) + highlightColor[2] * t) + jB);
-        data[idx + 3] = 255;
-      } else if (hexDist < 0.35) {
-        const t = (hexDist - 0.12) / 0.23;
-        data[idx] = Math.min(255, Math.round(highlightColor[0] * (1 - t) + baseColor[0] * t) + jR);
-        data[idx + 1] = Math.min(
-          255,
-          Math.round(highlightColor[1] * (1 - t) + baseColor[1] * t) + jG
-        );
-        data[idx + 2] = Math.min(
-          255,
-          Math.round(highlightColor[2] * (1 - t) + baseColor[2] * t) + jB
-        );
-        data[idx + 3] = 255;
-      } else {
-        const t = (hexDist - 0.35) / 0.59;
-        data[idx] = Math.max(
-          0,
-          Math.min(255, Math.round(baseColor[0] * (1 - t * 0.3) + borderColor[0] * (t * 0.3)) + jR)
-        );
-        data[idx + 1] = Math.max(
-          0,
-          Math.min(255, Math.round(baseColor[1] * (1 - t * 0.3) + borderColor[1] * (t * 0.3)) + jG)
-        );
-        data[idx + 2] = Math.max(
-          0,
-          Math.min(255, Math.round(baseColor[2] * (1 - t * 0.3) + borderColor[2] * (t * 0.3)) + jB)
-        );
-        data[idx + 3] = 255;
-      }
-    }
-  }
-  return data;
-}
-function generateScaleNormalMap(size = 512) {
-  const data = new Uint8Array(size * size * 4);
-  const scaleSize = size / 16;
-  const hexH = scaleSize;
-  const hexW = scaleSize * Math.sqrt(3);
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      const row = Math.floor(y / (hexH * 0.75));
-      const isOddRow = row % 2 === 1;
-      const xOff = isOddRow ? hexW * 0.5 : 0;
-      const col = Math.floor((x + xOff) / hexW);
-      const cx = col * hexW - xOff + hexW * 0.5;
-      const cy = row * hexH * 0.75 + hexH * 0.5;
-      const dx = (x - cx) / (hexW * 0.5);
-      const dy = (y - cy) / (hexH * 0.5);
-      const q = Math.abs(dx);
-      const r = Math.abs(dy);
-      const hexDist = Math.max(q, (q + r * Math.sqrt(3)) / 2);
-      const idx = (y * size + x) * 4;
-      let nx = 0, ny = 0, nz = 1;
-      if (hexDist > 0.92 && hexDist < 1) {
-        const len = Math.sqrt(dx * dx + dy * dy) || 1;
-        const strength = 0.55;
-        nx = dx / len * strength;
-        ny = dy / len * strength;
-        nz = Math.sqrt(Math.max(0, 1 - nx * nx - ny * ny));
-      } else if (hexDist < 0.5) {
-        const strength = 0.25;
-        nx = -dx * strength;
-        ny = -dy * strength;
-        nz = Math.sqrt(Math.max(0, 1 - nx * nx - ny * ny));
-      }
-      data[idx] = Math.round((nx * 0.5 + 0.5) * 255);
-      data[idx + 1] = Math.round((ny * 0.5 + 0.5) * 255);
-      data[idx + 2] = Math.round((nz * 0.5 + 0.5) * 255);
-      data[idx + 3] = 255;
-    }
-  }
-  return data;
-}
-function encodePNG(pixels, width, height) {
-  const rowSize = width * 4 + 1;
-  const rawData = new Uint8Array(rowSize * height);
-  for (let y = 0; y < height; y++) {
-    rawData[y * rowSize] = 0;
-    rawData.set(pixels.slice(y * width * 4, (y + 1) * width * 4), y * rowSize + 1);
-  }
-  const deflated = deflateStored(rawData);
-  const crcTable = [];
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    crcTable[n] = c;
-  }
-  function crc32(buf) {
-    let crc = 4294967295;
-    for (let i = 0; i < buf.length; i++) crc = crcTable[(crc ^ buf[i]) & 255] ^ crc >>> 8;
-    return (crc ^ 4294967295) >>> 0;
-  }
-  function writeChunk(type, data) {
-    const chunk = new Uint8Array(4 + 4 + data.length + 4);
-    const dv = new DataView(chunk.buffer);
-    dv.setUint32(0, data.length);
-    for (let i = 0; i < 4; i++) chunk[4 + i] = type.charCodeAt(i);
-    chunk.set(data, 8);
-    const crcInput = new Uint8Array(4 + data.length);
-    crcInput.set(chunk.slice(4, 8));
-    crcInput.set(data, 4);
-    dv.setUint32(8 + data.length, crc32(crcInput));
-    return chunk;
-  }
-  const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-  const ihdr = new Uint8Array(13);
-  const ihdrDV = new DataView(ihdr.buffer);
-  ihdrDV.setUint32(0, width);
-  ihdrDV.setUint32(4, height);
-  ihdr[8] = 8;
-  ihdr[9] = 6;
-  ihdr[10] = 0;
-  ihdr[11] = 0;
-  ihdr[12] = 0;
-  const ihdrChunk = writeChunk("IHDR", ihdr);
-  const idatChunk = writeChunk("IDAT", deflated);
-  const iendChunk = writeChunk("IEND", new Uint8Array(0));
-  const png = new Uint8Array(
-    signature.length + ihdrChunk.length + idatChunk.length + iendChunk.length
-  );
-  let offset = 0;
-  png.set(signature, offset);
-  offset += signature.length;
-  png.set(ihdrChunk, offset);
-  offset += ihdrChunk.length;
-  png.set(idatChunk, offset);
-  offset += idatChunk.length;
-  png.set(iendChunk, offset);
-  return png;
-}
-function decimateGeometry(geometry, ratio) {
-  const cellSize = Math.max(0.01, (1 - ratio) * 0.3);
-  const positions = geometry.positions;
-  const normals = geometry.normals;
-  const uvs = geometry.uvs;
-  const indices = geometry.indices;
-  const vertCount = positions.length / 3;
-  const cellMap = /* @__PURE__ */ new Map();
-  const remap = new Int32Array(vertCount);
-  const newPositions = [];
-  const newNormals = [];
-  const newUVs = [];
-  let newIdx = 0;
-  for (let i = 0; i < vertCount; i++) {
-    const px = positions[i * 3], py = positions[i * 3 + 1], pz = positions[i * 3 + 2];
-    const cx = Math.round(px / cellSize), cy = Math.round(py / cellSize), cz = Math.round(pz / cellSize);
-    const key = `${cx},${cy},${cz}`;
-    if (cellMap.has(key)) {
-      remap[i] = cellMap.get(key);
-    } else {
-      cellMap.set(key, newIdx);
-      remap[i] = newIdx;
-      newPositions.push(px, py, pz);
-      newNormals.push(normals[i * 3], normals[i * 3 + 1], normals[i * 3 + 2]);
-      newUVs.push(uvs[i * 2], uvs[i * 2 + 1]);
-      newIdx++;
-    }
-  }
-  const newIndices = [];
-  for (let i = 0; i < indices.length; i += 3) {
-    const a = remap[indices[i]], b = remap[indices[i + 1]], c = remap[indices[i + 2]];
-    if (a !== b && b !== c && a !== c) {
-      newIndices.push(a, b, c);
-    }
-  }
-  const newVertexCount = newPositions.length / 3;
-  const IndexArrayType = newVertexCount > 65535 ? Uint32Array : Uint16Array;
-  return {
-    positions: new Float32Array(newPositions),
-    normals: new Float32Array(newNormals),
-    uvs: new Float32Array(newUVs),
-    indices: new IndexArrayType(newIndices)
-  };
-}
-var DRAGON_SKELETON = [
-  { name: "Root", position: [0, 2.5, 0] },
-  { name: "Spine", position: [0, 2.5, 0], parent: "Root" },
-  { name: "Neck", position: [0, 3.5, 2], parent: "Spine" },
-  { name: "Head", position: [0, 4.5, 4.2], parent: "Neck" },
-  { name: "Jaw", position: [0, 4.2, 4.6], parent: "Head" },
-  { name: "Tail1", position: [0, 2.2, -2], parent: "Spine" },
-  { name: "Tail2", position: [0, 1, -3.5], parent: "Tail1" },
-  { name: "TailTip", position: [0, -0.05, -4.6], parent: "Tail2" },
-  { name: "LeftWing", position: [-1.2, 3, 0.2], parent: "Spine" },
-  { name: "LeftWingTip", position: [-2.6, 3.8, 0.2], parent: "LeftWing" },
-  { name: "RightWing", position: [1.2, 3, 0.2], parent: "Spine" },
-  { name: "RightWingTip", position: [2.6, 3.8, 0.2], parent: "RightWing" },
-  { name: "LeftFrontLeg", position: [-0.9, 1.6, 1.2], parent: "Spine" },
-  { name: "LeftFrontFoot", position: [-0.95, 0.15, 1.4], parent: "LeftFrontLeg" },
-  { name: "RightFrontLeg", position: [0.9, 1.6, 1.2], parent: "Spine" },
-  { name: "RightFrontFoot", position: [0.95, 0.15, 1.4], parent: "RightFrontLeg" },
-  { name: "LeftBackLeg", position: [-0.9, 1.5, -1], parent: "Spine" },
-  { name: "LeftBackFoot", position: [-0.95, 0.1, -1.15], parent: "LeftBackLeg" },
-  { name: "RightBackLeg", position: [0.9, 1.5, -1], parent: "Spine" },
-  { name: "RightBackFoot", position: [0.95, 0.1, -1.15], parent: "RightBackLeg" }
-];
-function deflateStored(data) {
-  const BLOCK_MAX = 65535;
-  const numBlocks = Math.ceil(data.length / BLOCK_MAX) || 1;
-  let size = 2 + 4;
-  for (let i = 0; i < numBlocks; i++) {
-    size += 5;
-    const blockLen = Math.min(BLOCK_MAX, data.length - i * BLOCK_MAX);
-    size += blockLen;
-  }
-  const out = new Uint8Array(size);
-  let pos = 0;
-  out[pos++] = 120;
-  out[pos++] = 1;
-  for (let i = 0; i < numBlocks; i++) {
-    const blockStart = i * BLOCK_MAX;
-    const blockLen = Math.min(BLOCK_MAX, data.length - blockStart);
-    const isLast = i === numBlocks - 1;
-    out[pos++] = isLast ? 1 : 0;
-    out[pos++] = blockLen & 255;
-    out[pos++] = blockLen >> 8 & 255;
-    out[pos++] = ~blockLen & 255;
-    out[pos++] = ~blockLen >> 8 & 255;
-    out.set(data.slice(blockStart, blockStart + blockLen), pos);
-    pos += blockLen;
-  }
-  let a = 1, b = 0;
-  for (let i = 0; i < data.length; i++) {
-    a = (a + data[i]) % 65521;
-    b = (b + a) % 65521;
-  }
-  const adler = (b << 16 | a) >>> 0;
-  out[pos++] = adler >> 24 & 255;
-  out[pos++] = adler >> 16 & 255;
-  out[pos++] = adler >> 8 & 255;
-  out[pos++] = adler & 255;
-  return out;
-}
-var ADVANCED_GEOMETRY_TYPES = /* @__PURE__ */ new Set(["spline", "membrane", "hull", "blob", "metaball"]);
-function generateCubeGeometry(scale) {
-  const [sx, sy, sz] = scale.map((s) => s * 0.5);
-  const positions = new Float32Array([
-    // Front face
-    -sx,
-    -sy,
-    sz,
-    sx,
-    -sy,
-    sz,
-    sx,
-    sy,
-    sz,
-    -sx,
-    sy,
-    sz,
-    // Back face
-    -sx,
-    -sy,
-    -sz,
-    -sx,
-    sy,
-    -sz,
-    sx,
-    sy,
-    -sz,
-    sx,
-    -sy,
-    -sz,
-    // Top face
-    -sx,
-    sy,
-    -sz,
-    -sx,
-    sy,
-    sz,
-    sx,
-    sy,
-    sz,
-    sx,
-    sy,
-    -sz,
-    // Bottom face
-    -sx,
-    -sy,
-    -sz,
-    sx,
-    -sy,
-    -sz,
-    sx,
-    -sy,
-    sz,
-    -sx,
-    -sy,
-    sz,
-    // Right face
-    sx,
-    -sy,
-    -sz,
-    sx,
-    sy,
-    -sz,
-    sx,
-    sy,
-    sz,
-    sx,
-    -sy,
-    sz,
-    // Left face
-    -sx,
-    -sy,
-    -sz,
-    -sx,
-    -sy,
-    sz,
-    -sx,
-    sy,
-    sz,
-    -sx,
-    sy,
-    -sz
-  ]);
-  const normals = new Float32Array([
-    // Front
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    // Back
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    // Top
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    // Bottom
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    // Right
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    // Left
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0,
-    -1,
-    0,
-    0
-  ]);
-  const uvs = new Float32Array([
-    // Front
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    0,
-    1,
-    // Back
-    1,
-    0,
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    // Top
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    // Bottom
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    // Right
-    1,
-    0,
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    // Left
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    0,
-    1
-  ]);
-  const indices = new Uint16Array([
-    0,
-    1,
-    2,
-    0,
-    2,
-    3,
-    // Front
-    4,
-    5,
-    6,
-    4,
-    6,
-    7,
-    // Back
-    8,
-    9,
-    10,
-    8,
-    10,
-    11,
-    // Top
-    12,
-    13,
-    14,
-    12,
-    14,
-    15,
-    // Bottom
-    16,
-    17,
-    18,
-    16,
-    18,
-    19,
-    // Right
-    20,
-    21,
-    22,
-    20,
-    22,
-    23
-    // Left
-  ]);
-  return { positions, normals, uvs, indices };
-}
-function generateSphereGeometry(scale) {
-  const sx = scale[0] * 0.5;
-  const sy = scale[1] * 0.5;
-  const sz = scale[2] * 0.5;
-  const segments = 32;
-  const rings = 24;
-  const positions = [];
-  const normals = [];
-  const uvs = [];
-  const indices = [];
-  for (let y = 0; y <= rings; y++) {
-    const v = y / rings;
-    const theta = v * Math.PI;
-    for (let x = 0; x <= segments; x++) {
-      const u = x / segments;
-      const phi = u * Math.PI * 2;
-      const nx = Math.sin(theta) * Math.cos(phi);
-      const ny = Math.cos(theta);
-      const nz = Math.sin(theta) * Math.sin(phi);
-      positions.push(nx * sx);
-      positions.push(ny * sy);
-      positions.push(nz * sz);
-      normals.push(nx, ny, nz);
-      uvs.push(u, 1 - v);
-    }
-  }
-  for (let y = 0; y < rings; y++) {
-    for (let x = 0; x < segments; x++) {
-      const a = y * (segments + 1) + x;
-      const b = a + segments + 1;
-      indices.push(a, b, a + 1);
-      indices.push(b, b + 1, a + 1);
-    }
-  }
-  return {
-    positions: new Float32Array(positions),
-    normals: new Float32Array(normals),
-    uvs: new Float32Array(uvs),
-    indices: new Uint16Array(indices)
-  };
-}
-function generateCylinderGeometry(scale) {
-  const radiusTop = scale[0] * 0.5;
-  const radiusBottom = scale[2] * 0.5;
-  const height = scale[1];
-  const segments = 32;
-  const positions = [];
-  const normals = [];
-  const uvs = [];
-  const indices = [];
-  const halfHeight = height / 2;
-  for (let y = 0; y <= 1; y++) {
-    const radius = y === 0 ? radiusBottom : radiusTop;
-    const posY = y === 0 ? -halfHeight : halfHeight;
-    for (let x = 0; x <= segments; x++) {
-      const u = x / segments;
-      const theta = u * Math.PI * 2;
-      const cosTheta = Math.cos(theta);
-      const sinTheta = Math.sin(theta);
-      positions.push(radius * cosTheta, posY, radius * sinTheta);
-      normals.push(cosTheta, 0, sinTheta);
-      uvs.push(u, y);
-    }
-  }
-  for (let x = 0; x < segments; x++) {
-    const a = x;
-    const b = x + segments + 1;
-    indices.push(a, b, a + 1);
-    indices.push(b, b + 1, a + 1);
-  }
-  const topCenterIndex = positions.length / 3;
-  positions.push(0, halfHeight, 0);
-  normals.push(0, 1, 0);
-  uvs.push(0.5, 0.5);
-  for (let x = 0; x <= segments; x++) {
-    const u = x / segments;
-    const theta = u * Math.PI * 2;
-    positions.push(radiusTop * Math.cos(theta), halfHeight, radiusTop * Math.sin(theta));
-    normals.push(0, 1, 0);
-    uvs.push(Math.cos(theta) * 0.5 + 0.5, Math.sin(theta) * 0.5 + 0.5);
-  }
-  for (let x = 0; x < segments; x++) {
-    indices.push(topCenterIndex, topCenterIndex + x + 1, topCenterIndex + x + 2);
-  }
-  const bottomCenterIndex = positions.length / 3;
-  positions.push(0, -halfHeight, 0);
-  normals.push(0, -1, 0);
-  uvs.push(0.5, 0.5);
-  for (let x = 0; x <= segments; x++) {
-    const u = x / segments;
-    const theta = u * Math.PI * 2;
-    positions.push(radiusBottom * Math.cos(theta), -halfHeight, radiusBottom * Math.sin(theta));
-    normals.push(0, -1, 0);
-    uvs.push(Math.cos(theta) * 0.5 + 0.5, Math.sin(theta) * 0.5 + 0.5);
-  }
-  for (let x = 0; x < segments; x++) {
-    indices.push(bottomCenterIndex, bottomCenterIndex + x + 2, bottomCenterIndex + x + 1);
-  }
-  return {
-    positions: new Float32Array(positions),
-    normals: new Float32Array(normals),
-    uvs: new Float32Array(uvs),
-    indices: new Uint16Array(indices)
-  };
-}
-function generateConeGeometry(scale) {
-  return generateCylinderGeometry([1e-3, scale[1], scale[2]]);
-}
-function generatePlaneGeometry(scale) {
-  const [sx, _, sz] = scale.map((s) => s * 0.5);
-  const positions = new Float32Array([
-    -sx,
-    0,
-    -sz,
-    sx,
-    0,
-    -sz,
-    sx,
-    0,
-    sz,
-    -sx,
-    0,
-    sz
-  ]);
-  const normals = new Float32Array([
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0
-  ]);
-  const uvs = new Float32Array([
-    0,
-    0,
-    1,
-    0,
-    1,
-    1,
-    0,
-    1
-  ]);
-  const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
-  return { positions, normals, uvs, indices };
-}
-var INITIAL_COMPILE_BUFFER_SIZE = 1024 * 1024;
-var MAX_RETAINED_BUFFER_SIZE = 1024 * 1024 * 20;
-var SHARED_COMPILE_BUFFER = new Uint8Array(INITIAL_COMPILE_BUFFER_SIZE);
-var GLTFPipeline = class extends CompilerBase {
-  constructor(options = {}) {
-    super();
-    this.compilerName = "GLTFPipeline";
-    this.bufferByteLength = 0;
-    this.accessors = [];
-    this.bufferViews = [];
-    this.meshes = [];
-    this.materials = [];
-    this.nodes = [];
-    this.scenes = [];
-    this.animations = [];
-    this.materialMap = /* @__PURE__ */ new Map();
-    this.images = [];
-    this.textures = [];
-    this.samplers = [];
-    this.scaleTextureIndex = -1;
-    this.scaleNormalTextureIndex = -1;
-    this.textureIndexMap = /* @__PURE__ */ new Map();
-    this.stats = {
-      nodeCount: 0,
-      meshCount: 0,
-      materialCount: 0,
-      textureCount: 0,
-      animationCount: 0,
-      totalVertices: 0,
-      totalTriangles: 0,
-      fileSizeBytes: 0
-    };
-    this._lodCoverages = null;
-    this._skins = null;
-    this._jointStartIndex = 0;
-    this.options = {
-      format: options.format ?? "glb",
-      dracoCompression: options.dracoCompression ?? false,
-      quantize: options.quantize ?? true,
-      prune: options.prune ?? true,
-      dedupe: options.dedupe ?? true,
-      embedTextures: options.embedTextures ?? true,
-      textureData: options.textureData ?? {},
-      generator: options.generator ?? "HoloScript GLTFPipeline v1.0.0",
-      copyright: options.copyright ?? ""
-    };
-    this.compositor = new TraitCompositor();
-  }
-  getRequiredCapability() {
-    return ANSCapabilityPath.GLTF;
-  }
-  get bufferData() {
-    return SHARED_COMPILE_BUFFER;
-  }
-  set bufferData(v) {
-    SHARED_COMPILE_BUFFER = v;
-  }
-  ensureBufferCapacity(needed) {
-    if (this.bufferByteLength + needed > this.bufferData.length) {
-      const newLen = Math.max(this.bufferData.length * 2, this.bufferByteLength + needed);
-      const newArr = new Uint8Array(newLen);
-      newArr.set(this.bufferData.subarray(0, this.bufferByteLength));
-      this.bufferData = newArr;
-    }
-  }
-  appendToBuffer(data) {
-    this.ensureBufferCapacity(data.length);
-    this.bufferData.set(data, this.bufferByteLength);
-    this.bufferByteLength += data.length;
-  }
-  padBuffer(alignment) {
-    const remainder = this.bufferByteLength % alignment;
-    if (remainder !== 0) {
-      const padding = alignment - remainder;
-      this.ensureBufferCapacity(padding);
-      this.bufferByteLength += padding;
-    }
-  }
-  /**
-   * Global smooth normals pass.
-   * Finds vertices at the same 3D position across all meshes and averages
-   * their normals. This eliminates hard seams where separate meshes meet
-   * (e.g., neck spline meets the head sphere).
-   */
-  smoothNormalsGlobal() {
-    const QUANT = 100;
-    const posMap = /* @__PURE__ */ new Map();
-    for (const mesh of this.meshes) {
-      for (const prim of mesh.primitives) {
-        const posIdx = prim.attributes.POSITION;
-        const nrmIdx = prim.attributes.NORMAL;
-        if (posIdx === void 0 || nrmIdx === void 0) continue;
-        const posAcc = this.accessors[posIdx];
-        const nrmAcc = this.accessors[nrmIdx];
-        if (!posAcc || !nrmAcc) continue;
-        const posBV = this.bufferViews[posAcc.bufferView];
-        const nrmBV = this.bufferViews[nrmAcc.bufferView];
-        if (!posBV || !nrmBV) continue;
-        const count = posAcc.count;
-        for (let i = 0; i < count; i++) {
-          const pOff = posBV.byteOffset + i * 12;
-          const px = this.readFloat32(pOff);
-          const py = this.readFloat32(pOff + 4);
-          const pz = this.readFloat32(pOff + 8);
-          const nOff = nrmBV.byteOffset + i * 12;
-          const nx = this.readFloat32(nOff);
-          const ny = this.readFloat32(nOff + 4);
-          const nz = this.readFloat32(nOff + 8);
-          const key = `${Math.round(px * QUANT)},${Math.round(py * QUANT)},${Math.round(pz * QUANT)}`;
-          let entries = posMap.get(key);
-          if (!entries) {
-            entries = [];
-            posMap.set(key, entries);
-          }
-          entries.push({ nx, ny, nz, byteOffset: nOff });
-        }
-      }
-    }
-    for (const entries of posMap.values()) {
-      if (entries.length < 2) continue;
-      let ax = 0, ay = 0, az = 0;
-      for (const e of entries) {
-        ax += e.nx;
-        ay += e.ny;
-        az += e.nz;
-      }
-      const len = Math.sqrt(ax * ax + ay * ay + az * az);
-      if (len < 1e-8) continue;
-      ax /= len;
-      ay /= len;
-      az /= len;
-      for (const e of entries) {
-        this.writeFloat32(e.byteOffset, ax);
-        this.writeFloat32(e.byteOffset + 4, ay);
-        this.writeFloat32(e.byteOffset + 8, az);
-      }
-    }
-  }
-  /** Read a Float32 from the buffer at byteOffset */
-  readFloat32(byteOffset) {
-    const bytes = new Uint8Array(4);
-    bytes.set(this.bufferData.subarray(byteOffset, byteOffset + 4));
-    return new Float32Array(bytes.buffer)[0];
-  }
-  /** Write a Float32 to the buffer at byteOffset */
-  writeFloat32(byteOffset, value) {
-    const f32 = new Float32Array([value]);
-    const view = new Uint8Array(f32.buffer);
-    this.bufferData.set(view, byteOffset);
-  }
-  /**
-   * Generate LOD meshes for the MSFT_lod extension.
-   * Creates 2 lower detail levels (50% and 25%) per mesh.
-   */
-  generateLODs() {
-    const ratios = [0.5, 0.25];
-    const originalCount = this.meshes.length;
-    const coverages = [];
-    for (let mi = 0; mi < originalCount; mi++) {
-      const mesh = this.meshes[mi];
-      const lodIds = [];
-      for (const ratio of ratios) {
-        for (const prim of mesh.primitives) {
-          const posIdx = prim.attributes.POSITION;
-          const nrmIdx = prim.attributes.NORMAL;
-          const uvIdx = prim.attributes.TEXCOORD_0;
-          const idxIdx = prim.indices;
-          if (posIdx === void 0 || nrmIdx === void 0 || idxIdx === void 0) continue;
-          const posAcc = this.accessors[posIdx];
-          const nrmAcc = this.accessors[nrmIdx];
-          const idxAcc = this.accessors[idxIdx];
-          if (!posAcc || !nrmAcc || !idxAcc) continue;
-          const posBV = this.bufferViews[posAcc.bufferView];
-          const nrmBV = this.bufferViews[nrmAcc.bufferView];
-          const idxBV = this.bufferViews[idxAcc.bufferView];
-          if (!posBV || !nrmBV || !idxBV) continue;
-          const vCount = posAcc.count;
-          const iCount = idxAcc.count;
-          const positions = new Float32Array(vCount * 3);
-          const normals = new Float32Array(vCount * 3);
-          const uvs = new Float32Array(vCount * 2);
-          const indices = new Uint16Array(iCount);
-          for (let i = 0; i < vCount * 3; i++) {
-            positions[i] = this.readFloat32(posBV.byteOffset + i * 4);
-            normals[i] = this.readFloat32(nrmBV.byteOffset + i * 4);
-          }
-          if (uvIdx !== void 0) {
-            const uvAcc = this.accessors[uvIdx];
-            const uvBV = uvAcc ? this.bufferViews[uvAcc.bufferView] : null;
-            if (uvBV) {
-              for (let i = 0; i < vCount * 2; i++) {
-                uvs[i] = this.readFloat32(uvBV.byteOffset + i * 4);
-              }
-            }
-          }
-          const compSize = idxAcc.componentType === 5123 ? 2 : 4;
-          for (let i = 0; i < iCount; i++) {
-            const off = idxBV.byteOffset + i * compSize;
-            if (compSize === 2) {
-              indices[i] = this.bufferData[off] | this.bufferData[off + 1] << 8;
-            } else {
-              indices[i] = this.readFloat32(off);
-            }
-          }
-          const geom = { positions, normals, uvs, indices };
-          const decimated = decimateGeometry(geom, ratio);
-          const lodMeshIndex = this.meshes.length;
-          const lodPrim = { attributes: {}, material: prim.material };
-          lodPrim.attributes.POSITION = this.createAccessor(decimated.positions, "VEC3", true);
-          lodPrim.attributes.NORMAL = this.createAccessor(decimated.normals, "VEC3");
-          lodPrim.attributes.TEXCOORD_0 = this.createAccessor(decimated.uvs, "VEC2");
-          lodPrim.indices = this.createAccessor(decimated.indices, "SCALAR");
-          this.meshes.push({ name: `LOD${ratio}_mesh${mi}`, primitives: [lodPrim] });
-          lodIds.push(lodMeshIndex);
-        }
-      }
-      if (lodIds.length > 0) {
-        mesh["extensions"] = {
-          MSFT_lod: { ids: lodIds }
-        };
-        coverages.push(0.5, 0.2);
-      }
-    }
-    if (coverages.length > 0) {
-      this._lodCoverages = coverages;
-    }
-  }
-  /**
-   * Build skeleton hierarchy and embed as glTF skin.
-   * Creates 20 joint nodes with inverse bind matrices.
-   */
-  buildSkeleton() {
-    const bones = DRAGON_SKELETON;
-    const boneNameToIdx = /* @__PURE__ */ new Map();
-    const jointStartIndex = this.nodes.length;
-    for (let i = 0; i < bones.length; i++) {
-      const bone = bones[i];
-      const nodeIdx = this.nodes.length;
-      boneNameToIdx.set(bone.name, nodeIdx);
-      const node = {
-        name: `Joint_${bone.name}`,
-        translation: bone.position
-      };
-      this.nodes.push(node);
-    }
-    for (const bone of bones) {
-      if (bone.parent) {
-        const parentIdx = boneNameToIdx.get(bone.parent);
-        const childIdx = boneNameToIdx.get(bone.name);
-        if (parentIdx !== void 0 && childIdx !== void 0) {
-          const parentNode = this.nodes[parentIdx];
-          if (!parentNode.children) parentNode.children = [];
-          parentNode.children.push(childIdx);
-        }
-      }
-    }
-    const ibmData = new Float32Array(bones.length * 16);
-    for (let i = 0; i < bones.length; i++) {
-      const p = bones[i].position;
-      const off = i * 16;
-      ibmData[off + 0] = 1;
-      ibmData[off + 5] = 1;
-      ibmData[off + 10] = 1;
-      ibmData[off + 15] = 1;
-      ibmData[off + 12] = -p[0];
-      ibmData[off + 13] = -p[1];
-      ibmData[off + 14] = -p[2];
-    }
-    const ibmAccessor = this.createAccessorRaw(ibmData, "MAT4", 5126);
-    const joints = [];
-    for (let i = 0; i < bones.length; i++) {
-      joints.push(jointStartIndex + i);
-    }
-    this._skins = [
-      {
-        skeleton: jointStartIndex,
-        joints,
-        inverseBindMatrices: ibmAccessor
-      }
-    ];
-    this._jointStartIndex = jointStartIndex;
-  }
-  /**
-   * Skin all mesh nodes to the skeleton.
-   * For each vertex, finds the 4 nearest bones by distance and assigns
-   * normalized inverse-distance weights. Writes JOINTS_0 (Uint8) and
-   * WEIGHTS_0 (Float32) attributes into each mesh primitive.
-   */
-  skinMeshes() {
-    if (!this._skins || this._skins.length === 0) return;
-    const bones = DRAGON_SKELETON;
-    const bonePositions = bones.map((b) => b.position);
-    const originalNodeCount = this._jointStartIndex;
-    for (let ni = 0; ni < originalNodeCount; ni++) {
-      const node = this.nodes[ni];
-      if (node.mesh === void 0) continue;
-      const mesh = this.meshes[node.mesh];
-      if (!mesh) continue;
-      for (const prim of mesh.primitives) {
-        const posIdx = prim.attributes.POSITION;
-        if (posIdx === void 0) continue;
-        const posAcc = this.accessors[posIdx];
-        if (!posAcc) continue;
-        const posBV = this.bufferViews[posAcc.bufferView];
-        if (!posBV) continue;
-        const vCount = posAcc.count;
-        if (vCount === 0) continue;
-        const tx = node.translation ? node.translation[0] : 0;
-        const ty = node.translation ? node.translation[1] : 0;
-        const tz = node.translation ? node.translation[2] : 0;
-        const jointsData = new Uint8Array(vCount * 4);
-        const weightsData = new Float32Array(vCount * 4);
-        for (let vi = 0; vi < vCount; vi++) {
-          const pOff = posBV.byteOffset + vi * 12;
-          const vx = this.readFloat32(pOff) + tx;
-          const vy = this.readFloat32(pOff + 4) + ty;
-          const vz = this.readFloat32(pOff + 8) + tz;
-          const distances = [];
-          for (let bi = 0; bi < bonePositions.length; bi++) {
-            const bp = bonePositions[bi];
-            const dx = vx - bp[0], dy = vy - bp[1], dz = vz - bp[2];
-            distances.push({ boneIdx: bi, distSq: dx * dx + dy * dy + dz * dz });
-          }
-          distances.sort((a, b) => a.distSq - b.distSq);
-          const top4 = distances.slice(0, 4);
-          let totalWeight = 0;
-          const rawWeights = [];
-          for (const d of top4) {
-            const w = 1 / (d.distSq + 1e-4);
-            rawWeights.push(w);
-            totalWeight += w;
-          }
-          const off = vi * 4;
-          for (let j = 0; j < 4; j++) {
-            if (j < top4.length) {
-              jointsData[off + j] = top4[j].boneIdx;
-              weightsData[off + j] = rawWeights[j] / totalWeight;
-            } else {
-              jointsData[off + j] = 0;
-              weightsData[off + j] = 0;
-            }
-          }
-        }
-        prim.attributes.JOINTS_0 = this.createAccessorRaw(jointsData, "VEC4", 5121);
-        prim.attributes.WEIGHTS_0 = this.createAccessor(weightsData, "VEC4");
-      }
-    }
-  }
-  /**
-   * Compile a HoloScript composition to glTF format
-   */
-  compile(composition, agentToken, outputPath) {
-    this.validateCompilerAccess(agentToken, outputPath);
-    this.reset();
-    this.processComposition(composition);
-    this.smoothNormalsGlobal();
-    this.generateLODs();
-    this.buildSkeleton();
-    this.skinMeshes();
-    const buffer = this.bufferData.slice(0, this.bufferByteLength);
-    if (SHARED_COMPILE_BUFFER.length > MAX_RETAINED_BUFFER_SIZE) {
-      SHARED_COMPILE_BUFFER = new Uint8Array(INITIAL_COMPILE_BUFFER_SIZE);
-    }
-    const gltf = this.buildDocument(composition.name, buffer.byteLength);
-    if (this.options.format === "glb") {
-      const binary = this.createGLB(gltf, buffer);
-      this.stats.fileSizeBytes = binary.byteLength;
-      return {
-        binary,
-        stats: { ...this.stats }
-      };
-    } else {
-      this.stats.fileSizeBytes = JSON.stringify(gltf).length + buffer.byteLength;
-      return {
-        json: gltf,
-        buffer,
-        stats: { ...this.stats }
-      };
-    }
-  }
-  /**
-   * Reset pipeline state for new compilation
-   */
-  reset() {
-    this.bufferByteLength = 0;
-    this.accessors = [];
-    this.bufferViews = [];
-    this.meshes = [];
-    this.materials = [];
-    this.nodes = [];
-    this.scenes = [];
-    this.animations = [];
-    this.materialMap.clear();
-    this.images = [];
-    this.textures = [];
-    this.samplers = [];
-    this.scaleTextureIndex = -1;
-    this.scaleNormalTextureIndex = -1;
-    this.textureIndexMap.clear();
-    this.stats = {
-      nodeCount: 0,
-      meshCount: 0,
-      materialCount: 0,
-      textureCount: 0,
-      animationCount: 0,
-      totalVertices: 0,
-      totalTriangles: 0,
-      fileSizeBytes: 0
-    };
-  }
-  /**
-   * Process the entire composition
-   */
-  processComposition(composition) {
-    const rootNodes = [];
-    for (const object of composition.objects || []) {
-      const nodeIndex = this.processObject(object);
-      if (nodeIndex !== -1) {
-        rootNodes.push(nodeIndex);
-      }
-    }
-    for (const group of composition.spatialGroups || []) {
-      const nodeIndex = this.processSpatialGroup(group);
-      if (nodeIndex !== -1) {
-        rootNodes.push(nodeIndex);
-      }
-    }
-    for (const light of composition.lights || []) {
-      const nodeIndex = this.processLight(light);
-      if (nodeIndex !== -1) {
-        rootNodes.push(nodeIndex);
-      }
-    }
-    if (composition.camera) {
-      const nodeIndex = this.processCamera(composition.camera);
-      if (nodeIndex !== -1) {
-        rootNodes.push(nodeIndex);
-      }
-    }
-    for (const timeline of composition.timelines || []) {
-      this.processTimeline(timeline);
-    }
-    const domainBlocks = composition.domainBlocks ?? [];
-    if (domainBlocks.length > 0) {
-      compileDomainBlocks(
-        domainBlocks,
-        {
-          material: (block) => {
-            const mat = compileMaterialBlock(block);
-            const gltfMat = materialToGLTF(mat);
-            this.materials.push(gltfMat);
-            this.stats.materialCount++;
-            return "";
-          }
-        },
-        () => ""
-      );
-    }
-    this.scenes.push({
-      name: composition.name,
-      nodes: rootNodes
-    });
-  }
-  /**
-   * Process a single object
-   */
-  processObject(object) {
-    const position = this.extractVec3Prop(object, "position", [0, 0, 0]);
-    const rotation = this.extractVec3Prop(object, "rotation", [0, 0, 0]);
-    const scale = this.extractVec3Prop(object, "scale", [1, 1, 1]);
-    const geometryProp = this.findProp(object, "geometry") || this.findProp(object, "mesh") || this.findProp(object, "type");
-    const shapeType = (typeof geometryProp === "string" ? geometryProp : "box").toLowerCase();
-    let meshIndex;
-    if (PRIMITIVE_GENERATORS[shapeType]) {
-      meshIndex = this.createPrimitiveMesh(object.name, shapeType, scale, object);
-    } else if (ADVANCED_GEOMETRY_TYPES.has(shapeType)) {
-      meshIndex = this.createAdvancedMesh(object.name, shapeType, scale, object);
-    }
-    const node = gltfNodePool.acquire();
-    node.name = object.name || `node_${this.nodes.length}`;
-    node.translation = position;
-    node.rotation = this.eulerToQuaternion(rotation);
-    node.scale = [1, 1, 1];
-    if (meshIndex !== void 0) {
-      node.mesh = meshIndex;
-    }
-    if (object.children && object.children.length > 0) {
-      const childIndices = [];
-      for (const child of object.children) {
-        const childIdx = this.processObject(child);
-        if (childIdx !== -1) childIndices.push(childIdx);
-      }
-      if (childIndices.length > 0) node.children = childIndices;
-    }
-    const nodeIndex = this.nodes.length;
-    this.nodes.push(node);
-    this.stats.nodeCount++;
-    return nodeIndex;
-  }
-  /**
-   * Process a spatial group
-   */
-  processSpatialGroup(group) {
-    const childIndices = [];
-    for (const child of group.objects || []) {
-      const childIndex = this.processObject(child);
-      if (childIndex !== -1) {
-        childIndices.push(childIndex);
-      }
-    }
-    if (group.groups) {
-      for (const sub of group.groups) {
-        const subIdx = this.processSpatialGroup(sub);
-        if (subIdx !== -1) childIndices.push(subIdx);
-      }
-    }
-    const posProp = (group.properties || []).find((p) => p.key === "position");
-    const position = posProp && Array.isArray(posProp.value) ? [
-      Number(posProp.value[0]) || 0,
-      Number(posProp.value[1]) || 0,
-      Number(posProp.value[2]) || 0
-    ] : [0, 0, 0];
-    const node = gltfNodePool.acquire();
-    node.name = group.name || `group_${this.nodes.length}`;
-    node.translation = position;
-    if (childIndices.length > 0) {
-      node.children = childIndices;
-    }
-    const nodeIndex = this.nodes.length;
-    this.nodes.push(node);
-    this.stats.nodeCount++;
-    return nodeIndex;
-  }
-  /**
-   * Process a timeline as animation.
-   *
-   * HoloTimeline has entries: HoloTimelineEntry[] where each entry has
-   * { time: number, action: HoloTimelineAction }.
-   * We extract 'animate' actions and group them by target + property.
-   */
-  processTimeline(timeline) {
-    if (!timeline.entries || timeline.entries.length === 0) return;
-    const animateEntries = timeline.entries.filter((e) => e.action.kind === "animate").map((e) => ({
-      time: e.time,
-      target: e.action.target,
-      properties: e.action.properties
-    }));
-    if (animateEntries.length === 0) return;
-    const channels = [];
-    const samplers = [];
-    const grouped = /* @__PURE__ */ new Map();
-    for (const entry of animateEntries) {
-      const targetNodeIndex = this.nodes.findIndex((n) => n.name === entry.target);
-      if (targetNodeIndex === -1) continue;
-      for (const [prop, value] of Object.entries(entry.properties)) {
-        const gltfPath = this.mapPropertyToGLTFPath(prop);
-        if (!gltfPath) continue;
-        const key = `${targetNodeIndex}:${gltfPath}`;
-        if (!grouped.has(key)) grouped.set(key, []);
-        grouped.get(key).push({ time: entry.time, value });
-      }
-    }
-    for (const [key, keyframes] of grouped) {
-      const [nodeIdxStr, gltfPath] = key.split(":");
-      const nodeIdx = parseInt(nodeIdxStr, 10);
-      const times = keyframes.map((kf) => kf.time / 1e3);
-      const inputAccessor = this.createAccessor(new Float32Array(times), "SCALAR");
-      const values = [];
-      for (const kf of keyframes) {
-        if (Array.isArray(kf.value)) {
-          if (gltfPath === "rotation") {
-            const quat = this.eulerToQuaternion(kf.value);
-            values.push(...quat);
-          } else {
-            values.push(...kf.value);
-          }
-        }
-      }
-      const outputType = gltfPath === "rotation" ? "VEC4" : "VEC3";
-      const outputAccessor = this.createAccessor(new Float32Array(values), outputType);
-      const samplerIndex = samplers.length;
-      samplers.push({ input: inputAccessor, interpolation: "LINEAR", output: outputAccessor });
-      channels.push({ sampler: samplerIndex, target: { node: nodeIdx, path: gltfPath } });
-    }
-    if (channels.length > 0) {
-      this.animations.push({
-        name: timeline.name || `animation_${this.animations.length}`,
-        channels,
-        samplers
-      });
-      this.stats.animationCount++;
-    }
-  }
-  /**
-   * Create a primitive mesh
-   */
-  createPrimitiveMesh(name, shapeType, scale, object) {
-    const generator = PRIMITIVE_GENERATORS[shapeType];
-    if (!generator) return -1;
-    const geometry = generator(scale);
-    const positionAccessor = this.createAccessor(geometry.positions, "VEC3", true);
-    const normalAccessor = this.createAccessor(geometry.normals, "VEC3");
-    const uvAccessor = this.createAccessor(geometry.uvs, "VEC2");
-    const indexAccessor = this.createAccessor(geometry.indices, "SCALAR");
-    const materialIndex = this.getOrCreateMaterial(object, shapeType);
-    const mesh = {
-      name: name || `mesh_${this.meshes.length}`,
-      primitives: [
-        {
-          attributes: {
-            POSITION: positionAccessor,
-            NORMAL: normalAccessor,
-            TEXCOORD_0: uvAccessor
-          },
-          indices: indexAccessor,
-          material: materialIndex,
-          mode: 4
-          // TRIANGLES
-        }
-      ]
-    };
-    const meshIndex = this.meshes.length;
-    this.meshes.push(mesh);
-    this.stats.meshCount++;
-    this.stats.totalVertices += geometry.positions.length / 3;
-    this.stats.totalTriangles += geometry.indices.length / 3;
-    return meshIndex;
-  }
-  /**
-   * Create an advanced mesh (spline, membrane, hull/metaball).
-   * These geometry types need additional properties beyond scale.
-   */
-  createAdvancedMesh(name, shapeType, scale, object) {
-    let geometry;
-    switch (shapeType) {
-      case "spline": {
-        const pointsProp = this.findProp(object, "points");
-        const radiiProp = this.findProp(object, "radii");
-        const segmentsProp = this.findProp(object, "segments");
-        const stepsProp = this.findProp(object, "steps");
-        const points = this.extractNestedArray(pointsProp, 3);
-        const radii = Array.isArray(radiiProp) ? radiiProp.map(Number) : [0.1];
-        while (radii.length < points.length) {
-          radii.push(radii[radii.length - 1] ?? 0.1);
-        }
-        const radialSegments = typeof segmentsProp === "number" ? segmentsProp : 24;
-        const lengthSteps = typeof stepsProp === "number" ? stepsProp : 8;
-        geometry = generateSplineGeometry(points, radii, radialSegments, lengthSteps);
-        break;
-      }
-      case "membrane": {
-        const anchorsProp = this.findProp(object, "anchors");
-        const subdivisionsProp = this.findProp(object, "subdivisions");
-        const bulgeProp = this.findProp(object, "bulge");
-        const anchors = this.extractNestedArray(anchorsProp, 3);
-        const subdivisions = typeof subdivisionsProp === "number" ? subdivisionsProp : 8;
-        const bulge = typeof bulgeProp === "number" ? bulgeProp : 0.15;
-        geometry = generateMembraneGeometry(anchors, subdivisions, bulge);
-        break;
-      }
-      case "hull":
-      case "blob":
-      case "metaball": {
-        const blobsProp = this.findProp(object, "blobs");
-        const resolutionProp = this.findProp(object, "resolution");
-        const thresholdProp = this.findProp(object, "threshold");
-        const blobs = [];
-        if (Array.isArray(blobsProp)) {
-          for (const blobItem of blobsProp) {
-            if (blobItem && typeof blobItem === "object") {
-              const b = blobItem;
-              const center = Array.isArray(b.center) ? b.center.map(Number) : [0, 0, 0];
-              const radius = Array.isArray(b.radius) ? b.radius.map(Number) : [0.5, 0.5, 0.5];
-              blobs.push({ center, radius });
-            }
-          }
-        }
-        if (blobs.length === 0) {
-          blobs.push({
-            center: [0, 0, 0],
-            radius: [scale[0] * 0.5, scale[1] * 0.5, scale[2] * 0.5]
-          });
-        }
-        const resolution = typeof resolutionProp === "number" ? resolutionProp : 24;
-        const threshold = typeof thresholdProp === "number" ? thresholdProp : 1;
-        geometry = generateHullGeometry(blobs, resolution, threshold);
-        break;
-      }
-      default:
-        return -1;
-    }
-    const positionAccessor = this.createAccessor(geometry.positions, "VEC3", true);
-    const normalAccessor = this.createAccessor(geometry.normals, "VEC3");
-    const uvAccessor = this.createAccessor(geometry.uvs, "VEC2");
-    const indexAccessor = this.createAccessor(geometry.indices, "SCALAR");
-    const materialIndex = this.getOrCreateMaterial(object, shapeType);
-    const mesh = {
-      name: name || `mesh_${this.meshes.length}`,
-      primitives: [
-        {
-          attributes: {
-            POSITION: positionAccessor,
-            NORMAL: normalAccessor,
-            TEXCOORD_0: uvAccessor
-          },
-          indices: indexAccessor,
-          material: materialIndex,
-          mode: 4
-          // TRIANGLES
-        }
-      ]
-    };
-    const meshIndex = this.meshes.length;
-    this.meshes.push(mesh);
-    this.stats.meshCount++;
-    this.stats.totalVertices += geometry.positions.length / 3;
-    this.stats.totalTriangles += geometry.indices.length / 3;
-    return meshIndex;
-  }
-  /**
-   * Extract a nested array of vec3s from a HoloValue.
-   * e.g. [[0, 1, 2], [3, 4, 5]] => [[0,1,2], [3,4,5]]
-   */
-  extractNestedArray(val, expectedLength) {
-    const result = [];
-    if (!Array.isArray(val)) return result;
-    for (const item of val) {
-      if (Array.isArray(item) && item.length >= expectedLength) {
-        result.push(item.slice(0, expectedLength).map(Number));
-      }
-    }
-    return result;
-  }
-  /**
-   * Get or create a material from object properties + traits.
-   *
-   * Material composition order (later overrides earlier):
-   * 1. Defaults (white, metallic 0, roughness 0.5)
-   * 2. Named material preset (e.g., material: "glass")
-   * 3. TraitCompositor output (PBR from visual presets)
-   * 4. Direct property overrides (color, opacity)
-   */
-  getOrCreateMaterial(object, shapeType) {
-    let color = [1, 1, 1];
-    let metallic = 0;
-    let roughness = 0.5;
-    let opacity = 1;
-    let emissive = [0, 0, 0];
-    let transmission = 0;
-    let ior = 1.5;
-    let thickness = 0;
-    let clearcoat = 0;
-    let clearcoatRoughness = 0;
-    let sheen = 0;
-    let sheenRoughness = 0.5;
-    let sheenColor = [1, 1, 1];
-    let iridescence = 0;
-    let iridescenceIOR = 1.3;
-    let anisotropy = 0;
-    let anisotropyRotation = 0;
-    let attenuationColor;
-    let attenuationDistance;
-    const namedMat = this.findProp(object, "material");
-    if (typeof namedMat === "string" && MATERIAL_PRESETS[namedMat]) {
-      const preset = MATERIAL_PRESETS[namedMat];
-      if (preset.color) color = this.parseColorString(preset.color);
-      if (preset.metalness !== void 0) metallic = preset.metalness;
-      if (preset.roughness !== void 0) roughness = preset.roughness;
-      if (preset.opacity !== void 0) opacity = preset.opacity;
-      if (preset.transparent && opacity >= 1) opacity = 0.99;
-      if (preset.emissive) emissive = this.parseColorString(preset.emissive);
-      if (preset.transmission !== void 0) transmission = preset.transmission;
-      if (preset.ior !== void 0) ior = preset.ior;
-      if (preset.thickness !== void 0) thickness = preset.thickness;
-      if (preset.clearcoat !== void 0) clearcoat = preset.clearcoat;
-      if (preset.clearcoatRoughness !== void 0) clearcoatRoughness = preset.clearcoatRoughness;
-      if (preset.sheen !== void 0) sheen = preset.sheen;
-      if (preset.sheenRoughness !== void 0) sheenRoughness = preset.sheenRoughness;
-      if (preset.sheenColor) sheenColor = this.parseColorString(preset.sheenColor);
-      if (preset.iridescence !== void 0) iridescence = preset.iridescence;
-      if (preset.iridescenceIOR !== void 0) iridescenceIOR = preset.iridescenceIOR;
-      if (preset.anisotropy !== void 0) anisotropy = preset.anisotropy;
-      if (preset.anisotropyRotation !== void 0) anisotropyRotation = preset.anisotropyRotation;
-      if (preset.attenuationColor)
-        attenuationColor = this.parseColorString(preset.attenuationColor);
-      if (preset.attenuationDistance !== void 0)
-        attenuationDistance = preset.attenuationDistance;
-    }
-    const traitNames = (object.traits || []).map((t) => t.name);
-    if (traitNames.length > 0) {
-      const composed = this.compositor.compose(traitNames);
-      if (composed.color) color = this.parseColorString(composed.color);
-      if (composed.metalness !== void 0) metallic = composed.metalness;
-      if (composed.roughness !== void 0) roughness = composed.roughness;
-      if (composed.opacity !== void 0) opacity = composed.opacity;
-      if (composed.emissive) emissive = this.parseColorString(composed.emissive);
-      if (composed.transparent) opacity = Math.min(opacity, 0.9);
-      if (composed.transmission !== void 0) transmission = composed.transmission;
-      if (composed.ior !== void 0) ior = composed.ior;
-      if (composed.thickness !== void 0) thickness = composed.thickness;
-      if (composed.clearcoat !== void 0) clearcoat = composed.clearcoat;
-      if (composed.clearcoatRoughness !== void 0)
-        clearcoatRoughness = composed.clearcoatRoughness;
-      if (composed.sheen !== void 0) sheen = composed.sheen;
-      if (composed.sheenRoughness !== void 0) sheenRoughness = composed.sheenRoughness;
-      if (composed.sheenColor) sheenColor = this.parseColorString(composed.sheenColor);
-      if (composed.iridescence !== void 0) iridescence = composed.iridescence;
-      if (composed.iridescenceIOR !== void 0) iridescenceIOR = composed.iridescenceIOR;
-      if (composed.anisotropy !== void 0) anisotropy = composed.anisotropy;
-      if (composed.anisotropyRotation !== void 0)
-        anisotropyRotation = composed.anisotropyRotation;
-      if (composed.attenuationColor)
-        attenuationColor = this.parseColorString(composed.attenuationColor);
-      if (composed.attenuationDistance !== void 0)
-        attenuationDistance = composed.attenuationDistance;
-    }
-    const colorProp = this.findProp(object, "color");
-    if (typeof colorProp === "string") {
-      color = this.parseColorString(colorProp);
-    } else if (Array.isArray(colorProp) && colorProp.length >= 3) {
-      color = [Number(colorProp[0]), Number(colorProp[1]), Number(colorProp[2])];
-    }
-    const opacityProp = this.findProp(object, "opacity");
-    if (typeof opacityProp === "number") opacity = opacityProp;
-    const metallicProp = this.findProp(object, "metallic") ?? this.findProp(object, "metalness");
-    if (typeof metallicProp === "number") metallic = metallicProp;
-    const roughnessProp = this.findProp(object, "roughness");
-    if (typeof roughnessProp === "number") roughness = roughnessProp;
-    const emissiveIntensityProp = this.findProp(object, "emissiveIntensity");
-    const emissiveIntensity = typeof emissiveIntensityProp === "number" ? emissiveIntensityProp : 1;
-    const emissiveProp = this.findProp(object, "emissive");
-    if (typeof emissiveProp === "string") emissive = this.parseColorString(emissiveProp);
-    const transmissionProp = this.findProp(object, "transmission");
-    if (typeof transmissionProp === "number") transmission = transmissionProp;
-    const iorProp = this.findProp(object, "ior");
-    if (typeof iorProp === "number") ior = iorProp;
-    const clearcoatProp = this.findProp(object, "clearcoat");
-    if (typeof clearcoatProp === "number") clearcoat = clearcoatProp;
-    const texturePaths = {};
-    const TEX_PROP_MAP = {
-      // HoloScript property name → glTF slot key
-      baseColorMap: "baseColor",
-      albedo_map: "baseColor",
-      colorMap: "baseColor",
-      normalMap: "normal",
-      normal_map: "normal",
-      roughnessMap: "metallicRoughness",
-      roughness_map: "metallicRoughness",
-      metallicMap: "metallicRoughness",
-      metallic_map: "metallicRoughness",
-      metalnessMap: "metallicRoughness",
-      occlusionMap: "occlusion",
-      ao_map: "occlusion",
-      ambientOcclusionMap: "occlusion",
-      emissiveMap: "emissive",
-      emissive_map: "emissive",
-      emissionMap: "emissive"
-    };
-    for (const [propName, slotKey] of Object.entries(TEX_PROP_MAP)) {
-      const val = this.findProp(object, propName);
-      if (typeof val === "string" && val.length > 0 && !texturePaths[slotKey]) {
-        texturePaths[slotKey] = val;
-      }
-    }
-    const key = JSON.stringify({
-      color,
-      metallic,
-      roughness,
-      opacity,
-      emissive,
-      transmission,
-      ior,
-      thickness,
-      clearcoat,
-      clearcoatRoughness,
-      sheen,
-      sheenRoughness,
-      sheenColor,
-      iridescence,
-      iridescenceIOR,
-      anisotropy,
-      anisotropyRotation,
-      attenuationColor,
-      attenuationDistance,
-      texturePaths
-    });
-    if (this.materialMap.has(key)) {
-      return this.materialMap.get(key);
-    }
-    const material = {
-      name: `material_${this.materials.length}`,
-      pbrMetallicRoughness: {
-        baseColorFactor: [...color, opacity],
-        metallicFactor: metallic,
-        roughnessFactor: roughness
-      },
-      doubleSided: opacity < 1 || transmission > 0
-    };
-    if (opacity < 1 || transmission > 0) {
-      material.alphaMode = "BLEND";
-    }
-    const emissiveSum = emissive[0] + emissive[1] + emissive[2];
-    if (emissiveSum > 0) {
-      material.emissiveFactor = emissive.map((c) => c * emissiveIntensity);
-    }
-    const extensions = {};
-    if (transmission > 0) {
-      Object.assign(extensions, createTransmissionExtension(transmission));
-    }
-    if (ior !== 1.5) {
-      Object.assign(extensions, createIORExtension(ior));
-    }
-    if (clearcoat > 0) {
-      Object.assign(
-        extensions,
-        createClearcoatExtension({ factor: clearcoat, roughness: clearcoatRoughness })
-      );
-    }
-    if (sheen > 0) {
-      Object.assign(
-        extensions,
-        createSheenExtension({ color: sheenColor, roughness: sheenRoughness })
-      );
-    }
-    if (iridescence > 0) {
-      Object.assign(
-        extensions,
-        createIridescenceExtension({ factor: iridescence, ior: iridescenceIOR })
-      );
-    }
-    if (anisotropy > 0) {
-      Object.assign(
-        extensions,
-        createAnisotropyExtension({ strength: anisotropy, rotation: anisotropyRotation })
-      );
-    }
-    if (thickness > 0 || attenuationDistance !== void 0) {
-      Object.assign(
-        extensions,
-        createVolumeExtension({
-          thickness: thickness || 1,
-          attenuationDistance,
-          attenuationColor
-        })
-      );
-    }
-    if (emissiveIntensity > 1) {
-      Object.assign(extensions, createEmissiveStrengthExtension(emissiveIntensity));
-    }
-    if (Object.keys(extensions).length > 0) {
-      material.extensions = extensions;
-    }
-    const isScaledGeometry = shapeType === "hull" || shapeType === "metaball";
-    const isScaledMaterial = typeof namedMat === "string" && (namedMat === "skin_dark" || namedMat === "leather");
-    if (isScaledGeometry || isScaledMaterial) {
-      const texIdx = this.ensureScaleTexture();
-      if (texIdx >= 0) {
-        material.pbrMetallicRoughness.baseColorTexture = {
-          index: texIdx,
-          texCoord: 0
-        };
-        if (this.scaleNormalTextureIndex >= 0) {
-          material.normalTexture = {
-            index: this.scaleNormalTextureIndex,
-            texCoord: 0,
-            scale: 1
-          };
-        }
-        this.stats.textureCount = 2;
-      }
-    }
-    if (Object.keys(texturePaths).length > 0) {
-      const pbr = material.pbrMetallicRoughness;
-      if (texturePaths.baseColor && !pbr.baseColorTexture) {
-        const idx = this.getOrCreateExternalTexture(texturePaths.baseColor);
-        if (idx >= 0) pbr.baseColorTexture = { index: idx, texCoord: 0 };
-      }
-      if (texturePaths.metallicRoughness && !pbr.metallicRoughnessTexture) {
-        const idx = this.getOrCreateExternalTexture(texturePaths.metallicRoughness);
-        if (idx >= 0) pbr.metallicRoughnessTexture = { index: idx, texCoord: 0 };
-      }
-      const matRecord = material;
-      if (texturePaths.normal && !matRecord.normalTexture) {
-        const idx = this.getOrCreateExternalTexture(texturePaths.normal);
-        if (idx >= 0) matRecord.normalTexture = { index: idx, texCoord: 0, scale: 1 };
-      }
-      if (texturePaths.occlusion && !matRecord.occlusionTexture) {
-        const idx = this.getOrCreateExternalTexture(texturePaths.occlusion);
-        if (idx >= 0) matRecord.occlusionTexture = { index: idx, texCoord: 0, strength: 1 };
-      }
-      if (texturePaths.emissive && !matRecord.emissiveTexture) {
-        const idx = this.getOrCreateExternalTexture(texturePaths.emissive);
-        if (idx >= 0) matRecord.emissiveTexture = { index: idx, texCoord: 0 };
-      }
-    }
-    const materialIndex = this.materials.length;
-    this.materials.push(material);
-    this.materialMap.set(key, materialIndex);
-    this.stats.materialCount++;
-    return materialIndex;
-  }
-  /**
-   * Embed an external texture image in the glTF buffer. Returns the texture
-   * index, or -1 if the image data is not available in options.textureData.
-   * Caches by path so the same image is only embedded once.
-   */
-  getOrCreateExternalTexture(path) {
-    if (this.textureIndexMap.has(path)) {
-      return this.textureIndexMap.get(path);
-    }
-    const imageData = this.options.textureData[path];
-    if (!imageData || imageData.length === 0) {
-      return -1;
-    }
-    const isPNG = imageData[0] === 137 && imageData[1] === 80;
-    const isJPEG = imageData[0] === 255 && imageData[1] === 216;
-    const mimeType = isPNG ? "image/png" : isJPEG ? "image/jpeg" : "image/png";
-    const byteOffset = this.bufferByteLength;
-    this.appendToBuffer(imageData);
-    this.padBuffer(4);
-    const bufferViewIndex = this.bufferViews.length;
-    this.bufferViews.push({
-      buffer: 0,
-      byteOffset,
-      byteLength: imageData.length
-    });
-    const imageIndex = this.images.length;
-    this.images.push({
-      bufferView: bufferViewIndex,
-      mimeType
-    });
-    let samplerIndex;
-    if (this.samplers.length > 0) {
-      samplerIndex = 0;
-    } else {
-      samplerIndex = this.samplers.length;
-      this.samplers.push({
-        magFilter: 9729,
-        // LINEAR
-        minFilter: 9987,
-        // LINEAR_MIPMAP_LINEAR
-        wrapS: 10497,
-        // REPEAT
-        wrapT: 10497
-        // REPEAT
-      });
-    }
-    const textureIndex = this.textures.length;
-    this.textures.push({
-      source: imageIndex,
-      sampler: samplerIndex
-    });
-    this.textureIndexMap.set(path, textureIndex);
-    this.stats.textureCount++;
-    return textureIndex;
-  }
-  /**
-   * Ensure the procedural scale texture is generated and embedded in the glTF.
-   * Returns the texture index, or -1 if generation failed.
-   */
-  ensureScaleTexture() {
-    if (this.scaleTextureIndex >= 0) return this.scaleTextureIndex;
-    const TEX_SIZE = 256;
-    const pixels = generateScaleTexture(TEX_SIZE);
-    const pngData = encodePNG(pixels, TEX_SIZE, TEX_SIZE);
-    const byteOffset = this.bufferByteLength;
-    this.appendToBuffer(pngData);
-    this.padBuffer(4);
-    const bufferViewIndex = this.bufferViews.length;
-    this.bufferViews.push({
-      buffer: 0,
-      byteOffset,
-      byteLength: pngData.length
-    });
-    const imageIndex = this.images.length;
-    this.images.push({
-      bufferView: bufferViewIndex,
-      mimeType: "image/png"
-    });
-    const samplerIndex = this.samplers.length;
-    this.samplers.push({
-      magFilter: 9729,
-      // LINEAR
-      minFilter: 9987,
-      // LINEAR_MIPMAP_LINEAR
-      wrapS: 10497,
-      // REPEAT
-      wrapT: 10497
-      // REPEAT
-    });
-    this.scaleTextureIndex = this.textures.length;
-    this.textures.push({
-      source: imageIndex,
-      sampler: samplerIndex
-    });
-    const normalPixels = generateScaleNormalMap(TEX_SIZE);
-    const normalPng = encodePNG(normalPixels, TEX_SIZE, TEX_SIZE);
-    const normalByteOffset = this.bufferByteLength;
-    this.appendToBuffer(normalPng);
-    this.padBuffer(4);
-    const normalBVIndex = this.bufferViews.length;
-    this.bufferViews.push({
-      buffer: 0,
-      byteOffset: normalByteOffset,
-      byteLength: normalPng.length
-    });
-    const normalImageIndex = this.images.length;
-    this.images.push({
-      bufferView: normalBVIndex,
-      mimeType: "image/png"
-    });
-    this.scaleNormalTextureIndex = this.textures.length;
-    this.textures.push({
-      source: normalImageIndex,
-      sampler: samplerIndex
-      // reuse same sampler
-    });
-    return this.scaleTextureIndex;
-  }
-  /**
-   * Create an accessor with arbitrary type string (e.g., MAT4 for skeleton data, VEC4 for skinning).
-   * Supports Uint8Array for UNSIGNED_BYTE (5121), Uint16Array for UNSIGNED_SHORT (5123),
-   * Uint32Array for UNSIGNED_INT (5125), and Float32Array for FLOAT (5126).
-   */
-  createAccessorRaw(data, type, componentType) {
-    const byteOffset = this.bufferByteLength;
-    const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    this.appendToBuffer(view);
-    this.padBuffer(4);
-    const bufferViewIndex = this.bufferViews.length;
-    this.bufferViews.push({
-      buffer: 0,
-      byteOffset,
-      byteLength: data.byteLength
-    });
-    const comps = type === "MAT4" ? 16 : type === "VEC4" ? 4 : type === "VEC3" ? 3 : type === "VEC2" ? 2 : 1;
-    const count = data.length / comps;
-    const accessorIndex = this.accessors.length;
-    this.accessors.push({
-      bufferView: bufferViewIndex,
-      componentType,
-      count,
-      type
-    });
-    return accessorIndex;
-  }
-  /**
-   * Create an accessor and buffer view for data
-   */
-  createAccessor(data, type, computeBounds = false) {
-    const byteOffset = this.bufferByteLength;
-    const componentType = data instanceof Uint32Array ? 5125 : data instanceof Uint16Array ? 5123 : 5126;
-    const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    this.appendToBuffer(view);
-    this.padBuffer(4);
-    const bufferViewIndex = this.bufferViews.length;
-    const bufferView = {
-      buffer: 0,
-      byteOffset,
-      byteLength: data.byteLength
-    };
-    if (componentType === 5126) {
-      bufferView.target = 34962;
-    } else {
-      bufferView.target = 34963;
-    }
-    this.bufferViews.push(bufferView);
-    const componentsPerElement = type === "SCALAR" ? 1 : type === "VEC2" ? 2 : type === "VEC3" ? 3 : 4;
-    const count = data.length / componentsPerElement;
-    const accessor = {
-      bufferView: bufferViewIndex,
-      componentType,
-      count,
-      type
-    };
-    if (computeBounds && type === "VEC3" && data instanceof Float32Array) {
-      const min = [Infinity, Infinity, Infinity];
-      const max = [-Infinity, -Infinity, -Infinity];
-      for (let i = 0; i < data.length; i += 3) {
-        min[0] = Math.min(min[0], data[i]);
-        min[1] = Math.min(min[1], data[i + 1]);
-        min[2] = Math.min(min[2], data[i + 2]);
-        max[0] = Math.max(max[0], data[i]);
-        max[1] = Math.max(max[1], data[i + 1]);
-        max[2] = Math.max(max[2], data[i + 2]);
-      }
-      accessor.min = min;
-      accessor.max = max;
-    }
-    const accessorIndex = this.accessors.length;
-    this.accessors.push(accessor);
-    return accessorIndex;
-  }
-  /**
-   * Build the glTF JSON document
-   */
-  buildDocument(name, bufferLength) {
-    const gltf = {
-      asset: {
-        version: "2.0",
-        generator: this.options.generator
-      },
-      scene: 0,
-      scenes: this.scenes,
-      nodes: this.nodes,
-      meshes: this.meshes,
-      materials: this.materials,
-      accessors: this.accessors,
-      bufferViews: this.bufferViews,
-      buffers: [
-        {
-          byteLength: bufferLength
-        }
-      ]
-    };
-    if (this.options.copyright) {
-      gltf.asset.copyright = this.options.copyright;
-    }
-    if (this.animations.length > 0) {
-      gltf.animations = this.animations;
-    }
-    if (this.images.length > 0) {
-      gltf.images = this.images;
-      gltf.textures = this.textures;
-      gltf.samplers = this.samplers;
-    }
-    if (this._skins && this._skins.length > 0) {
-      gltf.skins = this._skins;
-    }
-    declareExtensions(gltf);
-    if (this.options.format === "gltf") {
-      gltf.buffers[0].uri = `${name}.bin`;
-    }
-    return gltf;
-  }
-  /**
-   * Create a GLB binary file
-   */
-  createGLB(gltf, buffer) {
-    const jsonString = JSON.stringify(gltf);
-    const jsonBuffer = new TextEncoder().encode(jsonString);
-    const jsonPadding = (4 - jsonBuffer.byteLength % 4) % 4;
-    const paddedJsonLength = jsonBuffer.byteLength + jsonPadding;
-    const binPadding = (4 - buffer.byteLength % 4) % 4;
-    const paddedBinLength = buffer.byteLength + binPadding;
-    const totalSize = 12 + 8 + paddedJsonLength + 8 + paddedBinLength;
-    const output = new ArrayBuffer(totalSize);
-    const view = new DataView(output);
-    const bytes = new Uint8Array(output);
-    let offset = 0;
-    view.setUint32(offset, 1179937895, true);
-    offset += 4;
-    view.setUint32(offset, 2, true);
-    offset += 4;
-    view.setUint32(offset, totalSize, true);
-    offset += 4;
-    view.setUint32(offset, paddedJsonLength, true);
-    offset += 4;
-    view.setUint32(offset, 1313821514, true);
-    offset += 4;
-    bytes.set(jsonBuffer, offset);
-    offset += jsonBuffer.byteLength;
-    for (let i = 0; i < jsonPadding; i++) {
-      bytes[offset++] = 32;
-    }
-    view.setUint32(offset, paddedBinLength, true);
-    offset += 4;
-    view.setUint32(offset, 5130562, true);
-    offset += 4;
-    bytes.set(buffer, offset);
-    offset += buffer.byteLength;
-    for (let i = 0; i < binPadding; i++) {
-      bytes[offset++] = 0;
-    }
-    return new Uint8Array(output);
-  }
-  /**
-   * Process a light node (stored as extras for universal glTF compatibility)
-   */
-  processLight(light) {
-    const props = light.properties || [];
-    const findLightProp = (key) => props.find((p) => p.key === key)?.value;
-    const position = findLightProp("position");
-    const node = {
-      name: light.name || `light_${this.nodes.length}`,
-      translation: position ? [position[0], position[1], position[2]] : [0, 0, 0],
-      extras: {
-        type: "light",
-        lightType: light.lightType,
-        color: findLightProp("color") || "#ffffff",
-        intensity: findLightProp("intensity") ?? 1
-      }
-    };
-    const nodeIndex = this.nodes.length;
-    this.nodes.push(node);
-    this.stats.nodeCount++;
-    return nodeIndex;
-  }
-  /**
-   * Process a camera node
-   */
-  processCamera(camera) {
-    const props = camera.properties || [];
-    const findCamProp = (key) => props.find((p) => p.key === key)?.value;
-    const position = findCamProp("position");
-    const node = {
-      name: "Camera",
-      translation: position ? [position[0], position[1], position[2]] : [0, 0, 0],
-      extras: {
-        type: "camera",
-        cameraType: camera.cameraType,
-        fov: findCamProp("fov") ?? 75,
-        near: findCamProp("near") ?? 0.1,
-        far: findCamProp("far") ?? 1e3
-      }
-    };
-    const nodeIndex = this.nodes.length;
-    this.nodes.push(node);
-    this.stats.nodeCount++;
-    return nodeIndex;
-  }
-  // =============================================================================
-  // UTILITY METHODS
-  // =============================================================================
-  /** Find a property by key in a HoloObjectDecl's property array. */
-  findProp(object, key) {
-    return object.properties?.find((p) => p.key === key)?.value;
-  }
-  /** Extract a vec3 from an object's properties array. */
-  extractVec3Prop(object, key, defaultValue) {
-    const val = this.findProp(object, key);
-    if (Array.isArray(val) && val.length >= 3) {
-      return [Number(val[0]) || 0, Number(val[1]) || 0, Number(val[2]) || 0];
-    }
-    return defaultValue;
-  }
-  parseColorString(color) {
-    if (color.startsWith("#")) {
-      const hex = color.slice(1);
-      if (hex.length >= 6) {
-        const r = parseInt(hex.slice(0, 2), 16) / 255;
-        const g = parseInt(hex.slice(2, 4), 16) / 255;
-        const b = parseInt(hex.slice(4, 6), 16) / 255;
-        return [r, g, b];
-      }
-    }
-    const colors = {
-      red: [1, 0, 0],
-      green: [0, 1, 0],
-      blue: [0, 0, 1],
-      white: [1, 1, 1],
-      black: [0, 0, 0],
-      yellow: [1, 1, 0],
-      cyan: [0, 1, 1],
-      magenta: [1, 0, 1],
-      orange: [1, 0.5, 0],
-      purple: [0.5, 0, 0.5]
-    };
-    return colors[color.toLowerCase()] || [1, 1, 1];
-  }
-  eulerToQuaternion(euler) {
-    const toRad = Math.PI / 180;
-    const x = euler[0] * toRad / 2;
-    const y = euler[1] * toRad / 2;
-    const z = euler[2] * toRad / 2;
-    const cx = Math.cos(x);
-    const sx = Math.sin(x);
-    const cy = Math.cos(y);
-    const sy = Math.sin(y);
-    const cz = Math.cos(z);
-    const sz = Math.sin(z);
-    return [
-      sx * cy * cz - cx * sy * sz,
-      cx * sy * cz + sx * cy * sz,
-      cx * cy * sz - sx * sy * cz,
-      cx * cy * cz + sx * sy * sz
-    ];
-  }
-  mapPropertyToGLTFPath(property) {
-    const mapping = {
-      position: "translation",
-      translation: "translation",
-      rotation: "rotation",
-      scale: "scale"
-    };
-    return mapping[property.toLowerCase()] || null;
-  }
-};
-function createGLTFPipeline(options) {
-  return new GLTFPipeline(options);
-}
-
-export { GLTFPipeline, createGLTFPipeline, generateScaleNormalMap, generateScaleTexture };
-//# sourceMappingURL=chunk-LBPEZQAF.js.map
-//# sourceMappingURL=chunk-LBPEZQAF.js.map