partforge 0.163.1 → 0.164.0

package/bin/cli.js

@@ -559,14 +559,17 @@ function printVerify(v) {
   for (const c of v.cases) {
     console.log(`  ${c.name}`);
     for (const ch of c.checks) {
-      const icon = ch.status === "pass" ? "✓" : ch.status === "fail" ? "✗" : ch.status === "warn" ? "⚠" : "·";
-      console.log(`    ${icon} ${ch.subpart ?? "_view"} ${ch.metric} ${ch.expr}  (${ch.message})`);
+      // A cost has a price (supports, a brim), so it gets `$`, not a warning sign.
+      const icon = ch.status === "pass" ? "✓" : ch.status === "fail" ? "✗" : ch.status === "warn" ? "⚠"
+        : ch.status === "cost" ? "$" : "·";
+      console.log(`    ${icon} ${ch.subpart ?? "_view"} ${ch.metric} ${ch.expr}  (${ch.message})${ch.accepted ? " (accepted)" : ""}`);
       // A measurement caveat prints whatever the verdict — "passed, but sampled"
       // is precisely the line a reader must not miss.
       if (ch.note) console.log(`        note: ${ch.note}`);
-      if (ch.status === "fail" || ch.status === "warn") {
+      if (ch.status === "fail" || ch.status === "warn" || ch.status === "cost") {
         if (ch.location) console.log(`        at [${ch.location.map((n) => n.toFixed(1)).join(", ")}]`);
-        if (ch.hint) console.log(`        hint: ${ch.hint}${ch.pattern ? ` (${patternRef(ch.pattern)})` : ""}`);
+        // An accepted cost's remedy is moot: the user already chose to pay it.
+        if (ch.hint && !ch.accepted) console.log(`        hint: ${ch.hint}${ch.pattern ? ` (${patternRef(ch.pattern)})` : ""}`);
       }
     }
   }
@@ -584,7 +587,8 @@ function printVerify(v) {
     : v.unevaluated?.length ? `verdict withheld (${v.unevaluated.length} check(s) not evaluated)`
     : v.declared ? "nothing verified (every declared check skipped)"
     : "nothing verified (no expectations declared)";
-  console.log(`  result: ${verdict}${w ? `, ${w} warning(s)` : ""}`);
+  const c = v.costs?.length ?? 0;
+  console.log(`  result: ${verdict}${w ? `, ${w} warning(s)` : ""}${c ? `, ${c} cost(s)` : ""}`);
 }
 
 function printLint(r) {

package/docs/AUTHORING-PARTS.md

@@ -1919,6 +1919,128 @@ that tessellates nothing, unlike `toRegions()`), `fillet(r, opts?)`, `chamfer(di
 opts?)`, `simplify(tolerance)`, `corners()`, `contains([x,y])`, `isEmpty()` (no
 regions left — see the vanishing-features rule above).
 
+## Printed parts
+
+3D-printed parts: FDM (filament) and resin. Everything that is not a sheet
+part is printed, but a part says so on purpose by declaring its print process in
+`verify.process`; that one key arms the process's print checks below from the first
+build (all of them under FDM; bed fit and min wall under `resin`). Name
+the process the user will print with, never one written by habit: it is the declaration
+the checks, the fits and the advice all read.
+
+### Declaring the process
+
+`process` is a profile id — `fdm-pla`, `fdm-petg` (the `fdm` process) or `resin` (the
+`resin` process) — or an inline object whose `base` names one and whose other keys
+override it: `{ base: "fdm-pla", bed: [256, 256, 256] }` for a bigger printer,
+`{ base: "fdm-pla", fits: { … } }` for a calibrated one (`fits` replaces the whole
+table). The profile numbers are in the `verify` section's table below. `accept` lists
+the costs the user has chosen to pay:
+
+```js
+verify: {
+  process: "fdm-pla",
+  accept: ["supports"],        // the user chose supports for the organic body
+  expect: { body: { holes: 1 }, _view: { overlaps: 0 } },
+}
+```
+
+### Gates, costs and advisories
+
+Every print check is in exactly one tier, decided by what the reading means:
+
+| tier | checks | effect on `verify.ok` |
+| --- | --- | --- |
+| **gate** — a defect in any orientation | bed fit (`bbox` within `bed`), bed contact (`bedContactPct` ≥ 50) | fails it |
+| **cost** — a design choice with a price | overhang (`overhangArea`, id `supports`), footprint (`footprintPct` ≥ 10, id `footprint`) | never |
+| **advisory** — a reading that may not matter | min wall (`minWall`), `wall` | never; a warning |
+
+A **gate** is fixed before the work is done: the piece cannot be printed this way
+whatever the user wants. A **cost** is a fact with a number and a location — mm² of
+overhang on a named piece and where it sits, or the share of a piece's silhouette on
+the bed that actually touches it — listed in `verify().costs` (never in `warnings`) with `status: "cost"`. It
+does not block a part still being shaped; it informs. Say each cost to the user once,
+in one sentence naming the piece, the number and the alternative ("the arm overhangs
+by 840 mm² and prints on supports; splitting it at the elbow avoids them"), and record
+the answer in `accept`. An **advisory** is read, and acted on only when
+it is real (a thin wall the user will hold, not a sliver at a facet seam).
+
+**Accepting a cost is not switching it off.** An accepted cost is still measured and
+still listed in `costs`, with `accepted: true`, so the number stays visible; it is
+simply no longer something to raise. Switching a measurement off is the inline
+profile form, `{ base: "fdm-pla", overhang: null }` (or `footprint: null`,
+`bedContact: null`), and is for a part where the reading is meaningless, not unwelcome.
+A threshold the user named ("under 500 mm² of supports") is an `expect`:
+`overhangArea: "<=500"` — still a cost, reported in `costs` and never failing `ok`;
+the user's own limit keeps its meaning, so it is never marked accepted, whatever
+`accept` says (`accept` covers only the process's default check). Lint refuses an `accept` entry the process does not define
+(`verify-unknown-accept`): `fdm` defines `supports` and `footprint`; `resin` prints on
+supports and defines none.
+
+**What arms what.** Under `fdm-pla`/`fdm-petg` the profile alone arms every check in
+the table except `wall`, which runs only where a sub-part declares a band; overhang fires past 1 mm². `resin` arms bed fit and min wall only. `orientation: "print"` declares that `build()`
+is the print pose (Z up, bed at the lowest Z); it arms nothing under a named profile,
+and with no profile at all it arms bed contact alone. An expectation you write yourself
+(`overhangArea`, `bedContactPct`, `footprintPct`) arms its own measurement under any
+profile or none; an `overhangArea` one is measured against 45° when the profile names no
+angle.
+
+### Orientation first
+
+Decide each piece's print pose before its geometry. Put its largest flat face on the
+bed; when a piece has none, split it at its widest flat section so each half has one,
+and join the halves with pins or a dovetail. `build()` IS that pose — every check and
+every export reads the piece as built — and `views.assembly` poses it into place; a
+`print` view lays the pieces out on the bed beside each other (see "The
+`PartDefinition` contract"). A piece that reads well in the assembly and prints on its
+side is the most common source of both costs.
+
+### What costs supports and what does not
+
+Overhangs past the profile's angle (45° from vertical on FDM) cost supports, and so
+do bridges longer than `bridge` (10 mm) and any cavity that opens downward — a socket
+under a ball, a pocket on the underside. The check counts every flat underside, a short
+bridge and the ceiling of a horizontal bore included, since a mesh cannot tell a bridge
+from a ceiling: a bridge within `bridge` prints without support, so tell the user that
+rather than redesign it. Faces within 45° of
+vertical do not cost supports: a chamfer under a ledge instead of a square step, a
+teardrop bore (a round hole with a 45° peak on top) instead of a round one. Faces on
+the bed or within 1 mm of it are never counted, so a bottom-edge chamfer, or a small fillet, is
+free.
+
+**Ball joints on FDM** are a split socket (two halves that clamp the ball and screw or
+pin together) or a pinned clevis, not a socket snapped over a sphere: the snap's inside
+is a downward cavity that prints on supports nobody can reach. Build the snap only when
+the user wants it and has accepted the supports.
+
+### Small features and scale
+
+A feature thinner than the profile's `minWall` (1.2 mm PLA, 1.5 mm PETG, 0.6 mm
+resin) prints as noise or not at all. A part with a scale parameter is checked at both
+ends of it: add a preset at the smallest and the largest scale and name them in
+`verify.cases`, so the small end's pins and walls are measured rather than described
+in the control's label ("below 150 mm the pins get thin").
+
+### Fits
+
+Size a mating feature from the profile's fit class — `press`, `push`, `slip`,
+`moving`, `printInPlace` — copied into `derive()` with a comment naming it
+(`// slip fit: fdm-pla 0.25`), and a horizontal bore enlarged by `holeUndersize`. A
+snap is a contact; its fit is `push` or `slip`. The numbers, and how a diametral fit
+becomes a `clearance` expectation, are in the `verify` section below.
+
+### First layer
+
+The first layer squashes wider than drawn (elephant's foot): give a bottom edge that
+must mate or measure true a small 45° chamfer (about 0.4 mm). Keep the underside flat
+and lowest: a knuckle, pin or boss that dips below it lifts the flat face off the bed
+and fails bed contact ([piece-hovers-above-bed](ERROR-PATTERNS.md#piece-hovers-above-bed))
+— size a print-in-place knuckle tangent to the bed and give it a block down to
+z = 0. A piece resting on a point, a line or a curve is reported as a footprint cost
+([piece-stands-on-nothing](ERROR-PATTERNS.md#piece-stands-on-nothing)): lay it on a
+flat face, add a pad, or record the user's brim with `accept: ["footprint"]`. Never
+emboss text on the underside; deboss it, or put it on a side or the top.
+
 ## Sheet parts
 
 Laser-cut parts from flat stock — plywood, MDF, acrylic — for a laser cutter
@@ -4008,7 +4130,7 @@ runtime a throwing probe only degrades quietly to `{ error }`.
 
 **Verify block** — `verify-unknown-metric`, `verify-unknown-subpart`,
 `verify-bad-expr`, `verify-bad-pair-check`, `verify-unknown-process`,
-`verify-unknown-orientation`,
+`verify-unknown-orientation`, `verify-unknown-accept`,
 `verify-expect-throws` (all errors). Note `_view` also accepts the pair-wise
 `contacts` / `clearance` / `held` keys, which are not scalar view metrics; they are
 validated by `verify-bad-pair-check`, matching `verify.js`'s own handling.
@@ -4173,7 +4295,8 @@ carries:
   from a sample rather than every triangle (see below); `overhangArea` sets one
   naming the steepest unsupported face's angle,
 - `location` — `[x, y, z]` in mm where the metric has one: `minWall` (thinnest
-  sample point), `overhangArea` (the largest unsupported face's centroid) and
+  sample point), `overhangArea` (the largest unsupported face's centroid),
+  `footprintPct` (the piece's lowest point; absent when its export-pose reading failed) and
   `overlaps` (the center of the first offending intersection's
   *bounding box* — a nearby indicator, not an exact point: when a pair overlaps in
   more than one place the bbox center can fall in the empty space between regions)
@@ -4188,7 +4311,8 @@ exists, e.g. the OCCT backend or min-wall measurement turned off, matching
 per triangle, which is unbounded work on a dense mesh, so past a sample budget
 it casts from a spread, deterministic subset instead — `minWallSampled` (boolean)
 and `minWallSamples` (`{ sampled, total }` or `null`) say whether that happened.
-A part that opted into the overhang check (see the `verify` block) also carries
+A part checked for overhang (a profile carrying `overhang`, or an `overhangArea`
+expectation — see the `verify` block) also carries
 `overhangArea` (mm² of unsupported downward-facing surface, `null` when not
 checked or on an `exportable: false` sub-part), `overhangAngle` (the steepest such
 face, degrees from vertical) and `overhangAt` (that face's centroid); the report's
@@ -4198,7 +4322,13 @@ A part checked for bed contact (an FDM profile, see the `verify` block) carries
 when not checked or on an `exportable: false` sub-part), `bedContactArea` and
 `bedHoverArea` (mm² touching and hovering), `bedHoverGap` (how far above the bed the
 largest hovering face sits, `null` when nothing hovers) and `bedHoverAt` (its
-centroid); the report's `measuredBedContact` says whether the pass ran.
+centroid); the report's `measuredBedContact` says whether the pass ran. The same
+pass reads `footprintPct` (the share of the piece's silhouette on the bed that actually
+touches it, in percent; `null` when not measured or the silhouette is empty) and
+`footprintAt`
+(the piece's lowest point; `null` when its export-pose reading failed), stamped by
+`measuredFootprint`; a profile carrying
+`footprint`, or a `footprintPct` expectation, arms the pass too.
 A sub-part that declares `wall` (see the `verify` section below) also carries
 `wall` — `{ value, location, band, members }` or `null`: the declared band's
 worst member, located, with the band it was measured against and how many rays
@@ -4302,10 +4432,11 @@ A part can declare how it should be checked, co-located with its schema, so
 
 ```js
 verify: {
-  process: "fdm-pla",            // a DFM profile: fdm-pla | fdm-petg | resin, or an
-                                  // inline { base, bed:[x,y,z], minWall, overhang, bedContact, fits, holeUndersize, bridge } object
-  orientation: "print",          // optional; ONLY with this is overhang checked — it says the
-                                  // part is laid out for its bed (Z up, bed at the lowest Z)
+  process: "fdm-pla",            // a DFM profile: fdm-pla | fdm-petg | resin, or an inline
+                                  // { base, bed:[x,y,z], minWall, overhang, bedContact, footprint, fits, holeUndersize, bridge } object
+  accept: ["supports"],          // optional; the costs the user chose to pay (fdm: supports, footprint)
+  orientation: "print",          // optional; declares build() is the print pose (Z up, bed at
+                                  // the lowest Z) — with no profile it arms bed contact
   cases: ["defaults", "M3"],     // optional; default = defaults + every preset
   expect: {                      // design intent, by sub-part name (+ "_view")
     spacer: { holes: 1, bbox: "<=[60,60,60]", volume: "0.4..0.6cm3" },
@@ -4318,28 +4449,38 @@ verify: {
 ```
 
 **What the profile gives you:** a hard **bed-fit** gate (the view bbox must fit `bed`),
-a **min-wall** warning, and — only for a part that also declares
-`orientation: "print"` — an **overhang** warning: `overhangArea` is the mm² of
+a **min-wall** warning, and on the FDM profiles a **bed-contact** gate and two
+**costs** — overhang and footprint (below). A cost is never a failure: it is a design
+choice with a price, reported in `verify().costs` with its number, location and hint
+and `status: "cost"`, and `ok` ignores it. See "Printed parts" for the tiers and how
+to raise a cost with the user.
+
+**Overhang — a COST, armed by the process.** `overhangArea` is the mm² of
 downward-facing surface steeper than the profile's `overhang` angle (45° from vertical
 on the FDM profiles; resin carries none, since it prints on supports), measured per
 sub-part in its print (export) pose — not as the view shows it — with the bed at that
-pose's own lowest Z, and warned past 1 mm²; the reported location is where the face sits
-in the view. The
-opt-in is deliberate: a profile says what a process can print, the orientation key
-says this part is laid out for it, and a part still being shaped, or one bound for a
-different process, should not be nagged about its underside. Writing your own
+pose's own lowest Z; it is a cost past 1 mm², with cost id `supports`, and the
+reported location is where the face sits in the view. A profile carrying `overhang`
+arms it from the first build; `orientation` takes no part. Writing your own
 `overhangArea` expectation is the other way in — it arms the measurement by itself,
-against the profile's angle or 45° when the profile names none, so a declared
-expectation is never answered "unavailable". Two bands next to the bed are never
+against the profile's angle or 45° when the profile names none, and is also how a
+user's limit is spelled (`overhangArea: "<=500"`). Two bands next to the bed are never
 counted: the footprint itself, and faces whose centroid sits within 1 mm of the bed
 (the lower curl of a bottom-edge fillet or chamfer, which prints fine). A bridge (a
 flat underside spanning two supports) and the ceiling of a horizontal bore are
-reported as overhangs — the mesh alone cannot tell a bridge from a ceiling — which
-is why this is a warning and never a gate. Two more limits, stated: it is judged in
-the DISPLAY pose, so a sub-part whose `assembly` pose stands it differently from how it prints (a lid that prints
-flat beside its base) is measured as displayed, and `exportable: false` sub-parts
-are skipped. Switch it off under an FDM profile with an inline
-`{ base: "fdm-pla", overhang: null }`.
+reported as overhangs — the mesh alone cannot tell a bridge from a ceiling — so read
+the location before proposing a redesign. When a sub-part's `place()` cannot be
+trusted as a rigid pose (it queries its solid), the reading falls back to the DISPLAY
+pose, so such a piece is measured as the view shows it. `exportable: false` sub-parts
+are skipped.
+
+**`accept` records the user's choice.** `accept: ["supports"]` says the user chose to
+print with supports: the overhang is still measured and still listed in `costs`, with
+`accepted: true`, and is no longer something to raise. That is a different thing from
+switching the measurement off, which is the inline `{ base: "fdm-pla", overhang: null }`
+(and `footprint: null`) for a part where the reading means nothing. `accept` holds cost
+ids, not metric names — `fdm` defines `supports` and `footprint`, `resin` none — and
+lint refuses any other entry (`verify-unknown-accept`).
 
 **Bed contact — a GATE, armed by the FDM profile alone.** Every exporter and slicer
 lays a printed piece on its lowest point. When that point is something small — a
@@ -4362,10 +4503,9 @@ its note says how far up it sits and how much area hovers versus touches. The fi
 almost always to trim the piece flat at the bed plane — cut away everything below
 z = 0 in its print pose — or to raise or shorten the lower feature so the flat face
 is the lowest; size a print-in-place knuckle so its cylinder is tangent to the bed
-(diameter = 2 × its centre height) and give it a support block down to z = 0. Unlike
-overhang, no orientation key is needed: an overhang is a design choice a part still
-being shaped may not have made, but a hovering underside is a defect in whatever
-orientation the piece exports. Resin prints on supports, so `resin` never checks it
+(diameter = 2 × its centre height) and give it a support block down to z = 0. It is a
+gate where overhang is a cost: an overhang is a design choice that prints on supports,
+but a hovering underside is a defect in whatever orientation the piece exports. Resin prints on supports, so `resin` never checks it
 unless you ask: your own `bedContactPct` expectation arms it under any profile, and
 `orientation: "print"` arms it on a part with no profile at all (both against 50%). A
 named profile otherwise decides alone. A recess meant to clear the
@@ -4375,6 +4515,23 @@ default stands, and a part that means it declares a lower `bedContactPct` (or
 `{ base: "fdm-pla", bedContact: null }` to switch it off). `exportable: false`
 sub-parts are not judged.
 
+**Footprint — a COST, armed by the FDM profile.** Bed contact passes a piece that
+stands on a point, a line or a curve, since nothing flat hovers; the first layer still
+has almost nothing to grip, and the piece tips or pulls loose unless it prints with a
+brim or a raft. `footprintPct` is the share of the piece's silhouette on the bed (its
+outline seen from below, in the same print pose) that actually touches it, read by bed
+contact's pass, in percent: a plate reads 100, and so do a tube on its rim, a frame of
+thin bars, spread pins and a bar laid diagonally, since each stands on all of its
+outline; a rod on a rounded tip reads about 0, a cylinder on its side a few percent
+(the facets along its lowest line), under the floor, and a wide piece balanced on a
+narrow foot reads low too. It is a cost below the profile's `footprint` (10%), with cost id
+`footprint`, located at the piece's lowest point
+([piece-stands-on-nothing](ERROR-PATTERNS.md#piece-stands-on-nothing)). Lay the piece on
+a flat face or add a pad; when the user chooses the brim, `accept: ["footprint"]`
+records it. Your own `footprintPct` expectation arms it under any profile; `orientation`
+does not, and `{ base: "fdm-pla", footprint: null }` switches it off. `exportable: false`
+sub-parts are not judged.
+
 **What the profile tells you.** Three more fields carry the numbers a mating
 feature needs. Nothing checks them; they are the one place the value is spelled,
 so `derive()` copies it with a comment naming the fit (`// slip fit: fdm-pla 0.25`).
@@ -4399,7 +4556,7 @@ an inline `{ base: "fdm-pla", fits: { … } }` replaces the whole table.
 **What `expect` gives you:** per-sub-part
 assertions on the facts `measure` already reports — `holes` (through-bores / genus),
 `volume`, `surfaceArea`, `triangleCount`, `bbox`, `watertight`, `minWall`,
-`overhangArea`, `bedContactPct`, `wall` (a range — see below), `bounds` (the axis-aligned corner
+`overhangArea`, `bedContactPct`, `footprintPct`, `wall` (a range — see below), `bounds` (the axis-aligned corner
 positions, written in the same `{ min, max }` shape `measure` reports them — where
 the geometry sits, vs `bbox` which is only its size) and `centerOfMass` (`[x,y,z]`, the volume-weighted
 centroid; `null` for a degenerate/zero-volume sub-part); and `_view` assertions `bbox`,
@@ -4442,12 +4599,14 @@ verify: { expect: {
 } }
 ```
 
-**Gates vs. warnings:** exact facts are **gates** (a failure sets a non-zero exit code);
-`minWall` is computed (a ray/shot wall-thickness measurement) and reported as a
-**warning** — it flags walls below the profile's minimum but never fails the build —
-and so is `overhangArea` (see above). `bedContactPct` is a **gate** even though the
-profile arms it (see above). `holes`/`watertight` are Manifold-only, so those
-assertions **skip** on OCCT parts rather than fail.
+**Gates, costs and warnings:** exact facts are **gates** (a failure sets a non-zero
+exit code and `ok: false`), and so is `bedContactPct`, even though the profile arms it.
+`overhangArea` and `footprintPct` under a process are **costs**: listed in `costs`, never
+failing, `accepted` once `accept` names them — but an `overhangArea` or `footprintPct`
+you write in `expect` is still a cost, not a gate. `minWall` is computed (a ray/shot
+wall-thickness measurement) and reported as a **warning** — it flags walls below the
+profile's minimum but never fails the build. `holes`/`watertight` are Manifold-only, so
+those assertions **skip** on OCCT parts rather than fail.
 
 **A wall that must stay one thickness: `wall`.** `minWall` answers "is anything too
 thin"; `wall` answers "does this wall stay what I declared" — the question a bend, a
@@ -4553,8 +4712,8 @@ mass. A reference ghost (`exportable: false`) is left out entirely: it neither
 counts nor holds, since it is never printed (lint refuses one named as the base).
 A named base that is `enabled()`-off
 in a case skips that case; a name that exists nowhere throws, like a `contacts`
-pair. It is an expectation, never a default, for the overhang reason: a part
-still being shaped should not be nagged. Topological only — a part balanced on a
+pair. It is an expectation, never a default: a part still being shaped should not
+fail for pieces it has not joined yet. Topological only — a part balanced on a
 point passes — and the same OCCT caveat applies: a sub-part fully inside another
 reads as not touching there. A view with fewer than two printed sub-parts passes with nothing to hold. A pin or axle running in a clearance bore, or a print-in-place piece, touches nothing in the model and reads as floating: `held` is for assemblies whose pieces seat on each other, so leave it off when a piece is captured with running clearance (`fits.moving`, `fits.printInPlace`) and declare that pair's `clearance` instead. A quick lap answers it `unevaluated`.
 

package/docs/ERROR-PATTERNS.md

@@ -210,6 +210,12 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 - **Cause:** Something smaller than the piece's flat underside sits lower than it in the print pose — a horizontal knuckle or pin whose cylinder dips below the plate, a boss, or lettering embossed on the bottom — so exporters and slicers rest the piece on that feature and the flat face prints in mid-air.
 - **Fix:** Trim the piece flat at the bed plane (cut everything below z = 0 in its print pose), or raise or shorten the lower feature so the flat face is the lowest; size a print-in-place knuckle so its cylinder is tangent to the bed and give it a support block down to z = 0. A recess meant to clear the bed declares a lower `bedContactPct`. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Self-verification (the `verify` block)".
 
+## piece-stands-on-nothing
+
+- **Symptom:** A `footprintPct` cost from `verify` (in `verify.costs`, e.g. `0.42 not >= 10`) on a piece whose print pose rests on a point, a line or a curl — a sphere-tipped rod standing on its end, a cylinder lying on its side — while `bedContactPct` passes.
+- **Cause:** The lowest point of the piece is not a flat face, so almost none of its silhouette on the bed actually touches it (a cylinder on its side reads a few percent, under the floor): the first layer has almost nothing to bond to, and the piece tips or pulls loose unless it prints with a brim, a raft, or in a different orientation.
+- **Fix:** Lay the piece on its flat face in its print pose, add a flat foot or pad at its lowest point, or print it with a brim. When the user chose the brim, `verify.accept: ["footprint"]` records it and the cost reads accepted. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Printed parts".
+
 ## expect-static-across-presets
 
 - **Symptom:** A `verify` exact gate (`holes`, `volume`, …) fails on SOME presets only — e.g. `✗ planter holes 1  (0 != 1)` on two cases while defaults pass — and the preview looks right for every preset.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.163.1",
+  "version": "0.164.0",
   "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/lint/rules-verify.js

@@ -7,7 +7,7 @@ import { SUBPART_METRICS, VIEW_METRICS, BOUNDS_FORM, teachableMetrics, sidesSpec
 import { PROFILES, ORIENTATIONS } from "../oracle/dfm-profiles.js";
 import { parseAssertion, bareVectorHint } from "../oracle/assert-dsl.js";
 import { suggest } from "../geometry/op-options.js";
-import { PROCESS_IDS } from "../process/registry.js";
+import { PRINT_PROCESSES, PROCESS_IDS, printProcessFor } from "../process/registry.js";
 import { SHEET_DOC_ID } from "../sheet/constants.js";
 
 // Resolve `expect` to a plain object. The function form (p, d) => ({…}) is invoked
@@ -410,8 +410,41 @@ export const VERIFY_RULES = [
       const hint = safeSuggest(orientation, ORIENTATIONS);
       return [err("verify-unknown-orientation",
         `\`verify.orientation\` is ${describe(orientation)}, which is not a known orientation`,
-        `Use ${ORIENTATIONS.map((o) => `"${o}"`).join(", ")}${hint ? ` — did you mean "${hint}"?` : ""} (declares the part is laid out for its print bed, arming the profile's overhang check), or omit the key.`,
+        `Use ${ORIENTATIONS.map((o) => `"${o}"`).join(", ")}${hint ? ` — did you mean "${hint}"?` : ""} (declares that \`build()\` is the print pose: Z up, bed at the lowest Z), or omit the key.`,
         "verify.orientation")];
     },
   },
+  {
+    // `verify.accept` lists cost ids the user accepted. verify() reads it but
+    // never validates it, so a typo would be silently ignored without this rule.
+    // A process that does not resolve is verify-unknown-process's finding, not ours.
+    id: "verify-unknown-accept",
+    run: ({ part }) => {
+      const verify = part?.verify;
+      if (verify?.accept == null) return [];
+      if (!Array.isArray(verify.accept)) {
+        return [err("verify-unknown-accept",
+          `\`verify.accept\` is ${describe(verify.accept)}, not a list of cost ids`,
+          "Write `accept` as an array of cost ids, e.g. `accept: [\"supports\"]`, or omit the key.",
+          "verify.accept")];
+      }
+      // With no print process resolved, a cost can still fire (an authored expectation,
+      // an inline profile with no base), so check against every print process's ids.
+      const proc = printProcessFor(verify.process);
+      const known = proc ? Object.keys(proc.costs) : [...new Set(PRINT_PROCESSES.flatMap((d) => Object.keys(d.costs)))];
+      const out = [];
+      verify.accept.forEach((id, i) => {
+        if (typeof id === "string" && known.includes(id)) return;
+        out.push(err("verify-unknown-accept",
+          `\`verify.accept[${i}]\` is ${describe(id)}, which is not a cost ${proc ? "this process" : "any print process"} defines`,
+          !proc
+            ? `No print process is declared; the cost ids any print process knows are: ${known.join(", ")}.`
+            : known.length
+              ? `Known cost ids for this process: ${known.join(", ")}.`
+              : "This process defines no acceptable costs; remove the entry.",
+          `verify.accept[${i}]`));
+      });
+      return out;
+    },
+  },
 ];

package/src/framework/oracle/bed-contact.js

@@ -65,6 +65,59 @@ export const HOVER_FLOOR = 1;
 // The footprint slack never exceeds this (mm): well under a first layer, and under the
 // smallest hover worth reporting, so a tall piece is judged the way a short one is.
 export const MAX_BED_EPS = 0.05;
+// The silhouette raster (the footprint's denominator): the finest cell pitch (mm), and
+// the most cells along the longer side — so a large piece costs a 512×512 bitmap at most.
+const SILHOUETTE_MIN_PITCH = 0.25;
+const SILHOUETTE_CELLS = 512;
+
+// Mark one downward triangle's xy shadow on the silhouette grid: every cell whose centre
+// lies inside it. Each grid row is filled as one span — the x-range where the row's
+// centre line crosses the triangle — so the work is the cells the triangle covers plus
+// one intersection per row, never its whole bounding rectangle (a fine fan of slivers
+// over the same floor used to rescan that rectangle once per sliver). A triangle too
+// thin to contain any centre (a wall thinner than a cell) marks the cells along its
+// outline instead (sampled at half a pitch), so it is never dropped between centres.
+// Marking edge cells for EVERY triangle was tried and over-covered a 1 mm tube wall by
+// a third; centre sampling is unbiased along an edge.
+function shadow(P, a, b, c, minX, minY, pitch, gx, gy, grid, mark) {
+  const ax = P[a], ay = P[a + 1], bx = P[b], by = P[b + 1], cx = P[c], cy = P[c + 1];
+  const area2 = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+  let hit = false;
+  if (area2 !== 0) {
+    const j0 = Math.max(0, Math.floor((Math.min(ay, by, cy) - minY) / pitch));
+    const j1 = Math.min(gy - 1, Math.floor((Math.max(ay, by, cy) - minY) / pitch));
+    for (let j = j0; j <= j1; j++) {
+      const y = minY + (j + 0.5) * pitch;
+      // Where this row's centre line enters and leaves the triangle: the extreme x of its
+      // crossings with the three edges (an edge lying on the line contributes both ends).
+      let lo = Infinity, hi = -Infinity;
+      const cross = (x0, y0, x1, y1) => {
+        if (!((y0 <= y && y <= y1) || (y1 <= y && y <= y0))) return;
+        if (y0 === y1) { lo = Math.min(lo, x0, x1); hi = Math.max(hi, x0, x1); return; }
+        const x = x0 + ((y - y0) * (x1 - x0)) / (y1 - y0);
+        if (x < lo) lo = x;
+        if (x > hi) hi = x;
+      };
+      cross(ax, ay, bx, by); cross(bx, by, cx, cy); cross(cx, cy, ax, ay);
+      if (lo > hi) continue;
+      const i0 = Math.max(0, Math.ceil((lo - minX) / pitch - 0.5));
+      const i1 = Math.min(gx - 1, Math.floor((hi - minX) / pitch - 0.5));
+      for (let i = i0; i <= i1; i++) grid[j * gx + i] = 1;
+      if (i1 >= i0) hit = true;
+    }
+  }
+  if (hit) return;
+  // The fallback samples the triangle shrunk by half toward its centroid, not its own
+  // edges: a fan sliver of a disc's bottom then marks cells inside the disc, never the
+  // cells its rim crosses (which over-covered a Ø5 pin by a tenth).
+  const gxc = (ax + bx + cx) / 3, gyc = (ay + by + cy) / 3;
+  const h = ([x, y]) => [(x + gxc) / 2, (y + gyc) / 2];
+  const [pa, pb, pc] = [h([ax, ay]), h([bx, by]), h([cx, cy])];
+  for (const [x0, y0, x1, y1] of [[...pa, ...pb], [...pb, ...pc], [...pc, ...pa]]) {
+    const steps = Math.ceil(Math.hypot(x1 - x0, y1 - y0) / (pitch / 2)) + 1;
+    for (let t = 0; t <= steps; t++) mark(x0 + ((x1 - x0) * t) / steps, y0 + ((y1 - y0) * t) / steps);
+  }
+}
 
 /**
  * @param {{ positions: ArrayLike<number>, indices?: ArrayLike<number>, triangles: number }} mesh
@@ -73,38 +126,64 @@ export const MAX_BED_EPS = 0.05;
  *   scanned); `bedEps` the footprint slack (default 0.1% of the mesh height, floored at
  *   0.01 mm and capped at MAX_BED_EPS); `bedBand` the height above the bed within which a flat face hovers
  *   (default 1 mm)
- * @returns {{ pct: number, contactArea: number, hoverArea: number, gap: number|null, at: number[]|null }|null}
+ * @returns {{ pct: number, contactArea: number, hoverArea: number, downArea: number, gap: number|null, at: number[]|null, base: number[], lowestAt: number[] }|null}
  *   `pct` 0..100, the share of the near-bed flat underside on the bed; the two areas in
  *   mm²; `gap` how far above the bed the largest hovering face sits, and `at` its
- *   centroid (null when nothing hovers past the floor); null for an empty mesh.
+ *   centroid (null when nothing hovers past the floor); `downArea` the piece's
+ *   silhouette on the bed (mm²): the UNION of every downward-facing triangle's shadow,
+ *   rasterized (a closed mesh's silhouette is exactly that union, since every point of
+ *   it has a bottom-most face, which faces down), and
+ *   `lowestAt` the mesh's lowest vertex — measure.js's footprint cost, the contact area
+ *   over `downArea`, catches what `pct` cannot: a piece with almost no flat underside
+ *   at all (a sphere-tipped rod on its end) hovers nothing and reads 100. `base`, the
+ *   mesh's [dx, dy] extent, is reported but no longer divided by: a tube on its rim, a
+ *   frame or a diagonal bar fills little of its bounding box yet stands on all of its
+ *   underside. Null for an empty mesh.
  */
 export function bedContact(mesh, { bedZ, bedEps, bedBand = 1 } = {}) {
   const { positions, indices } = mesh;
   const n = indices ? indices.length : positions.length / 3;
   if (n < 3) return null;
 
-  let minZ = Infinity, maxZ = -Infinity;
-  if (bedZ === undefined || bedEps === undefined) {
-    for (let i = 2; i < positions.length; i += 3) {
-      const z = positions[i];
-      if (z < minZ) minZ = z;
-      if (z > maxZ) maxZ = z;
-    }
+  // One scan for the extents: the bed (lowest Z) and the slack's height when the caller
+  // did not hand them in, and always the posed base (its xy extent, reported) and the
+  // lowest vertex (where the footprint cost is located).
+  let minZ = Infinity, maxZ = -Infinity, minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, low = 0;
+  for (let i = 0; i + 2 < positions.length; i += 3) {
+    const x = positions[i], y = positions[i + 1], z = positions[i + 2];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+    if (z < minZ) { minZ = z; low = i; }
+    if (z > maxZ) maxZ = z;
   }
+  const base = [maxX - minX, maxY - minY];
+  const lowestAt = [positions[low], positions[low + 1], positions[low + 2]];
   const bed = bedZ ?? minZ;
   const eps = bedEps ?? Math.min(MAX_BED_EPS, Math.max(0.01, 1e-3 * (maxZ - minZ)));
   const bandTop = bed + bedBand;
+  // The silhouette raster: an xy grid over the base, at most ~512 cells a side.
+  const pitch = Math.max(SILHOUETTE_MIN_PITCH, Math.max(base[0], base[1]) / SILHOUETTE_CELLS);
+  const gx = Math.max(1, Math.ceil(base[0] / pitch) + 1), gy = Math.max(1, Math.ceil(base[1] / pitch) + 1);
+  const grid = new Uint8Array(gx * gy);
+  const mark = (x, y) => {
+    const i = Math.min(gx - 1, Math.max(0, Math.floor((x - minX) / pitch)));
+    const j = Math.min(gy - 1, Math.max(0, Math.floor((y - minY) / pitch)));
+    grid[j * gx + i] = 1;
+  };
 
   let contactArea = 0, hoverArea = 0, largest = 0, gap = null, at = null;
   for (let i = 0; i < n; i += 3) {
     const a = (indices ? indices[i] : i) * 3, b = (indices ? indices[i + 1] : i + 1) * 3, c = (indices ? indices[i + 2] : i + 2) * 3;
     const az = positions[a + 2], bz = positions[b + 2], cz = positions[c + 2];
     const cenZ = (az + bz + cz) / 3;
-    if (cenZ > bandTop) continue;                                             // above the band: not the underside
     const ux = positions[b] - positions[a], uy = positions[b + 1] - positions[a + 1], uz = bz - az;
     const vx = positions[c] - positions[a], vy = positions[c + 1] - positions[a + 1], vz = cz - az;
     const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
     if (nz >= 0) continue;                                                    // not facing down
+    shadow(positions, a, b, c, minX, minY, pitch, gx, gy, grid, mark);        // its shadow joins the silhouette
+    if (cenZ > bandTop) continue;                                             // above the band: not the underside
     const len = Math.hypot(nx, ny, nz);
     if (len < 1e-9) continue;                                                 // degenerate: no normal
     const triArea = len / 2;
@@ -122,6 +201,9 @@ export function bedContact(mesh, { bedZ, bedEps, bedBand = 1 } = {}) {
             cenZ];
     }
   }
-  if (hoverArea < HOVER_FLOOR) return { pct: 100, contactArea, hoverArea, gap: null, at: null };
-  return { pct: (100 * contactArea) / (contactArea + hoverArea), contactArea, hoverArea, gap, at };
+  let cells = 0;
+  for (let i = 0; i < grid.length; i++) cells += grid[i];
+  const downArea = cells * pitch * pitch;
+  if (hoverArea < HOVER_FLOOR) return { pct: 100, contactArea, hoverArea, downArea, gap: null, at: null, base, lowestAt };
+  return { pct: (100 * contactArea) / (contactArea + hoverArea), contactArea, hoverArea, downArea, gap, at, base, lowestAt };
 }