partforge 0.146.0 → 0.146.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.146.0",
+  "version": "0.146.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/geometry/threemf-parse.js

@@ -1,87 +1,175 @@
 // Minimal 3MF reader, the read twin of threemf.js's writer. 3MF is an OPC
-// package (a zip) holding an XML model; unzip (fflate), find the model part,
-// extract vertices/triangles/per-item transforms and the model unit, and
-// merge every build item into one soup-free indexed mesh in millimetres.
+// package (a zip) holding one or more XML model parts; unzip (fflate), find the
+// ROOT model part, extract vertices/triangles, resolve <components> and per-item
+// transforms, and merge every build item into one soup-free indexed mesh in
+// millimetres.
+//
+// Slicer project files (Bambu Studio, Orca, PrusaSlicer) keep no mesh in the
+// root part at all: its objects are <components> pointing, through the
+// Production extension's `p:path`, at meshes in other parts
+// (3D/Objects/object_1.model). Reading only one part — or only top-level
+// <object><mesh> — finds nothing in exactly the files people export most.
 //
 // Regex-based extraction, NOT a DOM parse — workers have no DOMParser and the
 // worker graph must stay DOM-free (test/worker-layering.test.js enforces
 // this transitively). Scope: geometry only — materials, colors and beam
-// lattices are ignored, and only top-level <object><mesh> content is read
-// (no <components> nesting).
+// lattices are ignored.
 import { unzipSync } from "fflate";
 
 const UNIT_MM = { micron: 0.001, millimeter: 1, centimeter: 10, inch: 25.4, foot: 304.8, meter: 1000 };
+const MAX_COMPONENT_DEPTH = 32;
+const IDENTITY = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
 
-export function parse3MF(bytes) {
-  const u8 = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
-  let files;
-  try {
-    files = unzipSync(u8);
-  } catch (e) {
-    throw new Error(`3mf import: not a readable zip archive (${e?.message || e})`);
+// Part names are compared without a leading slash and case-insensitively: OPC
+// names are case-insensitive, and references carry a leading "/" that zip
+// entry names do not.
+const partKey = (name) => name.replace(/^\/+/, "").toLowerCase();
+
+// Transforms are 12 numbers, row-major 4x3 with the translation in the last
+// row, per the 3MF core spec (applied to a row vector: v' = v*M, i.e.
+// x' = x*m00 + y*m10 + z*m20 + m30). The translation is in the units of the
+// part that holds the transform, so it is scaled to mm on read; the linear
+// part is unitless.
+function readTransform(tag, scale) {
+  const raw = tag.match(/\btransform="([^"]+)"/)?.[1];
+  if (!raw) return IDENTITY;
+  const t = raw.trim().split(/\s+/).map(Number);
+  if (t.length !== 12 || t.some((n) => !Number.isFinite(n))) return IDENTITY;
+  return [...t.slice(0, 9), t[9] * scale, t[10] * scale, t[11] * scale];
+}
+
+// Child first, then parent: v * C * P.
+function compose(c, p) {
+  const r = new Array(12);
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 3; col++) {
+      r[row * 3 + col] =
+        c[row * 3] * p[col] + c[row * 3 + 1] * p[3 + col] + c[row * 3 + 2] * p[6 + col] + (row === 3 ? p[9 + col] : 0);
+    }
   }
-  const modelPath = Object.keys(files).find((f) => f.toLowerCase().endsWith(".model"));
-  if (!modelPath) throw new Error("3mf import: archive has no 3D model part (*.model)");
-  const xml = new TextDecoder().decode(files[modelPath]);
+  return r;
+}
+
+// The OPC/Production-extension `path` attribute, whatever its namespace prefix.
+const readPath = (tag) => tag.match(/\s(?:[\w.-]+:)?path="([^"]+)"/)?.[1] ?? null;
+
+function rootModelPath(files, keys) {
+  const rels = files.get("_rels/.rels");
+  if (rels) {
+    const xml = new TextDecoder().decode(rels);
+    for (const m of xml.matchAll(/<Relationship\b[^>]*>/g)) {
+      const type = m[0].match(/\bType="([^"]+)"/)?.[1] ?? "";
+      const target = m[0].match(/\bTarget="([^"]+)"/)?.[1];
+      if (target && /\/3dmodel$/i.test(type) && files.has(partKey(target))) return partKey(target);
+    }
+  }
+  if (files.has("3d/3dmodel.model")) return "3d/3dmodel.model";
+  return keys.find((k) => k.endsWith(".model")) ?? null;
+}
 
