partforge 0.164.1 → 0.165.1

package/docs/AUTHORING-PARTS.md

@@ -1776,7 +1776,7 @@ const wall  = k.shape2d(outer).offset(-2, { corners: "sharp" });  // inset, mite
 
 (This achieves the same geometry as building the profiles separately and using `k.extrude({ profile: { outer, holes }, h })`, but the Shape2D path is more idiomatic for complex 2-D operations.)
 
-`Shape2D.offset(delta, { corners: "round" | "chamfer" | "sharp" })` grows (`delta>0`) or insets (`delta<0`) a shape. It runs backend-independently on the shared contour engine — lines and arcs offset exactly (arcs stay arcs), so results are backend-identical by construction, like every other `Shape2D` op; it throws if the offset collapses the shape. A region with holes offsets material-wise: the outer grows/shrinks by `delta`, holes by `-delta`, so a positive `delta` always adds material. (For `derive()`/main-thread clearance math on plain point lists, use the pure `offsetPolygon` helper instead.)
+`Shape2D.offset(delta, { corners: "round" | "chamfer" | "sharp" })` grows (`delta>0`) or insets (`delta<0`) a shape. It runs backend-independently on the shared contour engine — lines and arcs offset exactly (arcs stay arcs), so results are backend-identical by construction, like every other `Shape2D` op; it throws if the offset collapses the shape. A region with holes offsets material-wise: the outer grows/shrinks by `delta`, holes by `-delta`, so a positive `delta` always adds material. (For `derive()`/main-thread clearance math on plain point lists, use the pure `offsetPolygon` helper instead.) The 3-D counterpart is `Solid.offset(d)` — a ball offset of a whole solid (see [`offset(d)`](#offsetd--grow-or-shrink-a-solid)).
 
 ## Editing profiles
 
@@ -4768,6 +4768,7 @@ at runtime — no declaration needed either way:
 | `s.fillet(radius)` · `s.fillet({ r, edges? })` | round edges (curve-following, exact); the bare-number scalar shorthand fillets **all** edges, the options form adds a selector |
 | `s.chamfer(distance)` · `s.chamfer({ d, edges? })` | bevel edges; same scalar-shorthand-or-options-with-selector shape as `fillet` |
 | `s.shell({ t, open })` | hollow inward, wall = `t`; `open` selector (`{inPlane,at}`/`{dir}`/`{near}`) chooses which face(s) to open. Closed (no-open-face) hollows are not supported. |
+| `s.offset(d)` · `s.offset({ d })` | grow (`d > 0`) or shrink (`d < 0`) the whole solid by `d` — a 3-D ball offset on both backends, imported meshes included; no OCCT routing. A closed constant-thickness skin is `body.cut(body.offset(-t))`. See [`offset(d)`](#offsetd--grow-or-shrink-a-solid) below. |
 
 `edges` (fillet/chamfer) / `open` (shell) chooses which edges/faces (omit `edges` for **all** edges — `shell` always requires `open`):
 
@@ -4887,6 +4888,50 @@ Rules of thumb:
 - A small ridge remaining where a thin rib was consumed is correct morphology
   (the rib's dilation fillet survives the opening), not a bug.
 
+### `offset(d)` — grow or shrink a solid
+
+`s.offset(2)` (or `s.offset({ d: 2 })`) grows the solid by 2 mm in every
+direction; `s.offset(-2)` shrinks it by 2 mm. Every point of the new surface is
+`|d|` from the old one — it is a true ball offset, the 3-D counterpart of
+`Shape2D.offset` — so it works on any solid, including an imported STL/3MF mesh,
+and it runs on both backends without routing. `offset(0)` is the identity.
+
+Its main use is a skin of constant thickness `t`, which `shell` cannot make for
+a closed body or an imported mesh:
+
+```js
+const helmet = k.import("helmet");
+const skin = helmet.cut(helmet.offset(-2));         // 2 mm thick everywhere, inside the helmet
+const cage = helmet.offset(1.5).cut(helmet);        // 1.5 mm thick everywhere, outside it
+```
+
+Do not build a skin from axis-shifted copies (`translate` by `±t` and union):
+that is six booleans, and the wall comes out only `t/√2` to `t/√3` thick on
+diagonal surfaces. `offset` is one op and holds `t` in every direction.
+
+**Corners.** A ball offset rounds what it moves away from: on a grow, convex
+edges and corners become arcs of radius `d` (a box grows into a rounded box);
+on a shrink, concave edges become arcs of radius `|d|` and convex corners stay
+sharp (a box shrinks into a smaller sharp box). Flat faces stay flat and move
+`|d|` along their normal. For sharp grown corners, offset the 2-D profile
+(`Shape2D.offset(d, { corners: "sharp" })`) and extrude it instead.
+
+**Thin features.** A shrink deeper than half a wall removes that wall, and a
+shrink past half the solid's thickness leaves nothing (an empty solid on
+Manifold). On OCCT (STEP export, or a sub-part that a `shell` routes there) a
+B-rep offset cannot change topology, so an offset it cannot build **throws**
+`offset-failed` — it never returns the un-offset solid, because a skin cut from
+that would be empty. See `docs/ERROR-PATTERNS.md`.
+
+**Cost note.** The mesh backend computes the offset as a Minkowski sum (grow)
+or difference (shrink) with a ball. On a non-convex solid each input triangle
+is hulled with the ball, so time grows with the triangle count — about 3 ms per
+triangle on a desktop (a 576-triangle dome ≈ 2 s, 8,448 triangles ≈ 23 s). An
+imported scan of 100k triangles is minutes. Decimate a dense import before you
+offset it, and offset once and reuse the result rather than offsetting inside a
+loop. The ball's own tessellation follows the quality tier (preview is coarser,
+so the wall can run up to ~0.1 mm under `t` on a diagonal; print is tighter).
+
 ### Cost on the OCCT path: fillet/chamfer scale with edge count — and order matters
 
 These costs apply when a sub-part **does** run on OCCT (a shell, an unsupported edge

package/docs/ERROR-PATTERNS.md

@@ -132,6 +132,24 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** the B-rep backend implements `roundAll` as a triple OCCT offset, which cannot change topology: a radius at or above the smallest local feature (thin wall < 2r, hole < 2r) has no valid B-rep offset result, so the op skips whole rather than emit garbage (KERNEL-CONTRACT.md, `roundAll` row). The mesh backend meanwhile performs true consumption — so preview and STEP legitimately differ in this regime.
 - **Fix:** reduce `r` below half the smallest wall/hole radius if STEP fidelity matters; or accept the divergence (preview/STL are correct) and gate the part with a `verify` volume assertion so the behavior is intentional.
 
+## offset-failed
+
+- **Symptom:** the build throws `offset-failed: offset(<d>) produced no valid solid on the OCCT backend — …` (STEP export, or a sub-part a `shell` routes to OCCT).
+- **Cause:** the B-rep backend implements `Solid.offset` as one OCCT offset, which cannot change topology: a shrink at or past half the thinnest wall (or a grow that would close a gap or hole narrower than `2d`) has no valid B-rep result. Unlike `roundAll`, `offset` never skips — returning the un-offset solid would make `body.cut(body.offset(-t))` empty without any sign of a problem — so it throws.
+- **Fix:** keep `|d|` below half the smallest wall/gap; or run the sub-part on Manifold (`meta.backend: "manifold"`, or drop the `shell` that routes it), whose Minkowski offset consumes thin features correctly. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "`offset(d)` — grow or shrink a solid".
+
+## offset-slow
+
+- **Symptom:** a build that calls `Solid.offset` takes many seconds or minutes, most often on an imported STL/3MF.
+- **Cause:** the Manifold backend's offset is a Minkowski sum/difference with a ball; on a non-convex solid every input triangle is hulled with the ball, about 3 ms per triangle (8,448 triangles ≈ 23 s; a 100k-triangle scan is minutes).
+- **Fix:** decimate the mesh before you import it, offset once and reuse the result, and do not offset inside a loop. Where the solid is an extrusion, offset the 2-D profile (`Shape2D.offset`) and extrude it instead — that is near-instant.
+
+## solid-offset-not-a-function
+
+- **Symptom:** `TypeError: <name>.offset is not a function` on a Solid (an extruded, imported or boolean result).
+- **Cause:** partforge before 0.165 had `offset` only on `Shape2D`; `Solid.offset` was added in 0.165.0.
+- **Fix:** update partforge to 0.165.0 or later. Do not fall back to unioning axis-shifted copies of the solid — that makes a wall only `t/√3` thick on diagonal surfaces.
+
 ## boolean-not-watertight
 
 - **Symptom:** `NOT watertight ✗` from `partforge measure` (non-zero exit) after adding a boolean cut or union.

package/docs/KERNEL-CONTRACT.md

@@ -80,6 +80,15 @@ Its coverage and tolerance band are part of the contract:
   labels upstream of the call do not survive through it (attribution uses the
   fallback path), and the result shades with the default SMOOTH policy.
 
+`offset` is required on every class too and is **parity-tolerant** while the
+offset does not change topology (a shrink less than half the thinnest wall, a
+grow that closes no gap): the mesh class computes it with one Minkowski pass
+(roundAll's sphere tessellation rule, sized from `|d|`) and a B-rep class with
+one native offset (`BRepOffsetAPI_MakeOffsetShape`, arc join). Past that, the
+mesh class changes topology correctly and a B-rep class throws `offset-failed`
+— unlike `roundAll`, skipping is NOT a permitted degrade, because the un-offset
+solid is a wrong answer rather than a missing feature.
+
 `roundAll` is required on **every** class (it is in `SOLID_OPS`, not
 `OCCT_ONLY_OPS`) and is **parity-tolerant with a regime split**: while `r` is
 strictly below the solid's smallest feature size (min wall, min hole
@@ -97,13 +106,17 @@ relying on consumption should gate it with a `verify` volume assertion.
 **B-rep class.** Core plus native `fillet`/`chamfer`/`shell` and `toSTEP`. The in-repo
 OCCT/replicad backend is the reference.
 
-**Optional ops.** `KERNEL_OPTIONAL_OPS` (`beginSubPart`/`endSubPart`/`sweepCache`/
+**Optional ops.** `KERNEL_OPTIONAL_OPS` (`beginSubPart`/`endSubPart`/`sweepCache`/`dropCache`/
 `cacheStats`/`resetCacheStats`/`cleanup`) and `SOLID_OPTIONAL_OPS` (`genus`/`isEmpty`) may
 be omitted entirely; callers in the framework guard with `?.`/`typeof`. A host that omits
 them loses sub-part caching and mesh-topology gates (`holes`, emptiness), nothing else.
 `sweepCache()` is the cache's rebind hygiene hook: called once when a worker is rebound to
 a part (never inside a `beginSubPart`/`endSubPart` bracket), it drops cache partitions that
-have gone unbuilt for three consecutive rebinds.
+have gone unbuilt for three consecutive rebinds. `dropCache()` drops every partition at
+once, under the same never-mid-bracket rule: the worker calls it on each booted kernel
+before an export job, because a display build's retained solids and the export's own
+build share one WASM heap, and on a very large part the cache alone can leave too little
+heap for the export. The next display build after an export is cold.
 
 `beginSubPart`/`endSubPart` brackets MAY nest: only the outermost pair opens and
 commits a round, and an inner pair is a balanced no-op. Nesting is real rather than
@@ -379,6 +392,7 @@ Normative signatures: `kernel.js`'s `@typedef Solid`.
 | `toIndexedMesh({quality?})` | `{positions, indices}` indexed mesh (3MF path); defaults to `"print"` like `toSTL`. Coincident vertices need NOT be welded — the 3MF writer welds, because that format reads topology from the indices rather than re-stitching soup by position the way an STL consumer does. |
 | `fillet(r)` · `fillet({r, edges?})` / `chamfer(d)` · `chamfer({d, edges?})` / `shell({t, open})` | `fillet`/`chamfer`: implemented on BOTH in-repo classes since v3 — exactly on B-rep, tolerance-band on the mesh class for straight, circular-arc, planar-rim and curved-face edge chains (see [Conformance classes](#conformance-classes)); an edge class the mesh kernel cannot blend throws `KernelCapabilityError` and reroutes. Zero magnitude — `fillet(0)` / `chamfer({d: 0})` — is the identity on every class (returns the solid unchanged, never throws; `shell` excluded, `t: 0` is degenerate). Scalar `fillet(3)`/`chamfer(1)` acts on all edges; the options form adds an `edges` selector. `shell` remains B-rep-only (core throws), hollows inward keeping outer dimensions; `open` (face selector) is required. |
 | `roundAll(r)` · `roundAll({r})` | Morphological close-then-open with a ball of radius `r`: rounds EVERY edge (convex and concave) at radius ≈ `r`; faces stay in place (within the class's tolerance band — the B-rep offset chain can drift ~0.1 mm); features smaller than the ball are consumed (walls < 2r melt, holes < 2r seal). Implemented natively on BOTH classes — never routes, never throws `KernelCapabilityError`. Parity-tolerant only while `r` is below the smallest feature size; at consuming radii the mesh class performs true consumption and a B-rep class MAY skip the whole op unchanged with a `roundall-skipped` warning (skip is the only permitted degrade). `roundAll(0)` is the identity on every class. |
+| `offset(d)` · `offset({d})` | 3-D ball offset — the solid counterpart of `Shape2D.offset`: `d > 0` grows the solid by `d` (Minkowski sum with a ball), `d < 0` shrinks it by `\|d\|` (Minkowski difference). Every point of the result's surface is `\|d\|` from the input's, within the class's tolerance band (the mesh class's faceted ball sits up to its sagitta inside the true ball, so diagonal faces land slightly short of `\|d\|`). Corners: a grow rounds convex edges/corners at radius `d` and keeps concave ones sharp; a shrink rounds concave edges at `\|d\|` and keeps convex ones sharp. Implemented natively on BOTH classes — never routes, never throws `KernelCapabilityError`; works on imported meshes on the mesh class. A shrink past the solid's half-thickness yields an empty solid on the mesh class. A B-rep class MUST NOT return the input unchanged on failure (a skin `body.cut(body.offset(-t))` would silently come out empty): it throws an error whose message starts `offset-failed:`. `offset(0)` is the identity on every class. Additive in 0.165 with no contract bump (the `loftSmooth` precedent). |
 
 `quality` (`"preview"` | `"print"`) is **advisory**: it trades tessellation density for
 speed and a backend may bake it at kernel creation (Manifold does). A part must never
@@ -942,6 +956,12 @@ in `kernel.js` define the current surface; only breaking changes bump the versio
   `cut` per CadQuery/replicad rather than OpenSCAD's `difference`), so LLM priors
   transfer. Renames are breaking changes with no offsetting benefit — don't.
 
+**Additive within v4** (partforge 0.165): `Solid.offset` joins `SOLID_OPS` — a 3-D
+ball offset (`d > 0` grows, `d < 0` shrinks), on both in-repo classes. No contract
+bump, following the `loftSmooth`/`heightfield` precedent for an op both in-repo
+backends implement; a third-party core kernel must add it to stay conforming
+(Manifold's `minkowskiSum`/`minkowskiDifference` with a sphere is the reference).
+
 **v3 → v4** (partforge 0.63): `Solid.roundAll` is added to `SOLID_OPS` (portable
 morphological rounding — rounds every edge with a ball of radius `r`;
 parity-tolerant, regime-split semantics, see

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.164.1",
+  "version": "0.165.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/export/bed-layout.js

@@ -47,16 +47,26 @@ export function bedWidthFor(part) {
   }
 }
 
-// `pieces`: [{ name, solid, ...rest }] in export order. Map-form pieces are laid out
-// together; legacy ones keep their export pose, and so do sheet pieces — a sheet's pose IS
-// its placement, so sheet exports come out assembled. Returns a new array, same order.
+// Map-form pieces are laid out together; legacy ones keep their export pose, and so do
+// sheet pieces — a sheet's pose IS its placement, so sheet exports come out assembled.
+export function laidOutOnBed(part, name) {
+  const sp = part.parts[name];
+  return formOf(sp) === "map" && !isSheetPart(sp);
+}
+
+// `boxes`: [{ name, box }] for the laid-out pieces, in export order → Map(name → offset).
+// Bounds alone are enough, which is what lets the 3MF export free each piece as soon as
+// it is meshed and shift the mesh afterwards (feedback #212).
+export function exportLayoutOffsets(part, boxes) {
+  if (boxes.length === 0) return new Map();
+  return bedLayout(boxes.map(({ name, box }) => ({ key: name, ...box })), { width: bedWidthFor(part) });
+}
+
+// `pieces`: [{ name, solid, ...rest }] in export order. Returns a new array, same order,
+// laid-out pieces translated (see laidOutOnBed).
 export function layoutExportPieces(part, pieces) {
-  const laidOut = (sp) => formOf(sp) === "map" && !isSheetPart(sp);
-  const mapPieces = pieces.filter(({ name }) => laidOut(part.parts[name]));
+  const mapPieces = pieces.filter(({ name }) => laidOutOnBed(part, name));
   if (mapPieces.length === 0) return pieces;
-  const offsets = bedLayout(
-    mapPieces.map(({ name, solid }) => ({ key: name, ...solid.boundingBox() })),
-    { width: bedWidthFor(part) },
-  );
+  const offsets = exportLayoutOffsets(part, mapPieces.map(({ name, solid }) => ({ name, box: solid.boundingBox() })));
   return pieces.map((pc) => (offsets.has(pc.name) ? { ...pc, solid: pc.solid.translate(offsets.get(pc.name)) } : pc));
 }

package/src/framework/export/bundle.js

@@ -392,6 +392,7 @@ export async function buildBundle({ kernel, part, msg, p, d, posed, label, expor
       pp.triangles = indices.length / 3;
     }
     builtPrints.push(pp);
+    kernel.cleanup?.(); // pp keeps only JS-owned data; free this piece's solids before the next (feedback #212)
   }
   const prints = dedupe(builtPrints, (x) => x.hash, (a, b) => a.triangles === b.triangles && a.color === b.color
       && near(a.volume, b.volume) && a.size.every((x, i) => near(x, b.size[i])))

package/src/framework/geometry/kernel.js

@@ -36,7 +36,7 @@ export const KERNEL_OPS = [
 // OCCT's replicad shapes need no dispose bookkeeping). jobs.js calls all of these via
 // `?.`, so a third-party backend may simply omit them.
 export const KERNEL_OPTIONAL_OPS = [
-  "beginSubPart", "endSubPart", "sweepCache", "cacheStats", "resetCacheStats", "cleanup",
+  "beginSubPart", "endSubPart", "sweepCache", "dropCache", "cacheStats", "resetCacheStats", "cleanup",
   // Drains the feature-skip warnings recorded since the last drain — a fillet or
   // chamfer the geometry defeated and the backend skipped rather than failed the
   // build over. Both backends implement it; a host that never calls it sees the
@@ -51,6 +51,9 @@ export const SOLID_OPS = [
   "translate", "rotate", "rotateX", "rotateY", "rotateZ", "rotateAbout", "along", "at",
   "mirror", "scale", "toMesh", "toSTL", "toIndexedMesh",
   "fillet", "chamfer", "shell", "roundAll",
+  // Additive in 0.165 (no CONTRACT_VERSION bump — the loftSmooth/heightfield
+  // precedent): both in-repo backends implement it.
+  "offset",
 ];
 
 // Backend-optional Solid queries: Manifold mesh-topology numbers (measure.js
@@ -109,6 +112,8 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; fillet(3) or fillet({r,edges}); legacy (r,selector) accepted for now (see file header)
  * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges; mesh-native incl. curved-face edges, OCCT fallback otherwise; chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted for now (see file header)
  * @property {(o:{t:number,open:object}) => Solid} shell   hollow inward (OCCT only); legacy (thickness,openFaces) accepted for now (see file header)
+ * @property {(r:number|{r:number}) => Solid} roundAll   morphological close-then-open with a ball of radius r: rounds every edge (both backends)
+ * @property {(d:number|{d:number}) => Solid} offset   3-D ball offset: grow (+d) / shrink (−d) the solid by |d| everywhere — convex edges round on a grow, concave on a shrink; both backends; the 2-D twin is Shape2D.offset
  * @property {() => number} [genus]     through-hole count (Manifold only)
  * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)
  *
@@ -165,6 +170,7 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {(name:string) => void} [beginSubPart]   open a per-sub-part solid-cache round (both backends)
  * @property {() => void} [endSubPart]                close the cache round (always pair with beginSubPart)
  * @property {() => void} [sweepCache]   drop cache partitions idle for 3 rebinds; call once per setPart, never mid-bracket
+ * @property {() => void} [dropCache]    drop EVERY cache partition (the worker calls it before an export); never mid-bracket
  * @property {() => {hits:number,misses:number}} [cacheStats]
  * @property {() => void} [resetCacheStats]
  * @property {() => void} [cleanup]   free per-job WASM objects (Manifold backend); call after each job

package/src/framework/geometry/manifold-backend.js

@@ -19,7 +19,7 @@ import { creasedNormals } from "./creased-normals.js";
 import { loftShadingPolicy, SMOOTH, BLEND } from "./shading-policy.js";
 import { meshFillet, meshChamfer, UnsupportedEdgeError } from "./mesh-fillet.js";
 import { affineAt, IDENTITY, invertAffine, mapSurface } from "./blend-surfaces.js";
-import { flatFacePlanes, meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
+import { flatFacePlanes, meshOffset, meshRoundAll, prismSection, roundAllSegs } from "./mesh-roundall.js";
 import { SEGS, circleSegs, doubleCurvatureSegs } from "./circle-segs.js";
 import { checkBooleanResult } from "./boolean-gate.js";
 import { KernelCapabilityError } from "./errors.js";
@@ -462,7 +462,12 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   // meshRoundAll's simplify tolerance protects), so only the face and its seam
   // vertices are on a plane. Keyed on geometry like every descriptor (see
   // blendSurfaces above), so it is never removed with the cache entry.
-  const markFlatFaces = (input, out, r) => {
+  //
+  // offset() reuses it with `moveTo`: a single dilate/erode step moves each flat
+  // face along its normal instead of returning it to its plane, so the planes are
+  // moved to where the step put them before they are registered. `r` and `segs`
+  // are the ball the step used (the tolerance rule is the same).
+  const markFlatFaces = (input, out, r, segs = roundAllSegs(2 * r, quality), moveTo = null) => {
     const gi = input.getMesh();
     let planes;
     try {
@@ -470,8 +475,8 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     } finally {
       gi.delete?.();
     }
+    if (moveTo) planes = planes.map(moveTo);
     if (!planes.length) return out;
-    const segs = roundAllSegs(2 * r, quality);
     const tol = Math.min(1e-3, 0.25 * r * (1 - Math.cos((2 * Math.PI) / segs)));
     const go = out.getMesh();
     try {
@@ -569,6 +574,18 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
       return cached(h("roundAll", hash, r, quality), () =>
         prismRoundAllFast(m, hash, r) ?? markFlatFaces(m, T(meshRoundAll(wasm, m, r, quality)), r));
     },
+    // Ball offset (mesh-roundall.js meshOffset): one dilate or erode, never
+    // routed, never NEEDS_OCCT. An erode deeper than the solid's half-thickness
+    // consumes it — the empty result is the honest answer, not a failure.
+    offset: (d) => {
+      if (!Number.isFinite(d)) throw new Error(`offset: d must be a finite number (got ${d})`);
+      if (d === 0) return wrap(m, hash); // contract: zero magnitude is the identity
+      return cached(h("offset", hash, d, quality), () => {
+        const { out, support, segs: ballSegs } = meshOffset(wasm, m, d, quality);
+        const sign = Math.sign(d); // a dilate moves a face out by h(n), an erode in by h(n)
+        return markFlatFaces(m, T(out), Math.abs(d), ballSegs, (p) => ({ n: p.n, d: p.d + sign * support(p.n) }));
+      });
+    },
     // batch difference: first minus the union of the rest, evaluated as one boolean
     // tree — no materialized intermediate union (the unionRaw memory note applies)
     cutAll: (tools) => cached(h("cutAll", hash, tools.map((t) => t._hash)), () => {
@@ -1046,6 +1063,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     sweepCache: () => cache.sweep(),
+    dropCache: () => cache.clear(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
     // Drain the feature-skip warnings recorded since the last drain (see

package/src/framework/geometry/mesh-roundall.js

@@ -84,6 +84,60 @@ export function meshRoundAll(wasm, m, r, quality) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Solid.offset on the mesh backend: ONE step of the chain above — a dilate
+// (d > 0, Minkowski sum) or an erode (d < 0, Minkowski difference) with a ball of
+// radius |d|. A true ball offset, so every point of the result's surface sits |d|
+// from the input's (within the ball's facet sagitta): convex edges and corners
+// round at radius d on a dilate, concave ones round at |d| on an erode, and the
+// other kind stays sharp. Same asOriginal-then-simplify cleanup as each roundAll
+// step, for the same sliver reason; the tolerance is roundAll's too, so the rim
+// ring that holds an offset face on its plane survives the simplify.
+//
+// Cost is the Minkowski's: on a non-convex input every triangle is hulled with
+// the ball, so time grows with the input's triangle count — measured ~3 ms per
+// input triangle on a dome (576 tris ≈ 2 s, 8,448 ≈ 23 s). The ball count is
+// sized from |d| alone, the one ball the op uses.
+export function meshOffset(wasm, m, d, quality) {
+  if (!Number.isFinite(d) || d === 0) throw new Error("offset: d must be a finite non-zero number (d = 0 is handled as the identity by the caller)");
+  const r = Math.abs(d);
+  const segs = roundAllSegs(r, quality);
+  const tol = Math.min(Math.max(r / 100, 0.01), 0.5 * r * (1 - Math.cos((2 * Math.PI) / segs)));
+  const ball = wasm.Manifold.sphere(r, segs);
+  try {
+    const raw = d > 0 ? m.minkowskiSum(ball) : m.minkowskiDifference(ball);
+    let orig;
+    try {
+      orig = raw.asOriginal();
+    } finally {
+      raw.delete?.();
+    }
+    try {
+      return { out: orig.simplify(tol), support: ballSupport(ball), segs };
+    } finally {
+      orig.delete?.();
+    }
+  } finally {
+    ball.delete?.();
+  }
+}
+
+// The faceted ball's support function h(n) = max over its vertices of n·v: how
+// far the offset actually moves a planar face with outward normal n (a dilate
+// puts it at n·x = d + h(n), an erode at d − h(n)). Equal to |d| where a ball
+// vertex lines up with n (the axes), a sagitta short of it elsewhere — the flat-
+// face shading below must place each plane where the face really landed.
+function ballSupport(ball) {
+  const g = ball.getMesh();
+  const np = g.numProp, vp = Float64Array.from(g.vertProperties);
+  g.delete?.();
+  return (n) => {
+    let best = -Infinity;
+    for (let i = 0; i < vp.length; i += np) best = Math.max(best, n[0] * vp[i] + n[1] * vp[i + 1] + n[2] * vp[i + 2]);
+    return best;
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Flat-face shading. The reference path's result is one fresh surface, shaded
 // SMOOTH (35° crease), and the rounding ball's facets bend far less than that, so

package/src/framework/geometry/occt-backend.js

@@ -25,7 +25,7 @@ import { groupInteractingRegions } from "./region-interaction.js";
 import { finishKernel } from "./kernel-front.js";
 import { makeProfileWarner } from "./profile-warnings.js";
 import { createOcctRepair } from "./occt-repair.js";
-import { occtRoundAll } from "./occt-roundall.js";
+import { occtOffset, occtRoundAll } from "./occt-roundall.js";
 import { classifyFaceGroups } from "./feature-attribution.js";
 import { emscriptenThrowEvidence, labelImportFailure } from "../kernel-error.js";
 import { resolveLoftRings, loftRingsKey } from "./loft-rings.js";
@@ -412,6 +412,16 @@ export function createOcctKernel(replicad) {
           return wrap(occtRoundAll(replicad, a._s, r, recordWarning), cloneLabels(a._labels), key);
         });
       },
+      // Never skips: a failed offset throws `offset-failed` (occt-roundall.js says why).
+      offset: (d) => {
+        if (!Number.isFinite(d)) throw new Error(`offset: d must be a finite number (got ${d})`);
+        const key = h("offset", hash, d);
+        return cached(key, () => {
+          const a = mat();
+          if (d === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
+          return wrap(occtOffset(replicad, a._s, d), cloneLabels(a._labels), key);
+        });
+      },
       shell: (thickness, openFaces) => {
         if (openFaces == null) throw new Error("shell: openFaces is required (a fully closed hollow is not supported)");
         const key = h("shell", hash, thickness, selKey(openFaces));
@@ -849,6 +859,7 @@ export function createOcctKernel(replicad) {
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),
     sweepCache: () => cache.sweep(),
+    dropCache: () => cache.clear(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
     // Drain the feature-skip warnings recorded since the last drain — the

package/src/framework/geometry/occt-repair.js

@@ -15,7 +15,12 @@
 // Is a shape a closed solid? A broken chamfer (one that over-ran and consumed a face)
 // meshes to an OPEN surface; a valid one is closed. OCCT meshes each face separately,
 // so weld vertices by position, then a closed solid has every edge shared by exactly
-// two triangles. (A coarse mesh is enough — this is a topology check.)
+// two triangles. (A coarse mesh is enough — this is a topology check.) A triangle
+// the weld collapses (two corners in one 1/32 mm cell — a sphere's pole fan, a
+// sliver) has no area and bounds nothing, so it is left out of the count: kept,
+// its self-edge counts once and its doubled edge three times, and every sphere
+// read as open. A mesh the weld collapses ENTIRELY bounds nothing either, so it
+// needs at least one surviving edge to count as closed.
 export const isClosedSolid = (shape) => {
   const m = shape.mesh({ tolerance: 0.3, angularTolerance: 1.0 });
   const P = m.vertices, T = m.triangles;
@@ -27,8 +32,10 @@ export const isClosedSolid = (shape) => {
   const edges = new Map();
   for (let t = 0; t < T.length / 3; t++) {
     const a = vid(T[t * 3]), b = vid(T[t * 3 + 1]), c = vid(T[t * 3 + 2]);
+    if (a === b || b === c || c === a) continue;
     for (const [x, y] of [[a, b], [b, c], [c, a]]) { const e = x < y ? x * 1e7 + y : y * 1e7 + x; edges.set(e, (edges.get(e) || 0) + 1); }
   }
+  if (edges.size === 0) return false;
   for (const n of edges.values()) if (n !== 2) return false;
   return true;
 };

package/src/framework/geometry/occt-roundall.js

@@ -30,9 +30,15 @@ const VARIANTS = [
   { join: "int", inter: false },
   { join: "int", inter: true },
 ];
+// Solid.offset's cascade: the Arc joins alone. An Intersection join extends the
+// faces to sharp corners, which passes every gate yet is not a ball offset.
+const ARC_VARIANTS = VARIANTS.filter((v) => v.join === "arc");
 
-export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`partforge: ${msg}`)) {
-  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
+// One gated offset step: the variant cascade above, each candidate held to the
+// IsDone / closed / positive-volume / volume-monotonic gate. Returns
+// { solid, vol } or null when no variant survives. `variants` is the cascade
+// order. Never frees `topoOwner` — the caller owns it.
+function offsetStep(replicad, topoOwner, off, vol, variants = VARIANTS) {
   const oc = replicad.getOC();
   const tryOffset = (topo, offset, v) => {
     const progress = new oc.Message_ProgressRange_1();
@@ -55,6 +61,26 @@ export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`p
       progress.delete?.();
     }
   };
+  for (const v of variants) {
+    const cand = tryOffset(topoOwner.wrapped, off, v);
+    if (!cand) continue;
+    let cvol;
+    try { cvol = replicad.measureVolume(cand); } catch { cand.delete?.(); continue; }
+    if (!Number.isFinite(cvol) || cvol <= 0) { cand.delete?.(); continue; }
+    if (off > 0 && cvol < vol * 0.999) { cand.delete?.(); continue; } // dilation shrank: garbage
+    if (off < 0 && cvol > vol * 1.001) { cand.delete?.(); continue; } // erosion grew: garbage
+    // isClosedSolid meshes the candidate, and meshing OCCT offset garbage can
+    // throw — that is just another rejected candidate, not an escape hatch out
+    // of "roundAll never throws for geometry".
+    try { if (!isClosedSolid(cand)) { cand.delete?.(); continue; } }
+    catch { cand.delete?.(); continue; }
+    return { solid: cand, vol: cvol };
+  }
+  return null;
+}
+
+export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`partforge: ${msg}`)) {
+  if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
   let vol;
   try {
     vol = replicad.measureVolume(shape);
@@ -65,30 +91,37 @@ export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`p
   }
   let cur = shape;
   for (const off of [r, -2 * r, r]) {
-    let next = null;
-    for (const v of VARIANTS) {
-      const cand = tryOffset(cur.wrapped, off, v);
-      if (!cand) continue;
-      let cvol;
-      try { cvol = replicad.measureVolume(cand); } catch { cand.delete?.(); continue; }
-      if (!Number.isFinite(cvol) || cvol <= 0) { cand.delete?.(); continue; }
-      if (off > 0 && cvol < vol * 0.999) { cand.delete?.(); continue; } // dilation shrank: garbage
-      if (off < 0 && cvol > vol * 1.001) { cand.delete?.(); continue; } // erosion grew: garbage
-      // isClosedSolid meshes the candidate, and meshing OCCT offset garbage can
-      // throw — that is just another rejected candidate, not an escape hatch out
-      // of "roundAll never throws for geometry".
-      try { if (!isClosedSolid(cand)) { cand.delete?.(); continue; } }
-      catch { cand.delete?.(); continue; }
-      next = cand;
-      vol = cvol;
-      break;
-    }
+    const next = offsetStep(replicad, cur, off, vol);
     if (cur !== shape) cur.delete?.(); // superseded intermediate; never the caller's shape
     if (!next) {
       warn(`roundall-skipped: offset step ${off} produced no valid solid — r=${r} is likely at/above the smallest feature size; returning the un-rounded solid`);
       return shape.clone();
     }
-    cur = next;
+    cur = next.solid;
+    vol = next.vol;
   }
   return cur;
 }
+
+// Solid.offset on the B-rep class: ONE gated offset step, Arc joins only, so the
+// corners match the mesh class's ball offset (convex edges round on a grow,
+// concave on a shrink). Unlike roundAll this never skips: an un-offset solid
+// handed back as an offset is silently wrong geometry (a skin cut from it comes
+// out empty), so a step no variant survives THROWS, with a greppable message
+// (docs/ERROR-PATTERNS.md "offset-failed"). The usual trigger is an erode at or
+// past half the thinnest wall — the B-rep offset cannot change topology, which
+// the mesh class's Minkowski does.
+export function occtOffset(replicad, shape, d) {
+  if (!Number.isFinite(d) || d === 0) throw new Error("offset: d must be a finite non-zero number (d = 0 is handled as the identity by the caller)");
+  let vol;
+  try {
+    vol = replicad.measureVolume(shape);
+  } catch (e) {
+    throw new Error(`offset-failed: offset(${d}) could not measure the input solid on the OCCT backend (${e?.message || e})`);
+  }
+  const next = offsetStep(replicad, shape, d, vol, ARC_VARIANTS);
+  if (!next) {
+    throw new Error(`offset-failed: offset(${d}) produced no valid solid on the OCCT backend — |d| is likely at/above half the thinnest wall, or the shape has faces OCCT cannot offset; the Manifold backend's offset handles both (meta.backend: "manifold")`);
+  }
+  return next.solid;
+}

package/src/framework/geometry/op-options.js

@@ -365,6 +365,8 @@ export const SOLID_OP_SPECS = {
     return [req("shell", o, "t"), req("shell", o, "open")]; } },
   roundAll: { toArgs: (o) => { checkKeys("roundAll", o, ["r"]);
     return [req("roundAll", o, "r")]; } },
+  offset:   { toArgs: (o) => { checkKeys("offset", o, ["d"]);
+    return [req("offset", o, "d")]; } },
 };
 
 // A zero-magnitude fillet/chamfer is the identity on every conformance class

package/src/framework/geometry/solid-cache.js

@@ -66,6 +66,20 @@ export function createSolidCache() {
       }
     },
 
+    // Drop EVERY partition, whatever its age — the next build of each sub-part is
+    // cold. The worker calls this before an export (feedback #212): the display
+    // build's retained solids and the export's own print-quality build share one
+    // WASM heap, and on a 105-plate forge the display cache alone held ~1.75 GB,
+    // so the export ran out of heap after a few plates on a phone. Like sweep(),
+    // never mid-bracket — the worker's job queue is serial.
+    clear() {
+      for (const entries of caches.values()) {
+        for (const [hash, entry] of entries) release(hash, entry); // refcounted: each partition lets go once
+      }
+      caches.clear();
+      lastBuilt.clear();
+    },
+
     lookup(hash, make) {
       if (name == null) return make().value; // not bracketed → no caching
       if (active.has(hash)) { hits++; return active.get(hash).value; }

package/src/framework/jobs.js

@@ -163,6 +163,22 @@ async function scoreMatchTargets(built, targets, onProgress) {
   }
 }
 
+// The WASM traps that mean the kernel ran out of heap (or was corrupted by doing so).
+const HEAP_TRAP_RE = /out of bounds memory access|memory access out of bounds|Cannot enlarge memory|out of memory/i;
+
+// A piece of a many-piece export failed: say WHICH piece, how far the export got, and
+// — when it is the heap that ran out — the one remedy the user can apply. The raw
+// message stays LAST, after a colon, so a host's own trap classifier still matches it.
+function exportPieceError(thrown, { kernel, piece, index, count }) {
+  const err = describeKernelThrow(thrown, { evidence: kernel._throwEvidence?.(thrown) });
+  if (count < 2 || err?.code) return err; // one piece: the error already names it; coded errors are routed, not shown
+  const raw = String(err?.message || err);
+  const advice = HEAP_TRAP_RE.test(raw)
+    ? " ran out of memory — export fewer parts at a time (each export needs room for the parts it builds)"
+    : " failed";
+  return new Error(`exporting "${piece}" (part ${index + 1} of ${count})${advice}: ${raw}`, { cause: thrown });
+}
+
 export async function handle(kernel, part, msg, post, opts = {}) {
   const isStale = opts.isStale ?? (() => false);
   const onProgress = (phase) => post({ type: "progress", phase, jobId: msg.jobId });
@@ -500,9 +516,18 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       const names = selected();
       if (names.length === 0) throw new Error("no exportable parts selected");
       const out = [];
-      for (const name of names) {
+      for (const [i, name] of names.entries()) {
         onProgress(`building ${label(name)}`);
-        out.push({ name: exportName(name), data: await posed(name, "export", onProgress).toSTL({ quality: msg.quality ?? "print" }) });
+        try {
+          out.push({ name: exportName(name), data: await posed(name, "export", onProgress).toSTL({ quality: msg.quality ?? "print" }) });
+        } catch (thrown) {
+          throw exportPieceError(thrown, { kernel, piece: label(name), index: i, count: names.length });
+        }
+        // Each file is JS-owned once toSTL returns, so this piece's solids can go now.
+        // Without it a many-piece export held every piece's print-quality build until
+        // the job ended — the 105-plate forge of feedback #212 ran out of heap at
+        // about the 100th plate.
+        kernel.cleanup?.();
       }
       post({ type: "download-parts", ext: "stl", mime: "model/stl", parts: out, jobId: msg.jobId },
            out.map((pp) => bufferOf(pp.data)));
@@ -523,12 +548,27 @@ export async function handle(kernel, part, msg, post, opts = {}) {
     } else if (msg.type === "export-3mf") {
       const names = selected();
       if (names.length === 0) throw new Error("no exportable parts selected");
-      const { layoutExportPieces } = await loadBedLayout();
-      const meshes = layoutExportPieces(part, names.map((name) => {
+      // One piece in the kernel at a time, as export-stl: build, read the bounds the bed
+      // layout needs, mesh into JS-owned arrays, free — then lay out from the bounds and
+      // shift the meshes (translation only, so this is the layout layoutExportPieces makes).
+      const { laidOutOnBed, exportLayoutOffsets } = await loadBedLayout();
+      const built = [];
+      for (const [i, name] of names.entries()) {
         onProgress(`building ${label(name)}`);
-        return { name, solid: posed(name, "export", onProgress) };
-      })).map(({ name, solid }) => {
-        const { positions, indices } = solid.toIndexedMesh({ quality: msg.quality ?? "print" });
+        try {
+          const solid = posed(name, "export", onProgress);
+          const box = laidOutOnBed(part, name) ? solid.boundingBox() : null;
+          const { positions, indices } = solid.toIndexedMesh({ quality: msg.quality ?? "print" });
+          built.push({ name, box, positions, indices });
+        } catch (thrown) {
+          throw exportPieceError(thrown, { kernel, piece: label(name), index: i, count: names.length });
+        }
+        kernel.cleanup?.();
+      }
+      const offsets = exportLayoutOffsets(part, built.filter((b) => b.box));
+      const meshes = built.map(({ name, positions, indices }) => {
+        const o = offsets.get(name);
+        if (o) for (let j = 0; j < positions.length; j += 3) { positions[j] += o[0]; positions[j + 1] += o[1]; positions[j + 2] += o[2]; }
         return { name: exportName(name), positions, indices, color: printColor(part.parts[name]?.display) };
       });
       onProgress("writing 3MF file");

package/src/framework/worker.js

@@ -30,6 +30,15 @@ async function manifoldKernels() {
   };
 }
 
+// Jobs that build every selected sub-part again at export quality. Before one runs,
+// the worker drops its kernels' display caches (dropCache): the cache's retained
+// solids and the export's build share one WASM heap, and on a very large part the
+// display build alone held ~1.75 GB — on a phone, enough that exporting three of a
+// 105-plate forge's plates ran out of heap (feedback #212). The cost is one cold
+// display build after an export; exports are rare and deliberate, a failed one
+// costs the user the whole job.
+const EXPORT_JOBS = new Set(["export-stl", "export-step", "export-3mf", "export-bundle"]);
+
 async function occtKernel() {
   const [{ default: opencascade }, wasmUrlMod, replicad, { createOcctKernel }] = await Promise.all([
     import("replicad-opencascadejs/src/replicad_single.js"),
@@ -115,6 +124,11 @@ export function runWorker(part, opts = {}) {
           // A generate superseded while it sat in the queue never builds at all.
           if (job.epoch !== null && job.epoch !== epoch) continue;
           kernel = await kernelFor(job.data);
+          if (EXPORT_JOBS.has(job.data?.type)) {
+            manifold?.preview.dropCache?.();
+            manifold?.print.dropCache?.();
+            occt?.dropCache?.();
+          }
           // handle() declares each message's transferables (the big binary buffers).
           const post = (m, transfer = []) => postMessage(m, transfer);
           if (job.epoch === null) { await handle(kernel, job.part, job.data, post, { importMeshes, jobs: opts.jobs }); continue; }

package/types/kernel.d.ts

@@ -290,6 +290,16 @@ export interface Solid {
    * never throws `KernelCapabilityError`. `roundAll(0)` is the identity.
    */
   roundAll(r: number | { r: number }): Solid;
+  /**
+   * 3-D ball offset — the solid counterpart of `Shape2D.offset`. `d > 0` grows
+   * the solid by `d` everywhere (convex edges round at radius `d`); `d < 0`
+   * shrinks it by `|d|` (concave edges round, convex corners stay sharp). Works
+   * on both backends and on imported meshes; never routes. A constant-thickness
+   * skin is `body.cut(body.offset(-t))`. `offset(0)` is the identity. The mesh
+   * backend's cost grows with triangle count (~3 ms per triangle); on OCCT an
+   * offset that cannot be built throws `offset-failed`.
+   */
+  offset(d: number | { d: number }): Solid;
   /** Through-hole count (Manifold only). */
   genus?(): number;
   /** No geometry at all (Manifold only). */
@@ -632,6 +642,8 @@ export interface GeometryKernel {
   endSubPart?(): void;
   /** Drop cache partitions idle for 3 rebinds. Never call mid-bracket. */
   sweepCache?(): void;
+  /** Drop every cache partition — the worker calls this before an export job. Never call mid-bracket. */
+  dropCache?(): void;
   cacheStats?(): { hits: number; misses: number };
   resetCacheStats?(): void;
   /** Free per-job WASM objects (Manifold backend); call after each job. */