partforge 0.146.0 → 0.146.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.146.0",
+  "version": "0.146.2",
   "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/kernel-front.js

@@ -21,6 +21,7 @@ import { KernelCapabilityError } from "./errors.js";
 import { isPlainOptions, KERNEL_OP_SPECS } from "./op-options.js";
 import { isPathContour, contourToPoints } from "./profile.js";
 import { textGlyphs } from "./text2d.js";
+import { unionMany } from "./union-many.js";
 import { placeRegions } from "./vector2d.js";
 import { beveledExtrude } from "./rim-bevel.js";
 import { DEFAULT_FONT_BYTES } from "./fonts/default-font.js";
@@ -279,7 +280,7 @@ export function finishKernel(k) {
     if (regions.length === 0) throw new Error("text2d: string produced no glyph geometry (empty or all-whitespace?)");
     // Glyph regions are machine-resolved by curve-fill — trusted, so a text
     // part does not pay profile validation per glyph per rebuild.
-    return regions.map((r) => k.shape2d.trusted(r)).reduce((a, b) => a.union(b));
+    return unionMany(regions.map((r) => k.shape2d.trusted(r)), k.shape2d.trusted);
   };
 
   // 2-D vector art as a Shape2D. Backend-agnostic for the same reason text2d is:
@@ -300,7 +301,7 @@ export function finishKernel(k) {
     if (!doc) throw new Error(`vector2d: unknown vector "${name}" — declare it in the part's \`vectors\` field`);
     // vector documents carry their own validation (VECTOR-FORMAT.md); trusted lift
     const lift = (regions, measureAgainst = regions) =>
-      placeRegions(regions, doc.units, opts, { measureAgainst, name }).map((r) => k.shape2d.trusted(r)).reduce((a, b) => a.union(b));
+      unionMany(placeRegions(regions, doc.units, opts, { measureAgainst, name }).map((r) => k.shape2d.trusted(r)), k.shape2d.trusted);
     if (opts.shape != null) {
       const entry = doc.shapes.get(opts.shape);
       if (!entry) {

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) };
 }

package/src/framework/geometry/union-many.js

@@ -0,0 +1,75 @@
+// Union of many Shape2Ds — the text2d / vector2d reduction — without the
+// quadratic left fold those ops used to run.
+//
+// `shapes.reduce((a, b) => a.union(b))` hands paper.js the WHOLE accumulated
+// result on every step, so n glyphs cost about n²/2 glyph conversions plus n
+// planar booleans over an ever-growing compound path. Measured on a 4-line,
+// 290-glyph paragraph (feedback #169, a bathroom sign): 14 s for text2d alone,
+// over a minute for the forge. Two independent savings, applied in order:
+//
+//   1. Shapes whose bounding boxes do not touch cannot share a point, so their
+//      union is just their regions side by side — no boolean at all. Text is
+//      almost entirely this case: letters sit apart, and only a kerned pair, a
+//      script face or negative tracking makes neighbours overlap. Shapes are
+//      grouped into clusters whose boxes overlap (transitively); the clusters
+//      are mutually disjoint, so concatenating them IS the union.
+//   2. Inside a cluster that does need booleans, the union is balanced
+//      (pairs, then pairs of pairs), so each shape is converted O(log n)
+//      times instead of O(n).
+//
+// Bounds are paper's exact curve bounds (Shape2D.boundingBox), padded by EPS so
+// shapes that merely touch along an edge still meet a boolean — touching
+// glyphs must fuse, not sit as two regions sharing an edge.
+//
+// Deterministic: clusters are emitted in the order of their first member, and
+// members keep input order, so the same inputs give the same regions (and so
+// the same Shape2D hash — build purity rests on it).
+const EPS = 1e-6;
+
+// `fromContours` builds a Shape2D from a list of already-resolved regions (the
+// kernel's k.shape2d.trusted) — passed in so this module needs no kernel.
+export function unionMany(shapes, fromContours) {
+  if (shapes.length === 0) throw new Error("unionMany: no shapes");
+  if (shapes.length === 1) return shapes[0];
+
+  const boxes = shapes.map((s) => s.boundingBox());
+  const n = shapes.length;
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const find = (i) => { while (parent[i] !== i) { parent[i] = parent[parent[i]]; i = parent[i]; } return i; };
+  const join = (a, b) => { const ra = find(a), rb = find(b); if (ra !== rb) parent[Math.max(ra, rb)] = Math.min(ra, rb); };
+
+  // Sweep in x: `active` holds every box whose x-range can still reach the
+  // current one. Worst case (a vertical column of shapes) is O(n²) box checks —
+  // cheap arithmetic, nothing like the booleans it saves.
+  const order = [...boxes.keys()].sort((a, b) => boxes[a].min[0] - boxes[b].min[0] || a - b);
+  let active = [];
+  for (const i of order) {
+    const bi = boxes[i];
+    active = active.filter((j) => boxes[j].max[0] + EPS >= bi.min[0]);
+    for (const j of active) {
+      const bj = boxes[j];
+      if (bj.min[1] - EPS <= bi.max[1] && bi.min[1] - EPS <= bj.max[1]) join(i, j);
+    }
+    active.push(i);
+  }
+
+  const clusters = new Map();                       // root → member indices, input order
+  for (let i = 0; i < n; i++) {
+    const r = find(i);
+    if (!clusters.has(r)) clusters.set(r, []);
+    clusters.get(r).push(i);
+  }
+
+  const merged = [...clusters.values()].map((members) => balancedUnion(members.map((i) => shapes[i])));
+  if (merged.length === 1) return merged[0];
+  return fromContours(merged.flatMap((s) => s.toContours()));
+}
+
+function balancedUnion(xs) {
+  while (xs.length > 1) {
+    const next = [];
+    for (let i = 0; i < xs.length; i += 2) next.push(i + 1 < xs.length ? xs[i].union(xs[i + 1]) : xs[i]);
+    xs = next;
+  }
+  return xs[0];
+}