@vcad/mcp 0.9.4-main.13 → 0.9.4-main.14

package/README.md

@@ -6,4 +6,4 @@ vcad's MCP server as a self-contained bundle (server + BRep kernel WASM).
 { "mcpServers": { "vcad": { "command": "npx", "args": ["-y", "@vcad/mcp"] } } }
 ```
 
-Built from 70552964e3760fb5b103235917b00364f6d45763 at 2026-07-24T16:29:07.170Z. Source: https://github.com/ecto/vcad
+Built from 292cf10c5c65aec57d1c40f8bd5bdb0a1222acaf at 2026-07-24T16:37:44.101Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -68,8 +68,11 @@ __export(vcad_kernel_wasm_exports, {
   atoms_minimize: () => atoms_minimize,
   atoms_parse_xyz: () => atoms_parse_xyz,
   atoms_write_xyz: () => atoms_write_xyz,
+  buildCalibrationReportJson: () => buildCalibrationReportJson,
   buildPart: () => buildPart,
   build_chat_system_prompt: () => build_chat_system_prompt,
+  calibrationDefaultTolerance: () => calibrationDefaultTolerance,
+  calibrationFingerprintDocument: () => calibrationFingerprintDocument,
   camDropCutter: () => camDropCutter,
   camExportGcode: () => camExportGcode,
   camExportLinuxCnc: () => camExportLinuxCnc,
@@ -155,6 +158,9 @@ __export(vcad_kernel_wasm_exports, {
   exportKicadProject: () => exportKicadProject,
   exportKicadSch: () => exportKicadSch,
   exportProjectedViewToDxf: () => exportProjectedViewToDxf,
+  exprEvalAst: () => exprEvalAst,
+  exprEvaluate: () => exprEvaluate,
+  exprParse: () => exprParse,
   feaAnalyzeMesh: () => feaAnalyzeMesh,
   generate3mf: () => generate3mf,
   generate3mfWithGcode: () => generate3mfWithGcode,
@@ -184,6 +190,7 @@ __export(vcad_kernel_wasm_exports, {
   nestSheetMetalParts: () => nestSheetMetalParts,
   nestedSheetMetalDxf: () => nestedSheetMetalDxf,
   neutronicsSimulate: () => neutronicsSimulate,
+  noteToHz: () => noteToHz,
   offsetSectionMesh: () => offsetSectionMesh,
   op_chamfer: () => op_chamfer,
   op_circular_pattern: () => op_circular_pattern,
@@ -218,11 +225,14 @@ __export(vcad_kernel_wasm_exports, {
   render_svg_view: () => render_svg_view,
   render_svg_view_highlight: () => render_svg_view_highlight,
   render_svg_view_section: () => render_svg_view_section,
+  resolveDocumentJson: () => resolveDocumentJson,
+  resolveParametersJson: () => resolveParametersJson,
   sample_timeline_sequence: () => sample_timeline_sequence,
   sample_timeline_track: () => sample_timeline_track,
   sectionMesh: () => sectionMesh,
   sheetMetalFoldedStep: () => sheetMetalFoldedStep,
   sheetMetalSequence: () => sheetMetalSequence,
+  simulateStrikeKernel: () => simulateStrikeKernel,
   sketchCircleSegments: () => sketchCircleSegments,
   sketchHitTest: () => sketchHitTest,
   sketchPlaneBasis: () => sketchPlaneBasis,
@@ -428,6 +438,31 @@ function atoms_write_xyz(molecule_json) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
+function buildCalibrationReportJson(prediction_json, measurements_json, options_json) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(prediction_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(measurements_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.buildCalibrationReportJson(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
 function buildPart(path, params_json) {
   let deferred4_0;
   let deferred4_1;
@@ -467,6 +502,36 @@ function build_chat_system_prompt(parts_json, selection_json) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
+function calibrationDefaultTolerance(kind, predicted) {
+  const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.calibrationDefaultTolerance(ptr0, len0, predicted);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0];
+}
+function calibrationFingerprintDocument(doc_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(doc_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.calibrationFingerprintDocument(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
 function camDropCutter(vertices_json, indices_json, tool_json, bounds_json, resolution) {
   let deferred6_0;
   let deferred6_1;
@@ -1548,6 +1613,31 @@ function exportProjectedViewToDxf(view_json) {
   wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
   return v2;
 }
+function exprEvalAst(ast, env) {
+  const ret = wasm.exprEvalAst(ast, env);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0];
+}
+function exprEvaluate(src, env) {
+  const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.exprEvaluate(ptr0, len0, env);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0];
+}
+function exprParse(src) {
+  const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.exprParse(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
 function feaAnalyzeMesh(spec_json, options_json, positions, indices) {
   const ptr0 = passStringToWasm0(spec_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -1856,6 +1946,15 @@ function neutronicsSimulate(spec_json, params_json) {
   }
   return takeFromExternrefTable0(ret[0]);
 }
+function noteToHz(note) {
+  const ptr0 = passStringToWasm0(note, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.noteToHz(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return ret[0];
+}
 function offsetSectionMesh(mesh_js, plane_json, hatch_json) {
   const ptr0 = passStringToWasm0(plane_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -2344,6 +2443,48 @@ function render_svg_view_section(vcad_json, scale, view, section) {
     wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
   }
 }
+function resolveDocumentJson(doc_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(doc_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.resolveDocumentJson(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function resolveParametersJson(params_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(params_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.resolveParametersJson(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
 function sample_timeline_sequence(timeline_json) {
   let deferred3_0;
   let deferred3_1;
@@ -2410,6 +2551,27 @@ function sheetMetalSequence(chain_json) {
     wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
   }
 }
+function simulateStrikeKernel(input_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.simulateStrikeKernel(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
 function sketchCircleSegments(cx, cy, radius, segments) {
   let deferred2_0;
   let deferred2_1;
@@ -2793,6 +2955,12 @@ function __wbg_get_imports() {
       const ret = arg0.WorkerGlobalScope;
       return ret;
     },
+    __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
+      const v = arg1;
+      const ret = typeof v === "bigint" ? v : void 0;
+      getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
     __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
       const v = arg0;
       const ret = typeof v === "boolean" ? v : void 0;
@@ -2809,6 +2977,10 @@ function __wbg_get_imports() {
       const ret = arg0 in arg1;
       return ret;
     },
+    __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+      const ret = typeof arg0 === "bigint";
+      return ret;
+    },
     __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
       const ret = typeof arg0 === "function";
       return ret;
@@ -2830,6 +3002,10 @@ function __wbg_get_imports() {
       const ret = arg0 === void 0;
       return ret;
     },
+    __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
+      const ret = arg0 === arg1;
+      return ret;
+    },
     __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
       const ret = arg0 == arg1;
       return ret;
@@ -3385,6 +3561,10 @@ function __wbg_get_imports() {
     __wbg_end_6f776519f1faa582: function(arg0) {
       arg0.end();
     },
+    __wbg_entries_58c7934c745daac7: function(arg0) {
+      const ret = Object.entries(arg0);
+      return ret;
+    },
     __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
       let deferred0_0;
       let deferred0_1;
@@ -3730,6 +3910,16 @@ function __wbg_get_imports() {
       const ret = result;
       return ret;
     },
+    __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Map;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
     __wbg_instanceof_Object_1c6af87502b733ed: function(arg0) {
       let result;
       try {
@@ -40800,6 +40990,7 @@ var init_part_labels = __esm({
 var init_export_stl = __esm({
   "../core/dist/utils/export-stl.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -40807,6 +40998,7 @@ var init_export_stl = __esm({
 var init_export_gltf = __esm({
   "../core/dist/utils/export-gltf.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -49177,6 +49369,15 @@ var init_loon = __esm({
 });
 
 // src/export/glb.ts
+function exportKernel() {
+  const mod = getKernelWasmSync();
+  if (!mod) {
+    throw new Error(
+      "kernel WASM not initialized \u2014 await getKernelWasm() before exporting"
+    );
+  }
+  return mod;
+}
 function buildPartLabels(doc) {
   return doc.roots.filter((entry) => entry.visible !== false).map((entry) => {
     const name = doc.nodes[String(entry.root)]?.name;
@@ -49184,363 +49385,71 @@ function buildPartLabels(doc) {
   });
 }
 function eulerXyzDegToQuat(rotation) {
-  const rad = Math.PI / 180;
-  const hx = rotation.x * rad / 2;
-  const hy = rotation.y * rad / 2;
-  const hz = rotation.z * rad / 2;
-  const c1 = Math.cos(hx);
-  const s1 = Math.sin(hx);
-  const c2 = Math.cos(hy);
-  const s2 = Math.sin(hy);
-  const c3 = Math.cos(hz);
-  const s3 = Math.sin(hz);
-  return [
-    s1 * c2 * c3 - c1 * s2 * s3,
-    c1 * s2 * c3 + s1 * c2 * s3,
-    c1 * c2 * s3 - s1 * s2 * c3,
-    c1 * c2 * c3 + s1 * s2 * s3
-  ];
+  const q = exportKernel().eulerXyzDegToQuat(rotation.x, rotation.y, rotation.z);
+  return [q[0], q[1], q[2], q[3]];
 }
 function buildGlb(inputMeshes, name, animation) {
-  const materialMap = /* @__PURE__ */ new Map();
-  const materials = [];
-  const materialIndexFor = (m) => {
-    const emissive = m.emissive ?? [0, 0, 0];
-    const emissiveStrength = m.emissiveStrength ?? 1;
-    const clearcoat = m.clearcoat ?? 0;
-    const clearcoatRoughness = m.clearcoatRoughness ?? 0;
-    const alpha = m.alpha ?? 1;
-    const key = `${m.color[0]},${m.color[1]},${m.color[2]},${m.metallic},${m.roughness},${emissive[0]},${emissive[1]},${emissive[2]},${emissiveStrength},${clearcoat},${clearcoatRoughness},${alpha}`;
-    const existing = materialMap.get(key);
-    if (existing !== void 0) return existing;
-    const idx = materials.length;
-    materialMap.set(key, idx);
-    materials.push({
-      name: m.name.includes(":") ? m.name.split(":")[0] : m.name,
-      color: m.color,
-      metallic: m.metallic,
-      roughness: m.roughness,
-      emissive,
-      emissiveStrength,
-      clearcoat,
-      clearcoatRoughness,
-      alpha
-    });
-    return idx;
+  let f32Len = 0;
+  let u32Len = 0;
+  for (const m of inputMeshes) {
+    f32Len += m.positions.length;
+    u32Len += m.indices.length;
+    if (m.normals && m.normals.length === m.positions.length) {
+      f32Len += m.normals.length;
+    }
+  }
+  for (const ch of animation?.channels ?? []) {
+    f32Len += ch.times.length + ch.values.length;
+  }
+  const f32Data = new Float32Array(f32Len);
+  const u32Data = new Uint32Array(u32Len);
+  let f32Off = 0;
+  let u32Off = 0;
+  const pushF32 = (data) => {
+    f32Data.set(data, f32Off);
+    const span = [f32Off, data.length];
+    f32Off += data.length;
+    return span;
   };
-  if (inputMeshes.length === 0) {
-    materials.push({
-      ...DEFAULT_MATERIAL,
-      emissive: [0, 0, 0],
-      emissiveStrength: 1,
-      clearcoat: 0,
-      clearcoatRoughness: 0,
-      alpha: 1
-    });
-  }
-  const bufferChunks = [];
-  const bufferViews = [];
-  const accessors = [];
-  const meshes = [];
-  const nodes = [];
-  let bufferOffset = 0;
-  const meshKeyToIdx = /* @__PURE__ */ new Map();
-  for (let inputIdx = 0; inputIdx < inputMeshes.length; inputIdx++) {
-    const input = inputMeshes[inputIdx];
-    const dedupIdx = input.meshKey !== void 0 ? meshKeyToIdx.get(input.meshKey) : void 0;
-    if (dedupIdx !== void 0) {
-      nodes.push(makeNode(input, dedupIdx));
-      continue;
-    }
-    const positions = f32(input.positions);
-    const normals = input.normals && input.normals.length === positions.length ? f32(input.normals) : void 0;
-    const vertexCount = positions.length / 3;
-    const indexCount = input.indices.length;
-    let minX = Infinity, minY = Infinity, minZ = Infinity;
-    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    for (let i = 0; i < vertexCount; i++) {
-      const x = positions[i * 3];
-      const y = positions[i * 3 + 1];
-      const z = positions[i * 3 + 2];
-      minX = Math.min(minX, x);
-      minY = Math.min(minY, y);
-      minZ = Math.min(minZ, z);
-      maxX = Math.max(maxX, x);
-      maxY = Math.max(maxY, y);
-      maxZ = Math.max(maxZ, z);
-    }
-    const indicesBytes = new Uint8Array(indexCount * 4);
-    const indicesView = new DataView(indicesBytes.buffer);
-    for (let i = 0; i < indexCount; i++) {
-      indicesView.setUint32(i * 4, input.indices[i], true);
-    }
-    const indicesPadded = padTo4(indicesBytes);
-    bufferChunks.push(indicesPadded);
-    const indicesBvIdx = bufferViews.length;
-    bufferViews.push({
-      buffer: 0,
-      byteOffset: bufferOffset,
-      byteLength: indexCount * 4,
-      target: 34963
-      // ELEMENT_ARRAY_BUFFER
-    });
-    bufferOffset += indicesPadded.length;
-    const indicesAccIdx = accessors.length;
-    accessors.push({
-      bufferView: indicesBvIdx,
-      componentType: 5125,
-      // UNSIGNED_INT
-      count: indexCount,
-      type: "SCALAR"
-    });
-    const positionsBytes = new Uint8Array(
-      positions.buffer.slice(
-        positions.byteOffset,
-        positions.byteOffset + vertexCount * 12
-      )
-    );
-    const positionsPadded = padTo4(positionsBytes);
-    bufferChunks.push(positionsPadded);
-    const positionsBvIdx = bufferViews.length;
-    bufferViews.push({
-      buffer: 0,
-      byteOffset: bufferOffset,
-      byteLength: vertexCount * 12,
-      target: 34962
-      // ARRAY_BUFFER
-    });
-    bufferOffset += positionsPadded.length;
-    const positionsAccIdx = accessors.length;
-    accessors.push({
-      bufferView: positionsBvIdx,
-      componentType: 5126,
-      // FLOAT
-      count: vertexCount,
-      type: "VEC3",
-      min: [minX, minY, minZ],
-      max: [maxX, maxY, maxZ]
-    });
-    const attributes = {
-      POSITION: positionsAccIdx
-    };
-    if (normals) {
-      const normalsBytes = new Uint8Array(
-        normals.buffer.slice(
-          normals.byteOffset,
-          normals.byteOffset + vertexCount * 12
-        )
-      );
-      const normalsPadded = padTo4(normalsBytes);
-      bufferChunks.push(normalsPadded);
-      const normalsBvIdx = bufferViews.length;
-      bufferViews.push({
-        buffer: 0,
-        byteOffset: bufferOffset,
-        byteLength: vertexCount * 12,
-        target: 34962
-        // ARRAY_BUFFER
-      });
-      bufferOffset += normalsPadded.length;
-      const normalsAccIdx = accessors.length;
-      accessors.push({
-        bufferView: normalsBvIdx,
-        componentType: 5126,
-        // FLOAT
-        count: vertexCount,
-        type: "VEC3"
-      });
-      attributes.NORMAL = normalsAccIdx;
-    }
-    const meshIdx = meshes.length;
-    meshes.push({
-      name: `mesh_${meshIdx}`,
-      primitives: [
-        {
-          attributes,
-          indices: indicesAccIdx,
-          material: materialIndexFor(input)
-        }
-      ]
-    });
-    if (input.meshKey !== void 0) meshKeyToIdx.set(input.meshKey, meshIdx);
-    nodes.push(makeNode(input, meshIdx));
-  }
-  let sceneNodeIndices = nodes.map((_, i) => i);
-  if (animation?.rootNodeName !== void 0) {
-    const rootIdx = nodes.length;
-    nodes.push({
-      name: animation.rootNodeName,
-      children: sceneNodeIndices
-    });
-    sceneNodeIndices = [rootIdx];
-  }
-  for (const extra of animation?.extraNodes ?? []) {
-    const idx = nodes.length;
-    nodes.push({ name: extra });
-    sceneNodeIndices = [...sceneNodeIndices, idx];
-  }
-  let animationsJson;
-  if (animation && animation.channels.length > 0) {
-    const nodeIndexByName = /* @__PURE__ */ new Map();
-    for (let i = 0; i < nodes.length; i++) {
-      nodeIndexByName.set(nodes[i].name, i);
-    }
-    const writeF32Accessor = (data, type, withMinMax) => {
-      const arr = new Float32Array(data);
-      const bytes = new Uint8Array(arr.buffer.slice(0));
-      const padded = padTo4(bytes);
-      bufferChunks.push(padded);
-      const bvIdx = bufferViews.length;
-      bufferViews.push({
-        buffer: 0,
-        byteOffset: bufferOffset,
-        byteLength: bytes.length
-      });
-      bufferOffset += padded.length;
-      const components = type === "SCALAR" ? 1 : type === "VEC3" ? 3 : 4;
-      const accIdx = accessors.length;
-      const acc = {
-        bufferView: bvIdx,
-        componentType: 5126,
-        // FLOAT
-        count: data.length / components,
-        type
-      };
-      if (withMinMax) {
-        acc.min = [Math.min(...data)];
-        acc.max = [Math.max(...data)];
-      }
-      accessors.push(acc);
-      return accIdx;
-    };
-    const samplers = [];
-    const channels = [];
-    for (const ch of animation.channels) {
-      const nodeIdx = nodeIndexByName.get(ch.nodeName);
-      if (nodeIdx === void 0) {
-        console.warn(
-          `buildGlb: animation channel targets unknown node "${ch.nodeName}" \u2014 skipped`
-        );
-        continue;
-      }
-      const inputAcc = writeF32Accessor(ch.times, "SCALAR", true);
-      const outputAcc = writeF32Accessor(
-        ch.values,
-        ch.path === "rotation" ? "VEC4" : "VEC3",
-        false
-      );
-      const samplerIdx = samplers.length;
-      samplers.push({
-        input: inputAcc,
-        output: outputAcc,
-        interpolation: ch.interpolation ?? "LINEAR"
-      });
-      channels.push({
-        sampler: samplerIdx,
-        target: { node: nodeIdx, path: ch.path }
-      });
-    }
-    if (channels.length > 0) {
-      animationsJson = [
-        { name: animation.name ?? "timeline", samplers, channels }
-      ];
-    }
-  }
-  let usesClearcoat = false;
-  let usesEmissiveStrength = false;
-  const materialJson = materials.map((m) => {
-    const mat = {
-      name: m.name,
-      pbrMetallicRoughness: {
-        baseColorFactor: [...m.color, m.alpha],
-        metallicFactor: m.metallic,
-        roughnessFactor: m.roughness
-      }
-    };
-    if (m.alpha < 1) {
-      mat.alphaMode = "BLEND";
-      mat.doubleSided = true;
-    }
-    if (isEmissive(m.emissive)) {
-      mat.emissiveFactor = m.emissive;
-    }
-    const extensions = {};
-    if (m.clearcoat > 0) {
-      usesClearcoat = true;
-      extensions.KHR_materials_clearcoat = {
-        clearcoatFactor: m.clearcoat,
-        clearcoatRoughnessFactor: m.clearcoatRoughness
-      };
-    }
-    if (isEmissive(m.emissive) && m.emissiveStrength !== 1) {
-      usesEmissiveStrength = true;
-      extensions.KHR_materials_emissive_strength = {
-        emissiveStrength: m.emissiveStrength
-      };
-    }
-    if (Object.keys(extensions).length > 0) mat.extensions = extensions;
-    return mat;
-  });
-  const extensionsUsed = [];
-  if (usesClearcoat) extensionsUsed.push("KHR_materials_clearcoat");
-  if (usesEmissiveStrength)
-    extensionsUsed.push("KHR_materials_emissive_strength");
-  const json = {
-    asset: { version: "2.0", generator: "vcad-mcp" },
-    scene: 0,
-    scenes: [{ name, nodes: sceneNodeIndices }],
-    nodes,
+  const pushU32 = (data) => {
+    u32Data.set(data, u32Off);
+    const span = [u32Off, data.length];
+    u32Off += data.length;
+    return span;
+  };
+  const meshes = inputMeshes.map((m) => ({
+    name: m.name,
+    positions: pushF32(m.positions),
+    indices: pushU32(m.indices),
+    normals: m.normals && m.normals.length === m.positions.length ? pushF32(m.normals) : void 0,
+    color: m.color,
+    metallic: m.metallic,
+    roughness: m.roughness,
+    emissive: m.emissive,
+    emissiveStrength: m.emissiveStrength,
+    clearcoat: m.clearcoat,
+    clearcoatRoughness: m.clearcoatRoughness,
+    alpha: m.alpha,
+    transform: m.transform,
+    meshKey: m.meshKey
+  }));
+  const spec = {
+    name,
     meshes,
-    materials: materialJson,
-    accessors,
-    bufferViews,
-    buffers: [{ byteLength: bufferOffset }]
+    animation: animation ? {
+      name: animation.name,
+      channels: animation.channels.map((ch) => ({
+        nodeName: ch.nodeName,
+        path: ch.path,
+        times: pushF32(ch.times),
+        values: pushF32(ch.values),
+        interpolation: ch.interpolation
+      })),
+      rootNodeName: animation.rootNodeName,
+      extraNodes: animation.extraNodes
+    } : void 0
   };
-  if (extensionsUsed.length > 0) json.extensionsUsed = extensionsUsed;
-  if (animationsJson) json.animations = animationsJson;
-  const jsonStr = JSON.stringify(json);
-  const jsonBytes = new TextEncoder().encode(jsonStr);
-  const jsonPadded = padTo4(jsonBytes, 32);
-  const binBuffer = new Uint8Array(bufferOffset);
-  let binOffset = 0;
-  for (const chunk of bufferChunks) {
-    binBuffer.set(chunk, binOffset);
-    binOffset += chunk.length;
-  }
-  const totalLength = 12 + 8 + jsonPadded.length + 8 + binBuffer.length;
-  const glb = new Uint8Array(totalLength);
-  const glbView = new DataView(glb.buffer);
-  let offset = 0;
-  glb.set(new TextEncoder().encode("glTF"), offset);
-  offset += 4;
-  glbView.setUint32(offset, 2, true);
-  offset += 4;
-  glbView.setUint32(offset, totalLength, true);
-  offset += 4;
-  glbView.setUint32(offset, jsonPadded.length, true);
-  offset += 4;
-  glbView.setUint32(offset, 1313821514, true);
-  offset += 4;
-  glb.set(jsonPadded, offset);
-  offset += jsonPadded.length;
-  glbView.setUint32(offset, binBuffer.length, true);
-  offset += 4;
-  glbView.setUint32(offset, 5130562, true);
-  offset += 4;
-  glb.set(binBuffer, offset);
-  return glb;
-}
-function makeNode(input, meshIdx) {
-  const node = { mesh: meshIdx, name: input.name };
-  const t2 = input.transform;
-  if (!t2) return node;
-  const [tx, ty, tz] = t2.translation;
-  if (tx !== 0 || ty !== 0 || tz !== 0) node.translation = t2.translation;
-  const [qx, qy, qz, qw] = t2.rotationQuat;
-  if (qx !== 0 || qy !== 0 || qz !== 0 || qw !== 1) node.rotation = t2.rotationQuat;
-  const [sx, sy, sz] = t2.scale;
-  if (sx !== 1 || sy !== 1 || sz !== 1) node.scale = t2.scale;
-  return node;
+  return exportKernel().buildGlbBytes(JSON.stringify(spec), f32Data, u32Data);
 }
 function toGlbBytes(scene, name, partLabels) {
   const meshes = scene.parts.map((part, i) => ({
@@ -49554,28 +49463,17 @@ function toGlbBytes(scene, name, partLabels) {
   }));
   return buildGlb(meshes, name);
 }
-function padTo4(bytes, padByte = 0) {
-  const paddedLength = bytes.length + 3 & ~3;
-  if (paddedLength === bytes.length) return bytes;
-  const padded = new Uint8Array(paddedLength);
-  padded.set(bytes);
-  for (let i = bytes.length; i < paddedLength; i++) {
-    padded[i] = padByte;
-  }
-  return padded;
-}
-var DEFAULT_MATERIAL, isEmissive, f32;
+var DEFAULT_MATERIAL;
 var init_glb = __esm({
   "src/export/glb.ts"() {
     "use strict";
+    init_dist();
     DEFAULT_MATERIAL = {
       name: "default",
       color: [0.8, 0.8, 0.8],
       metallic: 0.1,
       roughness: 0.5
     };
-    isEmissive = (e) => e[0] > 0 || e[1] > 0 || e[2] > 0;
-    f32 = (a) => a instanceof Float32Array ? a : new Float32Array(a);
   }
 });
 
@@ -56362,80 +56260,37 @@ var init_parts2 = __esm({
 
 // src/export/stl.ts
 function toStlBytes(scene, name) {
-  let totalTriangles = 0;
+  let f32Len = 0;
+  let u32Len = 0;
   for (const part of scene.parts) {
-    totalTriangles += part.mesh.indices.length / 3;
-  }
-  const buffer = new ArrayBuffer(84 + totalTriangles * 50);
-  const view = new DataView(buffer);
-  const uint8 = new Uint8Array(buffer);
-  const header = name.slice(0, 80).padEnd(80, " ");
-  for (let i = 0; i < 80; i++) {
-    uint8[i] = header.charCodeAt(i);
-  }
-  view.setUint32(80, totalTriangles, true);
-  let offset = 84;
-  for (const part of scene.parts) {
-    offset = writeMeshTriangles(part.mesh, view, offset);
-  }
-  return uint8;
-}
-function writeMeshTriangles(mesh, view, offset) {
-  const positions = mesh.positions;
-  const indices = mesh.indices;
-  const numTriangles = indices.length / 3;
-  for (let t2 = 0; t2 < numTriangles; t2++) {
-    const i0 = indices[t2 * 3];
-    const i1 = indices[t2 * 3 + 1];
-    const i2 = indices[t2 * 3 + 2];
-    const v0x = positions[i0 * 3];
-    const v0y = positions[i0 * 3 + 1];
-    const v0z = positions[i0 * 3 + 2];
-    const v1x = positions[i1 * 3];
-    const v1y = positions[i1 * 3 + 1];
-    const v1z = positions[i1 * 3 + 2];
-    const v2x = positions[i2 * 3];
-    const v2y = positions[i2 * 3 + 1];
-    const v2z = positions[i2 * 3 + 2];
-    const e1x = v1x - v0x;
-    const e1y = v1y - v0y;
-    const e1z = v1z - v0z;
-    const e2x = v2x - v0x;
-    const e2y = v2y - v0y;
-    const e2z = v2z - v0z;
-    let nx = e1y * e2z - e1z * e2y;
-    let ny = e1z * e2x - e1x * e2z;
-    let nz = e1x * e2y - e1y * e2x;
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-    if (len > 1e-10) {
-      nx /= len;
-      ny /= len;
-      nz /= len;
-    }
-    view.setFloat32(offset, nx, true);
-    view.setFloat32(offset + 4, ny, true);
-    view.setFloat32(offset + 8, nz, true);
-    offset += 12;
-    view.setFloat32(offset, v0x, true);
-    view.setFloat32(offset + 4, v0y, true);
-    view.setFloat32(offset + 8, v0z, true);
-    offset += 12;
-    view.setFloat32(offset, v1x, true);
-    view.setFloat32(offset + 4, v1y, true);
-    view.setFloat32(offset + 8, v1z, true);
-    offset += 12;
-    view.setFloat32(offset, v2x, true);
-    view.setFloat32(offset + 4, v2y, true);
-    view.setFloat32(offset + 8, v2z, true);
-    offset += 12;
-    view.setUint16(offset, 0, true);
-    offset += 2;
-  }
-  return offset;
+    f32Len += part.mesh.positions.length;
+    u32Len += part.mesh.indices.length;
+  }
+  const f32Data = new Float32Array(f32Len);
+  const u32Data = new Uint32Array(u32Len);
+  let f32Off = 0;
+  let u32Off = 0;
+  const meshes = scene.parts.map((part) => {
+    f32Data.set(part.mesh.positions, f32Off);
+    u32Data.set(part.mesh.indices, u32Off);
+    const spec = {
+      positions: [f32Off, part.mesh.positions.length],
+      indices: [u32Off, part.mesh.indices.length]
+    };
+    f32Off += part.mesh.positions.length;
+    u32Off += part.mesh.indices.length;
+    return spec;
+  });
+  return exportKernel().buildStlBytes(
+    JSON.stringify({ name, meshes }),
+    f32Data,
+    u32Data
+  );
 }
 var init_stl = __esm({
   "src/export/stl.ts"() {
     "use strict";
+    init_glb();
   }
 });
 
@@ -77903,8 +77758,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.13") {
-        return "0.9.4-main.13";
+      if ("0.9.4-main.14") {
+        return "0.9.4-main.14";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -77913,8 +77768,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "70552964e3760fb5b103235917b00364f6d45763";
-    BUILD_TIME = "2026-07-24T16:29:07.170Z";
+    BUILD_SHA = "292cf10c5c65aec57d1c40f8bd5bdb0a1222acaf";
+    BUILD_TIME = "2026-07-24T16:37:44.101Z";
     SHORT_SHA = BUILD_SHA === "unknown" ? "unknown" : BUILD_SHA.slice(0, 7);
     VERSION_WITH_BUILD = SHORT_SHA === "unknown" ? PKG_VERSION : `${PKG_VERSION}+${SHORT_SHA}`;
     INSTANCE_ID = randomUUID6().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.13",
+  "version": "0.9.4-main.14",
   "description": "vcad MCP server — parametric CAD + PCB design tools for AI agents (self-contained: bundled server + kernel WASM)",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
   },
   "homepage": "https://vcad.io",
   "vcadBuild": {
-    "sha": "70552964e3760fb5b103235917b00364f6d45763",
-    "builtAt": "2026-07-24T16:29:07.170Z"
+    "sha": "292cf10c5c65aec57d1c40f8bd5bdb0a1222acaf",
+    "builtAt": "2026-07-24T16:37:44.101Z"
   }
 }