+function parseModelPart(xml, key) {
   const unit = xml.match(/<model\b[^>]*\bunit="([^"]+)"/)?.[1] ?? "millimeter";
   const scale = UNIT_MM[unit];
   if (!scale) throw new Error(`3mf import: unknown unit "${unit}"`);
 
-  // objects: id -> { P: number[] (already scaled to mm), I: number[] }
+  // objects: id -> { type, mesh: {P (mm), I} | null, components: [{key, id, t}] }
   const objects = new Map();
-  const objRe = /<object\b[^>]*\bid="(\d+)"[^>]*>([\s\S]*?)<\/object>/g;
+  const objRe = /<object\b([^>]*)>([\s\S]*?)<\/object>/g;
   for (let m; (m = objRe.exec(xml)); ) {
-    const [, id, body] = m;
+    const [, attrs, body] = m;
+    const id = attrs.match(/\bid="(\d+)"/)?.[1];
+    if (!id) continue;
+    const type = attrs.match(/\btype="([^"]+)"/)?.[1] ?? "model";
     const P = [], I = [];
     const vRe = /<vertex\b[^>]*\bx="([^"]+)"[^>]*\by="([^"]+)"[^>]*\bz="([^"]+)"/g;
     for (let v; (v = vRe.exec(body)); ) P.push(+v[1] * scale, +v[2] * scale, +v[3] * scale);
     const tRe = /<triangle\b[^>]*\bv1="(\d+)"[^>]*\bv2="(\d+)"[^>]*\bv3="(\d+)"/g;
     for (let t; (t = tRe.exec(body)); ) I.push(+t[1], +t[2], +t[3]);
-    if (I.length) objects.set(id, { P, I });
+    const components = [];
+    for (const c of body.matchAll(/<component\b[^>]*>/g)) {
+      const cid = c[0].match(/\bobjectid="(\d+)"/)?.[1];
+      if (!cid) continue;
+      const path = readPath(c[0]);
+      components.push({ key: path ? partKey(path) : key, id: cid, t: readTransform(c[0], scale) });
+    }
+    objects.set(id, { type, mesh: I.length ? { P, I } : null, components });
   }
-  if (objects.size === 0) throw new Error("3mf import: model contains no mesh geometry");
 
-  // Build items: <item objectid="N" transform="m00 m01 m02 m10 m11 m12 m20 m21
-  // m22 m30 m31 m32"/> — row-major 4x3, translation in the last row, per the
-  // 3MF core spec (the transform is applied to a row vector: v' = v*M, i.e.
-  // x' = x*m00 + y*m10 + z*m20 + m30, and so on). No <build>, or an object
-  // with no matching item, falls back to identity placement.
-  //
-  // Attributes are pulled independently from each <item> tag (rather than in
-  // one fixed-order regex) because `objectid` and `transform` can appear in
-  // either order and a single ordered pattern with an optional middle group
-  // can match the tag while silently leaving `transform` uncaptured.
+  // Build items. Attributes are pulled independently from each <item> tag
+  // (rather than in one fixed-order regex) because `objectid` and `transform`
+  // can appear in either order and a single ordered pattern with an optional
+  // middle group can match the tag while silently leaving `transform`
+  // uncaptured. Items may be self-closing or carry children (metadata).
   const items = [];
