partforge 0.163.1 → 0.164.1

package/src/framework/process/fdm/descriptor.js

@@ -0,0 +1,48 @@
+// Reusable design-for-manufacturing process profiles — a manufacturing technique
+// as DATA: which checks apply and at what thresholds. `bed` is the build volume
+// [x,y,z] in mm (a hard bbox-fit gate); `minWall` mm (a warn); `overhang` is the
+// steepest unsupported face the process prints cleanly, in degrees from vertical
+// (a cost — supports — armed by the profile alone, see overhangAngleFor; resin
+// prints on supports, so it carries none); `bedContact` is the least share (%) of a printed
+// piece's near-bed flat underside that must rest on the bed (a GATE, armed by the
+// profile alone — see bedContactFor; resin prints on supports, so it carries none);
+// `clearance` mm is carried for a future gap check (not enforced yet).
+//
+// `fits`, `holeUndersize` and `bridge` are the numbers an author (or the cloud
+// agent) copies into derive() for a mating feature; nothing in this repo reads
+// them yet. They are guide defaults from the FDM design guides, not measurements:
+// a calibrated printer overrides them through an inline `{ base, fits: {...} }`
+// profile, which REPLACES the fits table whole. `fits` are diametral offsets in
+// mm (negative = interference): press (a pin that never comes out), push (a cap
+// pressed on by hand), slip (a lid that lifts off), moving (a hinge pin or axle),
+// printInPlace (parts printed already assembled). `holeUndersize` is added to a
+// horizontal bore's diameter, since the top of a printed arch sags inward.
+// `bridge` is the longest flat span the process prints unsupported; resin prints
+// on supports, so it carries none.
+//
+// `footprint` is the percent of a printed piece's posed base area resting on the
+// bed below which the footprint cost fires.
+//
+// Import-free, like every process descriptor: lint and the oracle read it through
+// process/registry.js.
+export const FDM = {
+  id: "fdm",
+  label: "FDM 3D printing",
+  stock: "filament",
+  docId: "printed-parts",
+  profiles: {
+    "fdm-pla": {
+      bed: [220, 220, 250], minWall: 1.2, clearance: 0.2, overhang: 45, bedContact: 50, footprint: 10,
+      fits: { press: -0.1, push: 0.05, slip: 0.25, moving: 0.35, printInPlace: 0.45 },
+      holeUndersize: 0.25, bridge: 10,
+    },
+    "fdm-petg": {
+      bed: [220, 220, 250], minWall: 1.5, clearance: 0.3, overhang: 45, bedContact: 50, footprint: 10,
+      fits: { press: -0.1, push: 0.05, slip: 0.3, moving: 0.4, printInPlace: 0.5 },
+      holeUndersize: 0.3, bridge: 10,
+    },
+  },
+  costs: { supports: "overhangArea", footprint: "footprintPct" },
+  metrics: {},
+  lintRules: [],
+};

package/src/framework/process/registry.js

@@ -7,6 +7,8 @@
 import { isSheetPart } from "../sheet/constants.js";
 import { LASER } from "./laser/descriptor.js";
 import { ROUTER } from "./cnc-router/descriptor.js";
+import { FDM } from "./fdm/descriptor.js";
+import { RESIN } from "./resin/descriptor.js";
 
 export const PROCESSES = [LASER, ROUTER];
 export const PROCESS_IDS = PROCESSES.map((d) => d.id);
