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

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 {
@@ -8022,14 +8212,22 @@ async function loadAndInit() {
     }
     await mod.default(hint ? { module_or_path: hint } : void 0);
   }
+  assertKernelBaseline(mod);
   wasmModule2 = mod;
   generation++;
   return mod;
 }
+function assertKernelBaseline(mod) {
+  const missing = REQUIRED_BINDINGS.filter((name) => typeof mod[name] !== "function");
+  if (missing.length > 0) {
+    const version2 = typeof mod.get_kernel_version === "function" ? mod.get_kernel_version() : "unknown";
+    throw new Error(`stale @vcad/kernel-wasm bundle (kernel version ${version2}): missing required bindings ${missing.join(", ")} \u2014 rebuild the workspace (VCAD_WASM_SKIP unset) or update to a current bundle`);
+  }
+}
 function getKernelWasmSync() {
   return wasmModule2;
 }
-var wasmPromise, wasmModule2, wasmInputHint, bindgenStarted, lastModuleBuffer, lastTrap, generation;
+var wasmPromise, wasmModule2, wasmInputHint, bindgenStarted, lastModuleBuffer, lastTrap, generation, REQUIRED_BINDINGS;
 var init_wasm_singleton = __esm({
   "../engine/dist/wasm-singleton.js"() {
     "use strict";
@@ -8038,6 +8236,13 @@ var init_wasm_singleton = __esm({
     bindgenStarted = false;
     lastTrap = null;
     generation = 0;
+    REQUIRED_BINDINGS = [
+      "evaluateDocument",
+      "documentDiff",
+      "documentMerge",
+      "documentToLoon",
+      "documentToLoonChecked"
+    ];
   }
 });
 
@@ -8509,7 +8714,10 @@ function evaluateDocument2(doc, kernel2, options = {}) {
   const resolved = resolveDocument(doc);
   doc = resolved.doc;
   doc = expandPartInstances(doc, kernel2);
-  if (kernel2.evaluateDocument) {
+  if (!kernel2.evaluateDocument) {
+    throw new Error("kernel WASM bundle is missing the evaluateDocument binding \u2014 rebuild @vcad/kernel-wasm (stale bundle); old bundles are unsupported");
+  }
+  {
     try {
       const docJson = JSON.stringify(doc);
       const result = kernel2.evaluateDocument(docJson, options.skipClashDetection ?? false);
@@ -9637,114 +9845,11 @@ var init_gpu = __esm({
 });
 
 // ../engine/dist/diff.js
-function decompose(doc) {
-  const obj = doc;
-  const entities = /* @__PURE__ */ new Map();
-  for (const [field, kind] of MAP_TABLES) {
-    const table = obj[field];
-    if (table && typeof table === "object" && !Array.isArray(table)) {
-      for (const [id, v] of Object.entries(table)) {
-        entities.set(`${kind}\0${id}`, v);
-      }
-    }
-  }
-  for (const [field, kind, idField] of VEC_TABLES) {
-    const items = obj[field];
-    if (Array.isArray(items)) {
-      for (const item of items) {
-        const raw = item?.[idField];
-        const id = typeof raw === "string" ? raw : JSON.stringify(raw);
-        entities.set(`${kind}\0${id}`, item);
-      }
-    }
-  }
-  for (const field of DOC_FIELDS) {
-    const v = obj[field];
-    if (v !== void 0 && v !== null)
-      entities.set(`doc\0${field}`, v);
-  }
-  return entities;
-}
-function deepEqual(a, b) {
-  if (a === b)
-    return true;
-  if (typeof a !== typeof b || a === null || b === null)
-    return false;
-  if (typeof a !== "object")
-    return false;
-  if (Array.isArray(a) !== Array.isArray(b))
-    return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length)
-      return false;
-    return a.every((v, i) => deepEqual(v, b[i]));
-  }
-  const ka = Object.keys(a).filter((k) => a[k] !== void 0);
-  const kb = Object.keys(b).filter((k) => b[k] !== void 0);
-  if (ka.length !== kb.length)
-    return false;
-  return ka.every((k) => deepEqual(a[k], b[k]));
-}
-function valueDiff(prefix, oldV, newV, out) {
-  if (deepEqual(oldV, newV))
-    return;
-  const join4 = (k) => prefix ? `${prefix}.${k}` : k;
-  const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-  if (isObj(oldV) && isObj(newV)) {
-    const keys = /* @__PURE__ */ new Set([...Object.keys(oldV), ...Object.keys(newV)]);
-    for (const k of keys) {
-      valueDiff(join4(k), oldV[k] ?? null, newV[k] ?? null, out);
-    }
-    return;
-  }
-  if (Array.isArray(oldV) && Array.isArray(newV) && oldV.length === newV.length) {
-    oldV.forEach((v, i) => valueDiff(join4(String(i)), v, newV[i], out));
-    return;
-  }
-  out.push({ path: prefix, old: oldV, new: newV });
-}
-function entityName(v) {
-  const n = v?.name;
-  return typeof n === "string" ? n : void 0;
-}
-function semanticDiffFallback(oldDoc, newDoc) {
-  const a = decompose(oldDoc);
-  const b = decompose(newDoc);
-  const keys = [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])].sort();
-  const changes = [];
-  for (const key of keys) {
-    const [kind, id] = key.split("\0");
-    const va = a.get(key);
-    const vb = b.get(key);
-    if (va === void 0 && vb !== void 0) {
-      changes.push({ kind, id, name: entityName(vb), type: "added", value: vb });
-    } else if (va !== void 0 && vb === void 0) {
-      changes.push({ kind, id, name: entityName(va), type: "removed", value: va });
-    } else if (!deepEqual(va, vb)) {
-      const fields = [];
-      valueDiff("", va, vb, fields);
-      if (fields.length > 0) {
-        changes.push({
-          kind,
-          id,
-          name: entityName(vb) ?? entityName(va),
-          type: "modified",
-          fields
-        });
-      }
-    }
-  }
-  return { changes };
-}
 function semanticDiff(oldDoc, newDoc, kernel2) {
-  if (kernel2?.documentDiff) {
-    try {
-      return kernel2.documentDiff(JSON.stringify(oldDoc), JSON.stringify(newDoc));
-    } catch (e) {
-      console.warn("[diff] kernel documentDiff failed, using TS fallback:", e);
-    }
+  if (!kernel2?.documentDiff) {
+    throw new Error("semantic diff needs a kernel build with the documentDiff binding \u2014 ensure the kernel WASM is initialized (getKernelWasm) and current");
   }
-  return semanticDiffFallback(oldDoc, newDoc);
+  return kernel2.documentDiff(JSON.stringify(oldDoc), JSON.stringify(newDoc));
 }
 function mergeAvailable(kernel2) {
   return typeof kernel2?.documentMerge === "function";
@@ -9755,33 +9860,9 @@ function threeWayMerge(base, ours, theirs, resolutions, kernel2) {
   }
   return kernel2.documentMerge(JSON.stringify(base), JSON.stringify(ours), JSON.stringify(theirs), resolutions.length > 0 ? JSON.stringify(resolutions) : null);
 }
-var MAP_TABLES, VEC_TABLES, DOC_FIELDS;
 var init_diff = __esm({
   "../engine/dist/diff.js"() {
     "use strict";
-    MAP_TABLES = [
-      ["nodes", "node"],
-      ["materials", "material"],
-      ["part_materials", "part-material"],
-      ["partDefs", "part-def"],
-      ["parameters", "parameter"],
-      ["bindings", "binding"]
-    ];
-    VEC_TABLES = [
-      ["roots", "root", "root"],
-      ["instances", "instance", "id"],
-      ["joints", "joint", "id"],
-      ["clearance_specs", "clearance", "label"]
-    ];
-    DOC_FIELDS = [
-      "version",
-      "scene",
-      "groundInstanceId",
-      "schematic",
-      "pcb",
-      "molecule",
-      "timeline"
-    ];
   }
 });
 
@@ -11631,7 +11712,6 @@ __export(dist_exports, {
   searchEcadParts: () => searchEcadParts,
   searchParts: () => searchParts,
   semanticDiff: () => semanticDiff,
-  semanticDiffFallback: () => semanticDiffFallback,
   solveDesignConstraints: () => solveDesignConstraints2,
   solveForwardKinematics: () => solveForwardKinematics2,
   threeWayMerge: () => threeWayMerge,
@@ -11801,6 +11881,8 @@ var init_dist = __esm({
           sheetMetalSequence: wasmModule7.sheetMetalSequence,
           nestSheetMetalParts: wasmModule7.nestSheetMetalParts,
           getSheetMetalMaterials: wasmModule7.getSheetMetalMaterials,
+          simulateStrikeKernel: wasmModule7.simulateStrikeKernel,
+          noteToHz: wasmModule7.noteToHz,
           getSheetMetalBendTable: wasmModule7.getSheetMetalBendTable,
           getSheetMetalShopCatalog: wasmModule7.getSheetMetalShopCatalog,
           sheetMetalFoldedStep: wasmModule7.sheetMetalFoldedStep,
@@ -12342,6 +12424,27 @@ var init_dist = __esm({
           return null;
         return sheetMetalSequence2(chain, this.kernel);
       }
+      /**
+       * Run the kernel's mallet-strike pipeline (free-free bar modal analysis +
+       * synthesis + FFT verdict). Input/output shapes are JSON mirrors of
+       * `vcad_kernel_acoustics::strike::{StrikeInput, StrikeResult}` with the
+       * WAV base64-encoded as `wav_base64`.
+       */
+      simulateStrike(input) {
+        const kernel2 = this.kernel;
+        if (!kernel2.simulateStrikeKernel) {
+          throw new Error("kernel WASM build lacks simulateStrikeKernel \u2014 rebuild @vcad/kernel-wasm");
+        }
+        return JSON.parse(kernel2.simulateStrikeKernel(JSON.stringify(input)));
+      }
+      /** Parse a note name ("C6", "F#4") to Hz via the kernel. */
+      noteToHz(note) {
+        const kernel2 = this.kernel;
+        if (!kernel2.noteToHz) {
+          throw new Error("kernel WASM build lacks noteToHz \u2014 rebuild @vcad/kernel-wasm");
+        }
+        return kernel2.noteToHz(note);
+      }
       /** Return the kernel's curated sheet-metal materials registry. */
       getSheetMetalMaterials() {
         return getSheetMetalMaterials2(this.kernel);
@@ -26615,33 +26718,33 @@ var init_server = __esm({
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-function assertToolsCallTaskCapability(requests, method, entityName2) {
+function assertToolsCallTaskCapability(requests, method, entityName) {
   if (!requests) {
-    throw new Error(`${entityName2} does not support task creation (required for ${method})`);
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
   }
   switch (method) {
     case "tools/call":
       if (!requests.tools?.call) {
-        throw new Error(`${entityName2} does not support task creation for tools/call (required for ${method})`);
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
       }
       break;
     default:
       break;
   }
 }
-function assertClientRequestTaskCapability(requests, method, entityName2) {
+function assertClientRequestTaskCapability(requests, method, entityName) {
   if (!requests) {
-    throw new Error(`${entityName2} does not support task creation (required for ${method})`);
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
   }
   switch (method) {
     case "sampling/createMessage":
       if (!requests.sampling?.createMessage) {
-        throw new Error(`${entityName2} does not support task creation for sampling/createMessage (required for ${method})`);
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
       }
       break;
     case "elicitation/create":
       if (!requests.elicitation?.create) {
-        throw new Error(`${entityName2} does not support task creation for elicitation/create (required for ${method})`);
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
       }
       break;
     default:
@@ -40887,6 +40990,7 @@ var init_part_labels = __esm({
 var init_export_stl = __esm({
   "../core/dist/utils/export-stl.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -40894,6 +40998,7 @@ var init_export_stl = __esm({
 var init_export_gltf = __esm({
   "../core/dist/utils/export-gltf.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -40930,6 +41035,7 @@ var init_save_load = __esm({
 var init_document_to_loon = __esm({
   "../core/dist/utils/document-to-loon.js"() {
     "use strict";
+    init_wasm_singleton2();
   }
 });
 
@@ -49263,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;
@@ -49270,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) => ({
@@ -49640,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);
   }
 });
 
@@ -56448,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();
   }
 });
 
@@ -72670,335 +72439,6 @@ var init_sheet_metal2 = __esm({
 
 // src/tools/acoustics.ts
 import { writeFileSync as writeFileSync5 } from "node:fs";
-function freeFreeBetaL(count) {
-  const roots = [];
-  for (let n = 1; n <= count; n++) {
-    let x = (2 * n + 1) * Math.PI / 2;
-    for (let i = 0; i < 50; i++) {
-      const f = Math.cosh(x) * Math.cos(x) - 1;
-      const df = Math.sinh(x) * Math.cos(x) - Math.cosh(x) * Math.sin(x);
-      const step = f / df;
-      x -= step;
-      if (Math.abs(step) < 1e-13) break;
-    }
-    roots.push(x);
-  }
-  return roots;
-}
-function modeShape(betaL, xi) {
-  const sigma = (Math.cosh(betaL) - Math.cos(betaL)) / (Math.sinh(betaL) - Math.sin(betaL));
-  const raw = (t2) => Math.cosh(betaL * t2) + Math.cos(betaL * t2) - sigma * (Math.sinh(betaL * t2) + Math.sin(betaL * t2));
-  return raw(xi) / Math.abs(raw(0));
-}
-function closedFormHz(bar, count) {
-  const L = bar.length_mm / 1e3;
-  const t2 = bar.thickness_mm / 1e3;
-  const E = bar.modulus_gpa * 1e9;
-  const c = t2 * Math.sqrt(E / (12 * bar.density_kg_m3));
-  return freeFreeBetaL(count).map((bl) => bl * bl * c / (2 * Math.PI * L * L));
-}
-function effectiveWidthMm(bar, xMm) {
-  let w = bar.width_mm;
-  const r = bar.hole_dia_mm / 2;
-  for (const h of bar.holes_mm) {
-    const d = Math.abs(xMm - h);
-    if (d < r) w -= 2 * Math.sqrt(r * r - d * d);
-  }
-  return Math.max(w, 1e-6);
-}
-function femHz(bar, count, nel = 96) {
-  const L = bar.length_mm / 1e3;
-  const t2 = bar.thickness_mm / 1e3;
-  const E = bar.modulus_gpa * 1e9;
-  const rho = bar.density_kg_m3;
-  const nDof = 2 * (nel + 1);
-  const K = zeros(nDof, nDof);
-  const M = zeros(nDof, nDof);
-  const le = L / nel;
-  const gp = [-0.8611363115940526, -0.3399810435848563, 0.3399810435848563, 0.8611363115940526];
-  const gw = [0.3478548451374538, 0.6521451548625461, 0.6521451548625461, 0.3478548451374538];
-  for (let e = 0; e < nel; e++) {
-    const x0 = e * le;
-    const ke = zeros(4, 4);
-    const me = zeros(4, 4);
-    for (let g = 0; g < 4; g++) {
-      const xi = gp[g];
-      const x = x0 + (xi + 1) / 2 * le;
-      const wEff = effectiveWidthMm(bar, x * 1e3) / 1e3;
-      const A = wEff * t2;
-      const I = wEff * t2 * t2 * t2 / 12;
-      const s = le / 2;
-      const N = [
-        0.25 * (1 - xi) * (1 - xi) * (2 + xi),
-        s * 0.25 * (1 - xi) * (1 - xi) * (1 + xi),
-        0.25 * (1 + xi) * (1 + xi) * (2 - xi),
-        s * 0.25 * (1 + xi) * (1 + xi) * (xi - 1)
-      ];
-      const c2 = 2 / le * (2 / le);
-      const B = [
-        1.5 * xi * c2,
-        s * (1.5 * xi - 0.5) * c2,
-        -1.5 * xi * c2,
-        s * (1.5 * xi + 0.5) * c2
-      ];
-      const wJ = gw[g] * s;
-      for (let i = 0; i < 4; i++) {
-        for (let j = 0; j < 4; j++) {
-          ke[i][j] += E * I * B[i] * B[j] * wJ;
-          me[i][j] += rho * A * N[i] * N[j] * wJ;
-        }
-      }
-    }
-    const dof = [2 * e, 2 * e + 1, 2 * e + 2, 2 * e + 3];
-    for (let i = 0; i < 4; i++) {
-      for (let j = 0; j < 4; j++) {
-        K[dof[i]][dof[j]] += ke[i][j];
-        M[dof[i]][dof[j]] += me[i][j];
-      }
-    }
-  }
-  const Lc = cholesky(M);
-  const C = congruence(K, Lc);
-  const lambda = jacobiEigenvalues(C);
-  lambda.sort((a, b) => a - b);
-  const elastic = lambda.filter((l) => l > (2 * Math.PI) ** 2);
-  return elastic.slice(0, count).map((l) => Math.sqrt(l) / (2 * Math.PI));
-}
-function zeros(r, c) {
-  return Array.from({ length: r }, () => new Array(c).fill(0));
-}
-function cholesky(A) {
-  const n = A.length;
-  const L = zeros(n, n);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j <= i; j++) {
-      let s = A[i][j];
-      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
-      if (i === j) {
-        if (s <= 0) throw new Error("mass matrix not positive definite");
-        L[i][i] = Math.sqrt(s);
-      } else {
-        L[i][j] = s / L[j][j];
-      }
-    }
-  }
-  return L;
-}
-function congruence(K, L) {
-  const n = K.length;
-  const Y = zeros(n, n);
-  for (let c = 0; c < n; c++) {
-    for (let i = 0; i < n; i++) {
-      let s = K[i][c];
-      for (let k = 0; k < i; k++) s -= L[i][k] * Y[k][c];
-      Y[i][c] = s / L[i][i];
-    }
-  }
-  const C = zeros(n, n);
-  for (let r = 0; r < n; r++) {
-    for (let i = 0; i < n; i++) {
-      let s = Y[r][i];
-      for (let k = 0; k < i; k++) s -= L[i][k] * C[r][k];
-      C[r][i] = s / L[i][i];
-    }
-  }
-  for (let i = 0; i < n; i++)
-    for (let j = 0; j < i; j++) {
-      const v = 0.5 * (C[i][j] + C[j][i]);
-      C[i][j] = v;
-      C[j][i] = v;
-    }
-  return C;
-}
-function jacobiEigenvalues(A) {
-  const n = A.length;
-  const a = A.map((row) => row.slice());
-  for (let sweep = 0; sweep < 30; sweep++) {
-    let off = 0;
-    for (let i = 0; i < n; i++)
-      for (let j = i + 1; j < n; j++) off += a[i][j] * a[i][j];
-    if (off < 1e-18 * n * n) break;
-    for (let p = 0; p < n - 1; p++) {
-      for (let q = p + 1; q < n; q++) {
-        if (Math.abs(a[p][q]) < 1e-30) continue;
-        const theta = (a[q][q] - a[p][p]) / (2 * a[p][q]);
-        const t2 = Math.sign(theta) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
-        const c = 1 / Math.sqrt(t2 * t2 + 1);
-        const s = t2 * c;
-        for (let k = 0; k < n; k++) {
-          const akp = a[k][p];
-          const akq = a[k][q];
-          a[k][p] = c * akp - s * akq;
-          a[k][q] = s * akp + c * akq;
-        }
-        for (let k = 0; k < n; k++) {
-          const apk = a[p][k];
-          const aqk = a[q][k];
-          a[p][k] = c * apk - s * aqk;
-          a[q][k] = s * apk + c * aqk;
-        }
-      }
-    }
-  }
-  return a.map((row, i) => row[i]);
-}
-function malletSpectrum(hz, contactMs) {
-  const tc = contactMs / 1e3;
-  const u = 2 * hz * tc;
-  const denom = Math.abs(1 - u * u);
-  if (denom < 1e-9) return Math.PI / 4;
-  return Math.abs(Math.cos(Math.PI * hz * tc)) / denom;
-}
-function strikeModes(bar, femFreqs, strikeFrac, contactMs, materialQ = 2500, suspensionQ0 = 150) {
-  const betas = freeFreeBetaL(femFreqs.length);
-  const modes = femFreqs.map((hz, i) => {
-    const phiStrike = modeShape(betas[i], strikeFrac);
-    const gain = Math.abs(phiStrike) * malletSpectrum(hz, contactMs);
-    let phiSq = 0;
-    for (const h of bar.holes_mm) {
-      const phi = modeShape(betas[i], h / bar.length_mm);
-      phiSq += phi * phi;
-    }
-    const qSusp = suspensionQ0 / Math.max(phiSq, 1e-9);
-    const q = 1 / (1 / materialQ + 1 / qSusp);
-    return {
-      n: i + 1,
-      hz,
-      gain,
-      q,
-      t60_s: Math.log(1e3) * q / (Math.PI * hz)
-    };
-  });
-  const peak = Math.max(...modes.map((m) => m.gain), 1e-12);
-  for (const m of modes) m.gain /= peak;
-  return modes;
-}
-function synthesize(modes, durationS, sampleRate) {
-  const n = Math.floor(durationS * sampleRate);
-  const out = new Float64Array(n);
-  for (const m of modes) {
-    if (m.hz >= 0.45 * sampleRate) continue;
-    const w = 2 * Math.PI * m.hz / sampleRate;
-    const tau = m.q / (Math.PI * m.hz);
-    const decay = Math.exp(-1 / (tau * sampleRate));
-    let amp = m.gain;
-    for (let k = 0; k < n; k++) {
-      out[k] += amp * Math.sin(w * k);
-      amp *= decay;
-    }
-  }
-  let peak = 1e-12;
-  for (let k = 0; k < n; k++) peak = Math.max(peak, Math.abs(out[k]));
-  const norm = 0.891 / peak;
-  for (let k = 0; k < n; k++) out[k] *= norm;
-  return out;
-}
-function encodeWav(samples, sampleRate) {
-  const n = samples.length;
-  const buf = new ArrayBuffer(44 + n * 2);
-  const v = new DataView(buf);
-  const str2 = (off, s) => {
-    for (let i = 0; i < s.length; i++) v.setUint8(off + i, s.charCodeAt(i));
-  };
-  str2(0, "RIFF");
-  v.setUint32(4, 36 + n * 2, true);
-  str2(8, "WAVE");
-  str2(12, "fmt ");
-  v.setUint32(16, 16, true);
-  v.setUint16(20, 1, true);
-  v.setUint16(22, 1, true);
-  v.setUint32(24, sampleRate, true);
-  v.setUint32(28, sampleRate * 2, true);
-  v.setUint16(32, 2, true);
-  v.setUint16(34, 16, true);
-  str2(36, "data");
-  v.setUint32(40, n * 2, true);
-  for (let i = 0; i < n; i++) {
-    const s = Math.max(-1, Math.min(1, samples[i]));
-    v.setInt16(44 + i * 2, Math.round(s * 32767), true);
-  }
-  return new Uint8Array(buf);
-}
-function fft(re, im) {
-  const n = re.length;
-  for (let i = 1, j = 0; i < n; i++) {
-    let bit = n >> 1;
-    for (; j & bit; bit >>= 1) j ^= bit;
-    j ^= bit;
-    if (i < j) {
-      [re[i], re[j]] = [re[j], re[i]];
-      [im[i], im[j]] = [im[j], im[i]];
-    }
-  }
-  for (let len = 2; len <= n; len <<= 1) {
-    const ang = -2 * Math.PI / len;
-    const wr = Math.cos(ang);
-    const wi = Math.sin(ang);
-    for (let i = 0; i < n; i += len) {
-      let cr = 1;
-      let ci = 0;
-      for (let k = 0; k < len / 2; k++) {
-        const ur = re[i + k];
-        const ui = im[i + k];
-        const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
-        const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
-        re[i + k] = ur + vr;
-        im[i + k] = ui + vi;
-        re[i + k + len / 2] = ur - vr;
-        im[i + k + len / 2] = ui - vi;
-        const ncr = cr * wr - ci * wi;
-        ci = cr * wi + ci * wr;
-        cr = ncr;
-      }
-    }
-  }
-}
-function spectrumPeaks(samples, sampleRate, maxPeaks = 8) {
-  const n = Math.min(65536, 1 << Math.floor(Math.log2(samples.length)));
-  const re = new Float64Array(n);
-  const im = new Float64Array(n);
-  for (let i = 0; i < n; i++) {
-    const w = 0.5 * (1 - Math.cos(2 * Math.PI * i / (n - 1)));
-    re[i] = samples[i] * w;
-  }
-  fft(re, im);
-  const half = n / 2;
-  const mag = new Float64Array(half);
-  let maxMag = 1e-30;
-  for (let i = 0; i < half; i++) {
-    mag[i] = Math.hypot(re[i], im[i]);
-    maxMag = Math.max(maxMag, mag[i]);
-  }
-  const peaks = [];
-  const floorDb = -60;
-  for (let i = 2; i < half - 2; i++) {
-    if (mag[i] <= mag[i - 1] || mag[i] < mag[i + 1]) continue;
-    const db = 20 * Math.log10(mag[i] / maxMag);
-    if (db < floorDb) continue;
-    const a = Math.log(mag[i - 1] + 1e-30);
-    const b = Math.log(mag[i] + 1e-30);
-    const c = Math.log(mag[i + 1] + 1e-30);
-    const delta = 0.5 * (a - c) / (a - 2 * b + c || 1e-30);
-    peaks.push({ hz: (i + delta) * sampleRate / n, db });
-  }
-  peaks.sort((a, b) => b.db - a.db);
-  const kept = [];
-  for (const p of peaks) {
-    if (kept.every((k) => Math.abs(p.hz - k.hz) / k.hz > 0.03)) kept.push(p);
-    if (kept.length >= maxPeaks) break;
-  }
-  return kept.sort((a, b) => a.hz - b.hz);
-}
-function noteToHz(note) {
-  const m = /^([A-Ga-g])([#b]?)(-?\d)$/.exec(note.trim());
-  if (!m) throw new Error(`unparseable note ${JSON.stringify(note)} \u2014 use e.g. "C6", "F#4"`);
-  const base = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
-  let semis = base[m[1].toUpperCase()];
-  if (m[2] === "#") semis += 1;
-  if (m[2] === "b") semis -= 1;
-  const midi = (Number(m[3]) + 1) * 12 + semis;
-  return 440 * 2 ** ((midi - 69) / 12);
-}
 function lookupMaterial(engine, name) {
   const key = name.trim().toLowerCase().replace(/[_ ]/g, "-");
   const registry4 = engine.getSheetMetalMaterials();
@@ -73045,10 +72485,8 @@ function barFromDocument(engine, documentId) {
   let holeDia = 0;
   for (const loop of holeLoops) {
     const cs = loop.map((p) => axis === "x" ? p.x : p.y);
-    const os = loop.map((p) => axis === "x" ? p.y : p.x);
     holesMm.push((Math.min(...cs) + Math.max(...cs)) / 2);
     holeDia = Math.max(holeDia, Math.max(...cs) - Math.min(...cs));
-    void os;
   }
   return {
     bar: {
@@ -73095,28 +72533,26 @@ function simulateStrike(input, engine) {
   const durationS = Math.min(Math.max(Number(a.duration_s ?? 2.5), 0.5), 10);
   const strikeFrac = Math.min(Math.max(Number(a.strike_position ?? 0.5), 0.02), 0.98);
   const contactMs = Math.min(Math.max(Number(a.mallet_contact_ms ?? 0.5), 0.05), 10);
-  const nModes = 6;
-  const closed = closedFormHz(bar, nModes);
-  const fem = femHz(bar, nModes);
-  const modes = strikeModes(bar, fem, strikeFrac, contactMs);
-  const audible = modes.filter((m) => m.hz < 0.45 * sampleRate && m.gain > 1e-4);
-  const samples = synthesize(audible, durationS, sampleRate);
-  const peaks = spectrumPeaks(samples, sampleRate);
   let expected;
   if (typeof a.expect_hz === "number") expected = a.expect_hz;
-  else if (typeof a.note === "string") expected = noteToHz(a.note);
-  const toleranceCents = Number(a.tolerance_cents ?? 10);
-  const dominant = peaks.reduce(
-    (best, p) => p.db > best.db ? p : best,
-    { hz: 0, db: -Infinity }
-  );
-  const verdict = expected !== void 0 ? {
-    expected_hz: expected,
-    measured_hz: dominant.hz,
-    cents_error: cents(dominant.hz, expected),
-    tolerance_cents: toleranceCents,
-    pass: Math.abs(cents(dominant.hz, expected)) <= toleranceCents
-  } : void 0;
+  else if (typeof a.note === "string") expected = engine.noteToHz(a.note);
+  const wantWav = typeof a.wav_filename === "string" && a.wav_filename.length > 0;
+  if (wantWav && !/\.wav$/i.test(a.wav_filename)) {
+    throw new Error("wav_filename must end in .wav");
+  }
+  const result = engine.simulateStrike({
+    bar,
+    strike_position: strikeFrac,
+    mallet_contact_ms: contactMs,
+    duration_s: durationS,
+    sample_rate: sampleRate,
+    n_modes: 6,
+    expected_hz: expected ?? null,
+    tolerance_cents: Number(a.tolerance_cents ?? 10),
+    include_wav: wantWav
+  });
+  const closed = result.closed_form_hz;
+  const fem = result.fem_hz;
   const payload = {
     bar: { ...bar, material: mat.name, material_display: mat.display_name },
     physics: {
@@ -73133,22 +72569,19 @@ function simulateStrike(input, engine) {
       duration_s: durationS,
       sample_rate: sampleRate
     },
-    modes: audible.map((m) => ({
+    modes: result.modes.map((m) => ({
       n: m.n,
       hz: round24(m.hz),
       gain: round4(m.gain),
       q: Math.round(m.q),
       t60_s: round24(m.t60_s)
     })),
-    spectrum_peaks: peaks.map((p) => ({ hz: round24(p.hz), db: round24(p.db) })),
-    ...verdict ? { verdict } : {},
+    spectrum_peaks: result.spectrum_peaks.map((p) => ({ hz: round24(p.hz), db: round24(p.db) })),
+    ...result.verdict ? { verdict: result.verdict } : {},
     limits: "1-D transverse bending only (no torsional/lateral modes); decay Q is a heuristic (material + cord-at-holes), frequencies are not"
   };
-  if (typeof a.wav_filename === "string" && a.wav_filename.length > 0) {
-    if (!/\.wav$/i.test(a.wav_filename)) {
-      throw new Error("wav_filename must end in .wav");
-    }
-    const bytes = encodeWav(samples, sampleRate);
+  if (wantWav && result.wav_base64) {
+    const bytes = Buffer.from(result.wav_base64, "base64");
     if (isRemoteDeployment()) {
       const cap = maxInlineExportBytes();
       if (bytes.length > cap) {
@@ -73159,7 +72592,7 @@ function simulateStrike(input, engine) {
       payload.wav = {
         filename: a.wav_filename,
         bytes: bytes.length,
-        data_base64: Buffer.from(bytes).toString("base64")
+        data_base64: result.wav_base64
       };
     } else {
       const path = resolveWithinRoot(
@@ -78325,8 +77758,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.11") {
-        return "0.9.4-main.11";
+      if ("0.9.4-main.14") {
+        return "0.9.4-main.14";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -78335,8 +77768,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "681857ca2f62f173237de79ff2621cd1609480a7";
-    BUILD_TIME = "2026-07-24T16:25:54.297Z";
+    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);