-  const itemTagRe = /<item\b[^>]*\/>/g;
-  for (let m; (m = itemTagRe.exec(xml)); ) {
-    const tag = m[0];
-    const id = tag.match(/\bobjectid="(\d+)"/)?.[1];
+  const build = xml.match(/<build\b[^>]*>([\s\S]*?)<\/build>/)?.[1] ?? "";
+  for (const m of build.matchAll(/<item\b[^>]*>/g)) {
+    const id = m[0].match(/\bobjectid="(\d+)"/)?.[1];
     if (!id) continue;
-    const t = tag.match(/\btransform="([^"]+)"/)?.[1];
-    items.push({ id, t: t ? t.trim().split(/\s+/).map(Number) : null });
+    const path = readPath(m[0]);
+    items.push({ key: path ? partKey(path) : key, id, t: readTransform(m[0], scale) });
+  }
+  return { objects, items };
+}
+
+export function parse3MF(bytes) {
+  const u8 = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
+  let raw;
+  try {
+    raw = unzipSync(u8);
+  } catch (e) {
+    throw new Error(`3mf import: not a readable zip archive (${e?.message || e})`, { cause: e });
   }
-  const chosen = items.length ? items : [...objects.keys()].map((id) => ({ id, t: null }));
+  const files = new Map(Object.entries(raw).map(([name, data]) => [partKey(name), data]));
+  const root = rootModelPath(files, [...files.keys()]);
+  if (!root) throw new Error("3mf import: archive has no 3D model part (*.model)");
+
+  const parts = new Map();
+  const partFor = (key) => {
+    if (!parts.has(key)) {
+      const data = files.get(key);
+      if (!data) throw new Error(`3mf import: a component references a missing model part (/${key})`);
+      parts.set(key, parseModelPart(new TextDecoder().decode(data), key));
+    }
+    return parts.get(key);
+  };
 
   const V = [], Tr = [];
-  for (const { id, t } of chosen) {
-    const o = objects.get(id);
-    if (!o) continue;
+  const emit = ({ P, I }, t) => {
     const base = V.length / 3;
-    for (let i = 0; i < o.P.length; i += 3) {
-      let x = o.P[i], y = o.P[i + 1], z = o.P[i + 2];
-      if (t) {
-        // Translation components (m30 m31 m32) are expressed in model units
-        // per the 3MF spec, same as vertex coordinates — scale them to mm too
-        // so they combine correctly with the already-scaled x/y/z above.
-        const x2 = t[0] * x + t[3] * y + t[6] * z + t[9] * scale;
-        const y2 = t[1] * x + t[4] * y + t[7] * z + t[10] * scale;
-        const z2 = t[2] * x + t[5] * y + t[8] * z + t[11] * scale;
-        x = x2; y = y2; z = z2;
-      }
-      V.push(x, y, z);
+    for (let i = 0; i < P.length; i += 3) {
+      const x = P[i], y = P[i + 1], z = P[i + 2];
+      V.push(
+        t[0] * x + t[3] * y + t[6] * z + t[9],
+        t[1] * x + t[4] * y + t[7] * z + t[10],
+        t[2] * x + t[5] * y + t[8] * z + t[11],
+      );
     }
-    for (const idx of o.I) Tr.push(base + idx);
+    for (const idx of I) Tr.push(base + idx);
+  };
+  const place = (key, id, t, stack) => {
+    const ref = `${key}#${id}`;
+    if (stack.includes(ref) || stack.length > MAX_COMPONENT_DEPTH) {
+      throw new Error("3mf import: components reference each other in a loop");
+    }
+    const o = partFor(key).objects.get(id);
+    if (!o) return;
+    // Support and "other" objects are not part of the printed shape.
+    if (o.type === "support" || o.type === "other") return;
+    if (o.mesh) emit(o.mesh, t);
+    for (const c of o.components) place(c.key, c.id, compose(c.t, t), [...stack, ref]);
+  };
+
+  // No <build> items: every object in the root part that no component uses,
+  // at identity.
+  const rootPart = partFor(root);
+  let items = rootPart.items;
+  if (!items.length) {
+    const used = new Set();
+    for (const o of rootPart.objects.values()) for (const c of o.components) if (c.key === root) used.add(c.id);
+    items = [...rootPart.objects.keys()].filter((id) => !used.has(id)).map((id) => ({ key: root, id, t: IDENTITY }));
   }
+  for (const { key, id, t } of items) place(key, id, t, []);
+
+  if (Tr.length === 0) throw new Error("3mf import: model contains no mesh geometry");
   return { positions: Float32Array.from(V), indices: Uint32Array.from(Tr) };
 }