@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-JX7YL6ZE.js

@@ -0,0 +1,2252 @@
+import { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from './chunk-EKBKLK7P.js';
+import { init_R3FCompiler, init_ObjectPool, ASTNodePool, MATERIAL_PRESETS } from './chunk-UM6C3CGK.js';
+import { init_TraitCompositor, TraitCompositor } from './chunk-4C57PR42.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileMaterialBlock, materialToGLTF } from './chunk-JCLBKPMX.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/GLTFPipeline.ts
+init_TraitCompositor();
+init_R3FCompiler();
+init_CompilerBase();
+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 = {
+      provenanceHash: options.provenanceHash ?? "",
+      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, 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(composition, bufferLength) {
+    const name = composition.name;
+    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;
+    }
+    const objectNames = (composition.objects || []).map((o) => o.name);
+    const allTraits = /* @__PURE__ */ new Set();
+    for (const obj of composition.objects || []) {
+      for (const trait of obj.traits || []) {
+        allTraits.add(typeof trait === "string" ? trait : trait.name);
+      }
+    }
+    const groupNames = (composition.spatialGroups || []).map((g) => g.name);
+    gltf.asset.extras = {
+      holoscript: {
+        version: "6.0",
+        compositionName: name,
+        objects: objectNames,
+        traits: [...allTraits],
+        spatialGroups: groupNames,
+        ...this.options.provenanceHash ? { provenanceHash: this.options.provenanceHash } : {}
+      }
+    };
+    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-JX7YL6ZE.js.map
+//# sourceMappingURL=chunk-JX7YL6ZE.js.map