@@ -23,3 +25,31 @@ export const SHEET_METRICS = Object.assign({}, ...PROCESSES.map((d) => d.metrics
 
 // Every process's own lint rules; lint/rules-sheet.js appends them to SHEET_RULES.
 export const PROCESS_LINT_RULES = PROCESSES.flatMap((d) => d.lintRules);
+
+// Print processes are their own list: PROCESSES stays the SHEET list (exporters,
+// destinations, SHEET_METRICS and sheet/part.js's PROCESS_IDS check all read it), so
+// fdm and resin never pass as a sheet part's process.
+export const PRINT_PROCESSES = [FDM, RESIN];
+export const PRINT_PROCESS_IDS = PRINT_PROCESSES.map((d) => d.id);
+export const ALL_PROCESSES = [...PROCESSES, ...PRINT_PROCESSES];
+
+export const printProcessById = (id) => PRINT_PROCESSES.find((d) => d.id === id) ?? null;
+
+// The DFM profiles of every print process as one map, keyed by profile id.
+export const PRINT_PROFILES = Object.freeze(Object.assign({}, ...PRINT_PROCESSES.map((d) => d.profiles)));
+
+// The print process owning a profile spec: a profile id, or an inline object whose
+// `base` (recursively) names one. Anything else is null.
+export function printProcessFor(spec) {
+  let id = spec;
+  // A cyclic inline profile (`p.base = p`) is malformed, not a loop to follow: lint calls
+  // this on user-authored parts, and a hang there takes the editor with it.
+  const seen = new Set();
+  while (id && typeof id === "object") {
+    if (seen.has(id)) return null;
+    seen.add(id);
+    id = id.base;
+  }
+  if (typeof id !== "string") return null;
+  return PRINT_PROCESSES.find((d) => Object.hasOwn(d.profiles, id)) ?? null;
+}

package/src/framework/process/resin/descriptor.js

@@ -0,0 +1,19 @@
+// Resin printing as DATA: see process/fdm/descriptor.js for what each profile field
+// means. Resin prints on supports, so it carries no overhang, bedContact, footprint
+// or bridge, and no costs. Import-free, like every process descriptor.
+export const RESIN = {
+  id: "resin",
+  label: "Resin 3D printing",
+  stock: "resin",
+  docId: "printed-parts",
+  profiles: {
+    "resin": {
+      bed: [120, 68, 160], minWall: 0.6, clearance: 0.1,
+      fits: { press: -0.05, push: 0.05, slip: 0.1, moving: 0.15, printInPlace: 0.2 },
+      holeUndersize: 0.05,
+    },
+  },
+  costs: {},
+  metrics: {},
+  lintRules: [],
+};

package/src/framework/verify-metrics.js

@@ -100,12 +100,14 @@ export const SUBPART_METRICS = {
         ? `no reading from the ${sampled} of ${total} triangles sampled — not a clean bill of health; a thin spot may exist between samples`
         : `sampled ${sampled} of ${total} triangles — an upper bound; a thinner spot may exist between samples`;
     } },
-  // Unsupported downward-facing area (oracle/overhang.js), in mm². Measured only
-  // for a part that declares `verify.orientation: "print"` under a profile with
-  // an `overhang` angle; elsewhere `extract` returns null and check() skips it.
-  // A warning, never a gate: a bridge reads as a ceiling and cannot be told apart.
-  overhangArea: { kind: "warn", extract: (s) => s.overhangArea,
-    hint: "unsupported downward-facing surface at the reported location — reorient the part so the face is vertical or on the bed, chamfer it to the process's overhang angle, split it into a bridged or supported feature, or accept supports",
+  // Unsupported downward-facing area (oracle/overhang.js), in mm². Measured for a
+  // part whose print process carries an `overhang` angle (the process alone arms it)
+  // or that asserts it; elsewhere `extract` returns null and check() skips it.
+  // A cost, never a gate or a warning: needing supports is a design choice with a
+  // price (a bridge reads as a ceiling and cannot be told apart), so it is listed
+  // under `costs` and the user may accept it (`verify.accept: ["supports"]`).
+  overhangArea: { kind: "cost", costId: "supports", extract: (s) => s.overhangArea,
+    hint: "unsupported downward-facing surface at the reported location — reorient the part so the face is vertical or on the bed, chamfer it to the process's overhang angle, split it into a bridged or supported feature; when the user chooses supports instead, record it with verify.accept: [\"supports\"]",
     locate: (s) => s.overhangAt,
     note: (s) => (s.overhangAngle != null ? `steepest unsupported face ${s.overhangAngle.toFixed(1)}° from vertical` : null) },
   // How much of a printed piece's near-bed flat underside rests on the bed
@@ -121,6 +123,15 @@ export const SUBPART_METRICS = {
     note: (s) => (s.bedHoverGap != null
       ? `${s.bedHoverArea.toFixed(1)} mm² of flat underside sits ${s.bedHoverGap.toFixed(2)} mm above the bed; ${s.bedContactArea.toFixed(1)} mm² touches it`
       : null) },
+  // The footprint (measure.js, from bed contact's pass): the flat contact area over the
+  // piece's silhouette on the bed, in percent. Measured where bed contact is, plus where the
+  // profile carries `footprint` or the author declares it. A COST, like overhangArea: a
+  // piece on a point or a line prints with a brim or a raft, which the user may choose
+  // (`accept: ["footprint"]`); bedContactPct passes such a piece, since nothing hovers.
+  footprintPct: { kind: "cost", costId: "footprint", extract: (s) => s.footprintPct,
+    hint: "the share of this piece's silhouette on the bed (its outline in the print pose) that actually touches it is small — it stands on a point, a line or a curve, which reads near zero, so the first layer has almost nothing to hold on to and the piece can tip or pull loose. Lay it on its flat face, add a flat foot or pad at its lowest point, or print it with a brim (accept: [\"footprint\"] records that choice)",
+    pattern: "piece-stands-on-nothing",
+    locate: (s) => s.footprintAt },
   // `s.deviation` (measure.js) exists only for a sub-part declaring `reference:
   // "<import name>"`; on every other sub-part `extract` returns null, which
   // `check()` already reports as status "skip" rather than a fail — the

package/types/part.d.ts

@@ -484,9 +484,9 @@ export interface DfmProfile {
   minWall?: number;
   /**
    * Steepest unsupported face the process prints cleanly, in degrees from
-   * vertical (45 on the FDM profiles; absent on resin). Checked only for a part
-   * that also declares `verify.orientation: "print"`; `null` switches it off
-   * under a named base. A warning, never a gate.
+   * vertical (45 on the FDM profiles; absent on resin). The print process alone
+   * arms the check; `null` switches it off under a named base. Reported as a
+   * cost (needing supports), never a failure.
    */
   overhang?: number | null;
   /**
@@ -495,6 +495,8 @@ export interface DfmProfile {
    * profile alone; `null` switches it off under a named base.
    */
   bedContact?: number | null;
+  /** Percent of a printed piece's posed base area resting on the bed below which the footprint cost fires. */
+  footprint?: number | null;
   /** Carried for a future gap check; not enforced yet. */
   clearance?: number;
   /**
@@ -562,8 +564,8 @@ export interface SubPartExpectations {
   wall?: Expectation;
   /**
    * Unsupported downward-facing surface in mm² (faces steeper than the profile's
-   * `overhang` angle, bed at the sub-part's own lowest Z). Measured only under
-   * `verify.orientation: "print"`; a warning, never a gate.
+   * `overhang` angle, bed at the sub-part's own lowest Z). Armed by the print
+   * process alone; reported as a cost (`verify.costs`), never a failure.
    */
   overhangArea?: Expectation;
   /**
@@ -572,6 +574,13 @@ export interface SubPartExpectations {
    * Under an FDM profile every printed sub-part gets `>=50` by default; a gate.
    */
   bedContactPct?: Expectation;
+  /**
+   * Share (0–100) of the sub-part's posed base area (its xy extent in the print pose)
+   * whose flat underside touches the bed — near 0 for a piece standing on a point, a
+   * line or a curl. Under an FDM profile every printed sub-part gets `>=5`; reported as
+   * a cost (`verify.costs`), never a failure; `accept: ["footprint"]` records a brim.
+   */
+  footprintPct?: Expectation;
   /** Symmetric-difference volume vs. the sub-part's declared `reference` import. */
   refXorVolume?: Expectation;
   /** Percent volume delta vs. the sub-part's declared `reference` import. */
@@ -640,12 +649,17 @@ export interface VerifyBlock<P = ResolvedParams, D = Derived> {
   /** A named DFM profile or an inline one. */
   process?: DfmProfileName | DfmProfile;
   /**
-   * `"print"` declares the part is laid out for its bed — Z up, each sub-part's
-   * bed at its own lowest Z — which is the only way the profile's `overhang`
-   * check is armed. Omit it while a part is still being shaped or is bound for
-   * another process.
+   * `"print"` declares that `build()` is the print pose — Z up, each sub-part's
+   * bed at its own lowest Z. It does not arm any check; the print process does.
    */
   orientation?: "print";
+  /**
+   * Costs the user accepted, by id. An accepted cost is still measured and
+   * reported (`accepted: true`), but no longer raised as something to fix. Only the
+   * process's own default check is marked accepted: a limit you wrote in `expect`
+   * (`overhangArea: "<=500"`) keeps its meaning and is never marked accepted.
+   */
+  accept?: ("supports" | "footprint")[];
   /** Which cases to check; default is `"defaults"` plus every preset name. */
   cases?: string[];
   /**

package/types/testing.d.ts

@@ -433,6 +433,14 @@ export interface SubPartFacts {
   bedHoverGap: number | null;
   /** Centroid of the largest hovering face; `null` when nothing hovers. */
   bedHoverAt: number[] | null;
+  /**
+   * Share (0–100) of the piece's silhouette on the bed (its outline seen from below, in
+   * the print pose) that actually touches it — the footprint cost's reading, from the
+   * bed-contact pass; `null` when that pass did not run or the silhouette is empty.
+   */
+  footprintPct: number | null;
+  /** The piece's lowest point, in display coordinates; `null` when not checked. */
+  footprintAt: number[] | null;
   /**
    * Present only when bed contact had to be read off the piece's export build (its
    * print pose could not be read from place() alone) and that build failed.
@@ -521,6 +529,8 @@ export interface MeasureReport {
   measuredOverhang: number | null;
   /** Whether the bed-contact pass ran (the part is checked for it). */
   measuredBedContact: boolean;
+  /** Whether the footprint was read — the same pass, so always `measuredBedContact`. */
+  measuredFootprint: boolean;
   /**
    * Present only in a view holding a sheet part: whether the printed sub-parts' print
    * (export) poses were built for `printBbox`.
@@ -595,7 +605,7 @@ export function measure(
 
 // --- verify -----------------------------------------------------------------
 
-export type CheckStatus = "pass" | "fail" | "warn" | "skip";
+export type CheckStatus = "pass" | "fail" | "warn" | "cost" | "skip";
 
 export interface VerifyCheck {
   /** `"part"` is the vacuous-verify notice; `"case"` the quick-lap "not measured" marker. */
@@ -603,8 +613,10 @@ export interface VerifyCheck {
   /** The sub-part name, `"a×b"` for a pair check, or `null` for a scalar view metric. */
   subpart: string | null;
   metric: string;
-  /** `gate` failures set a non-zero exit code; `warn` never blocks. */
-  kind: "gate" | "warn";
+  /** `gate` failures set a non-zero exit code; `warn` never blocks; `cost` is a design choice with a price. */
+  kind: "gate" | "warn" | "cost";
+  /** On a `cost` check: whether the user listed its id in `verify.accept`. */
+  accepted?: boolean;
   /** The asserted expression, stringified. */
   expr: string;
   actual: unknown;
@@ -651,6 +663,8 @@ export interface VerifyReport {
   /** Every failing check, flattened, each tagged with its `case`. */
   failures: Array<VerifyCheck & { case: string }>;
   warnings: Array<VerifyCheck & { case: string }>;
+  /** Design choices with a price (supports, footprint); never failures. Accepted ones are flagged. */
+  costs: Array<VerifyCheck & { case: string }>;
   /** Checks a quick lap could not evaluate. */
   unevaluated: Array<VerifyCheck & { case: string }>;
   /** Check instances the part or its profile declared, across cases (near-miss notices excluded). */