partforge 0.133.3 → 0.135.0

package/src/framework/sheet/part.js

@@ -9,6 +9,11 @@
 // `sp.sheet.generatedBuild` is the build made here; an author who replaces `build`
 // afterwards is detectable as `sp.build !== sp.sheet.generatedBuild`.
 //
+// Likewise `sp.sheet.generatedPlace` is the place made here (the pose, then the author's
+// own) and `sp.sheet.place` the author's own place, or null: the realistic look
+// (materials/sheet-look.js) trusts a sheet's canonical frame only with no author place
+// and `sp.place === sp.sheet.generatedPlace`.
+//
 // Placement (decision 10): the pose applies for display AND export, then the author's
 // own `place` — so STEP/3MF/STL files of a sheet forge come out assembled.
 import { RENAMED_KEYS, RESERVED_KEYS, SHEET_KEYS, SUBPART_PASSTHROUGH_KEYS } from "./constants.js";
@@ -67,32 +72,42 @@ export function sheetPart(spec) {
     const s = resolveSheet(k, sub, p, d);
     return (processById(s.process).preview ?? sheetPreview)(k, s);
   };
+
+  // Placement (decision 10): the pose applies for display AND export, then the author's own
+  // place. Made BEFORE the record is frozen, so the record can name it. Everything the
+  // place reads is taken NOW, into the same values the record freezes — never read off
+  // `spec` later, which an author may reuse and change for the next panel: the build and
+  // the burn's frame both read the frozen record, and a place that read the spec live would
+  // move the panel away from them.
+  const pose = spec.pose ?? null;
+  const thickness = spec.thickness;
+  const authorPlace = spec.place ?? null;
+  const generatedPlace = pose !== null || authorPlace ? (solid, ctx) => {
+    const resolved = typeof pose === "function" ? pose(ctx.p, ctx.d) : pose;
+    let posed = solid;
+    if (resolved !== null) {
+      const reason = validatePose(resolved);
+      if (reason) throw new Error(`sheet pose: ${reason}`);
+      const t = typeof thickness === "function" ? thickness(ctx.p, ctx.d) : thickness;
+      posed = applyPose(solid, resolved, t);
+    }
+    return authorPlace ? authorPlace(posed, ctx) : posed;
+  } : null;
+
   const sheet = Object.freeze({
     process,
     material: spec.material,
-    thickness: spec.thickness,
+    thickness,
     profile: spec.profile,
     score: spec.score ?? null,
     engrave: spec.engrave ?? null,
-    pose: spec.pose ?? null,
+    pose,
+    place: authorPlace,
     generatedBuild,
+    generatedPlace,
   });
   sub.build = generatedBuild;
-
-  const authorPlace = spec.place;
-  if (sheet.pose !== null || authorPlace) {
-    sub.place = (solid, ctx) => {
-      const pose = typeof sheet.pose === "function" ? sheet.pose(ctx.p, ctx.d) : sheet.pose;
-      let posed = solid;
-      if (pose !== null) {
-        const reason = validatePose(pose);
-        if (reason) throw new Error(`sheet pose: ${reason}`);
-        const t = typeof sheet.thickness === "function" ? sheet.thickness(ctx.p, ctx.d) : sheet.thickness;
-        posed = applyPose(solid, pose, t);
-      }
-      return authorPlace ? authorPlace(posed, ctx) : posed;
-    };
-  }
+  if (generatedPlace) sub.place = generatedPlace;
   sub.sheet = sheet;
   return sub;
 }

package/src/framework/viewer.js

@@ -12,6 +12,7 @@ import { ensureBoxUVs } from "./materials/uv.js";
 import { loadEnvironmentRig } from "./materials/environment.js";
 import { assetUrl } from "./materials/assets.js";
 import { resolveEnvironmentId } from "./materials/resolve.js";
+import { burnsFor, realisticDisplay } from "./materials/sheet-look.js";
 import { neutralToneMapToSrgb8 } from "./materials/tonemap-readback.js";
 import { createCutaway } from "./cutaway.js";
 import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
@@ -591,9 +592,11 @@ export function createViewer(container, part) {
   const textureCache = new Map();    // asset file name -> Texture
   const textureLoader = new THREE.TextureLoader();
   let pmrem = null;
-  let printFrames = {};
-  let printFrameSource = null;       // () => frames; mount's lazy provider (setPrintFrameSource)
-  let printFramesStale = false;      // the source has frames the materials have not seen
+  let printFrames = {};              // name -> mat4 array: layer lines' display → export map
+  let sheetFrames = {};              // name -> { frame, t, plies }: a burning sheet's canonical frame (sheet-look.js)
+  let frameSource = null;            // () => { print, sheet }; mount's lazy provider (setFrameSource)
+  let framesStale = false;           // the source has frames the materials have not seen
+  const IDENTITY_MAT4 = new THREE.Matrix4().toArray();
   const modeListeners = new Set();
   const envListeners = new Set();
   const SHADOW_LOWRES_MS = 100;      // at most one low-res shadow per this, while a part moves
@@ -728,9 +731,14 @@ export function createViewer(container, part) {
   function physicalFor(name) {
     let m = physicalMats.get(name);
     if (!m) {
-      m = cloneKeepsPattern(buildPhysicalMaterial(part.parts[name].display, { printFrame: printFrames[name], loadTexture }));
+      const sp = part.parts[name];
+      // `burn` is decided once per sub-part (sheet-look.js burnsFor): only a laser sheet in
+      // a wood compiles the burn pass, so every other program is exactly what it was.
+      // realisticDisplay: a laser sheet with no material draws as its stock (sheet-look.js).
+      m = cloneKeepsPattern(buildPhysicalMaterial(realisticDisplay(sp), { printFrame: printFrames[name], burn: burnsFor(sp), loadTexture }));
       physicalMats.set(name, m);
       syncGrain(name);
+      applySheetFrame(m, sheetFrames[name]);
     }
     return m;
   }
@@ -859,7 +867,7 @@ export function createViewer(container, part) {
   // ground only moves on showAssembly, never because a capture happened.
   function enterRealistic(rig, { live = true, reground = true } = {}) {
     try {
-      syncPrintFrames(); // before the swap: the first realistic frame has the export-pose layers
+      syncFrames(); // before the swap: the first realistic frame has the export-pose layers and the sheets' burns
       renderMode = "realistic";
       // A regen can land between the proxy compile and here, while the mode
       // was still CAD, so setSubGeometry skipped the UVs. Idempotent.
@@ -929,7 +937,7 @@ export function createViewer(container, part) {
   // target bound — each only for the synchronous compile() inside
   // compileAsync, so the view on screen is untouched while it waits.
   function compileRealistic(rig, { forCapture = false } = {}) {
-    syncPrintFrames();
+    syncFrames();
     const proxy = new THREE.Scene();
     proxy.environment = rig.envMap;
     for (const n of names) {
@@ -1030,30 +1038,45 @@ export function createViewer(container, part) {
     for (const [n, m] of physicalMats) m.userData.patternUniforms?.pfPrintFrame.value.fromArray(printFrames[n] ?? identity);
   }
 
-  // The lazy form mount uses. Computing a frame runs the sub-part's pose probe
-  // (two geometry-free builds for a placed sub-part), and every sub-part with
-  // no material draws layer lines, so frames are PULLED only when something is
-  // about to draw the realistic look: the live view (or a switch loading),
-  // and any capture that borrows it — compileRealistic and enterRealistic are
-  // the two doors every such path goes through. A delivery just marks them
-  // stale (invalidatePrintFrames); in CAD nothing is computed.
-  function setPrintFrameSource(source) {
-    printFrameSource = typeof source === "function" ? source : null;
-    invalidatePrintFrames();
-  }
-  function invalidatePrintFrames() {
-    printFramesStale = true;
-    if (renderMode === "realistic" || realisticPending) syncPrintFrames();
-  }
-  function syncPrintFrames() {
-    if (!printFrameSource || !printFramesStale) return;
-    printFramesStale = false;
+  // A burning sheet's canonical frame (sheet-look.js sheetFrameFor). No frame — not yet
+  // delivered, or not computable at these params — is pfSheetT = 0: plain wood.
+  function applySheetFrame(m, f) {
+    const u = m.userData.patternUniforms;
+    if (!u?.pfSheetFrame) return;
+    u.pfSheetFrame.value.fromArray(f?.frame ?? IDENTITY_MAT4);
+    u.pfSheetT.value = f?.t ?? 0;
+    u.pfPlies.value = f?.plies ?? 0;
+  }
+  function setSheetFrames(frames) {
+    sheetFrames = frames ?? {};
+    for (const [n, m] of physicalMats) applySheetFrame(m, sheetFrames[n]);
+  }
+
+  // The lazy form mount uses. Frames are PULLED only when something is about to draw the
+  // realistic look: the live view (or a switch loading), and any capture that borrows it —
+  // compileRealistic and enterRealistic are the two doors every such path goes through. A
+  // delivery just marks them stale (invalidateFrames); in CAD nothing is computed. One
+  // source carries both kinds: `print` (layer lines; a placed sub-part's costs two
+  // geometry-free probe builds, and every sub-part with no material draws layer lines) and
+  // `sheet` (a burning sheet's canonical frame, from data).
+  function setFrameSource(source) {
+    frameSource = typeof source === "function" ? source : null;
+    invalidateFrames();
+  }
+  function invalidateFrames() {
+    framesStale = true;
+    if (renderMode === "realistic" || realisticPending) syncFrames();
+  }
+  function syncFrames() {
+    if (!frameSource || !framesStale) return;
+    framesStale = false;
     let frames;
-    try { frames = printFrameSource(); } catch (e) {
-      console.warn("partforge: computing print frames failed", e);
+    try { frames = frameSource(); } catch (e) {
+      console.warn("partforge: computing material frames failed", e);
       return;
     }
-    setPrintFrames(frames);
+    setPrintFrames(frames?.print);
+    setSheetFrames(frames?.sheet);
   }
 
   // Resolves once the current environment's rig is loaded (captures wait on it).
@@ -2735,8 +2758,9 @@ export function createViewer(container, part) {
     isRealisticPending: () => realisticPending,
     onEnvironmentChange: (cb) => { envListeners.add(cb); return () => envListeners.delete(cb); },
     setPrintFrames,
-    setPrintFrameSource,
-    invalidatePrintFrames,
+    setSheetFrames,
+    setFrameSource,
+    invalidateFrames,
     whenRealisticReady,
     dispose,
   }, () => requestRender(API_GRACE_MS));

package/src/index.js

@@ -4,3 +4,7 @@
 // Part build functions import geometry helpers from "partforge/geometry" instead.
 export { mount } from "./framework/index.js";
 export { viewSubParts } from "./framework/part-model.js";
+// The cut & print kit's options surface, for a host that draws its own options screen
+// (partforge-cloud's coupling test reads KIT_OPTIONS_ERROR from here). export/formats.js
+// is import-free, so this adds nothing to the app bundle but a few constants.
+export { EXPORT_FORMATS, KIT_OPTIONS_ERROR, KIT_DEFAULTS, validateKitOptions } from "./framework/export/formats.js";

package/src/parts/laser-box.js

@@ -42,7 +42,7 @@ const hingeSlots = (k, p, d, pose, z) => d.hingeX.flatMap((hx) =>
   [hx - HINGE.tongueX, hx + HINGE.tongueX].map((x) =>
     k.shape2d(tab(p).slot).translate(worldToSheet(pose, [x, p.depth / 2, z]))));
 
-const PLY = { views: ["box"], display: { material: "oak" }, material: "birch plywood", thickness: (p) => p.t };
+const PLY = { views: ["box"], display: { material: "plywood" }, material: "birch plywood", thickness: (p) => p.t };
 const panel = (name, label, extra = {}) => sheetPart({
   ...PLY, label,
   profile: (k, p, d) => d.box[name].outline,       // drawn as seen from outside

package/src/parts/material-swatches.js

@@ -1,7 +1,10 @@
 // Dev-only contact sheet for the material library: one 30 mm sample per preset,
 // laid out in a grid, so a change to a preset or the pattern shader can be
-// judged by eye in every environment (materials.html). Not a reference part.
+// judged by eye in every environment (materials.html). The "Laser-cut" views
+// (below) do the same for the laser burn. Not a reference part.
 import { PRESETS } from "../framework/materials/presets.js";
+import { sheetPart } from "../framework/sheet/part.js";
+import { sheetHole } from "../framework/sheet/joinery.js";
 
 const ids = Object.keys(PRESETS);
 const COLS = 6, PITCH = 40;
@@ -19,10 +22,59 @@ const FILAMENT_COLOURS = [
 const withHole = (k) =>
   k.box({ size: [30, 30, 12] }).fillet({ r: 3 }).cut(k.cylinder({ r: 5, h: 20 }).translate([0, 0, -4]));
 
+// The "Laser-cut" view: sheet swatches as the laser burn draws them — each 30 × 30 with a
+// cut hole, an engraved label (its thickness) and a score line — in every wood at 3, 6 and
+// 9 mm; one oak panel standing on edge (posed, so its frame is not the identity); and the
+// looks that must NOT burn: a clear-acrylic sheet and an oak block that is not a sheet part.
+// "Laser-cut, unburnt" is its twin: the same swatches with an identity author `place`,
+// which shows plain wood (materials/sheet-look.js) — same geometry, same place, same
+// material — so the two views differ ONLY by the burn and scripts/capture-contact-sheet.mjs
+// can diff them pixel for pixel — and one row of sheets that name no material, drawn as
+// their stock (sheet-look.js STOCK_LOOKS).
+const SW = 30;
+const WOODS = ["plywood", "oak", "walnut"];
+const CONTROLS_Y = -WOODS.length * PITCH;
+const LASER_SWATCHES = [
+  ...WOODS.flatMap((material, row) => [3, 6, 9].map((t, col) => ({
+    key: `${material}_${t}`, label: `${PRESETS[material].label}, ${t} mm`, at: [col * PITCH, -row * PITCH], t, display: { material },
+  }))),
+  { key: "acrylic_3", label: "Clear acrylic, 3 mm", at: [0, CONTROLS_Y], t: 3, display: { material: "clear-acrylic" }, stock: "clear acrylic" },
+  { key: "oak_standing", label: "Oak, 3 mm, standing", at: [PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, standing: true },
+  { key: "oak_block", label: "Oak block (not a sheet part)", at: [2 * PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, block: true },
+  { key: "stock_plywood", label: "No material, \"birch plywood\" stock", at: [0, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood" },
+  { key: "stock_acrylic", label: "No material, \"clear acrylic\" stock", at: [PITCH, CONTROLS_Y - PITCH], t: 3, stock: "clear acrylic" },
+  { key: "stock_stained", label: "A bare colour on \"birch plywood\" stock", at: [2 * PITCH, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood", display: { color: 0x2e8b3d } },
+];
+
+function laserSwatch(s, unburnt) {
+  const [x, y] = s.at;
+  const common = {
+    label: unburnt ? `${s.label} (unburnt)` : s.label,
+    views: [unburnt ? "unburnt" : "laser"],
+    ...(s.display ? { display: s.display } : {}),
+  };
+  if (s.block) {
+    return { ...common, build: (k) => k.box({ min: [x, y, 0], max: [x + SW, y + SW, s.t] })
+      .cut(k.cylinder({ d: 8, h: s.t + 2 }).translate([x + 21, y + 21, -1])) };
+  }
+  // A standing swatch is drawn at the drawing origin; its pose stands it on edge at `at`.
+  const [u, v] = s.standing ? [0, 0] : [x, y];
+  return sheetPart({
+    ...common,
+    material: s.stock ?? "birch plywood",
+    thickness: s.t,
+    profile: (k) => k.shape2d([[u, v], [u + SW, v], [u + SW, v + SW], [u, v + SW]]).cut(sheetHole({ d: 8, at: [u + 21, v + 21] })),
+    engrave: (k) => k.text2d(String(s.t), { size: 10, align: "center", valign: "middle" }).translate([u + 9, v + 20]),
+    score: () => [[[u + 3, v + 7], [u + SW - 3, v + 7]]],
+    ...(s.standing ? { pose: { face: "-Y", up: "+Z", at: [x, y, 0] } } : {}),
+    ...(unburnt ? { place: (solid) => solid } : {}),
+  });
+}
+
 export default {
   meta: { title: "Material swatches", units: "mm", environment: "studio" },
   defaults: {},
-  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" } },
+  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" }, laser: { label: "Laser-cut" }, unburnt: { label: "Laser-cut, unburnt" } },
   parts: {
     ...Object.fromEntries(ids.map((id, i) => [id.replaceAll("-", "_"), {
       label: PRESETS[id].label,
@@ -65,5 +117,9 @@ export default {
       build: (k) => k.box({ size: [30, 12, 40] }).translate([50, 0, 0]),
       display: { material: "pla-print", color: 0xe0592a },
     },
+    ...Object.fromEntries(LASER_SWATCHES.flatMap((s) => [
+      [`laser_${s.key}`, laserSwatch(s, false)],
+      [`unburnt_${s.key}`, laserSwatch(s, true)],
+    ])),
   },
 };

package/types/index.d.ts

@@ -25,8 +25,49 @@ export type HostRailLayout =
   | { mode: "overlay" }
   | null;
 
-/** An export file format. STEP is routed to OCCT automatically. */
-export type ExportFormat = "stl" | "step" | "3mf";
+/** An export file format. STEP is routed to OCCT automatically; `"bundle"` is the cut & print kit (a ZIP). */
+export type ExportFormat = "stl" | "step" | "3mf" | "bundle";
+
+/** One entry of `runtime.listExportFormats()` / `EXPORT_FORMATS`. `needsSheet` marks a format that needs a sheet part checked. */
+export interface ExportFormatInfo {
+  id: ExportFormat;
+  label: string;
+  ext: string;
+  mime: string;
+  needsSheet: boolean;
+}
+
+/** A sheet part's stock, as `listExportableParts()` reports it. `group` is the kit's stock-group key, e.g. `"birch plywood|3.00"`. */
+export interface ExportableSheetInfo {
+  process: string;
+  material: string;
+  thickness: number;
+  group: string;
+}
+
+/**
+ * The cut & print kit's download options — `exportParts({ format: "bundle", options })`.
+ * Every key is optional; `validateKitOptions` fills the defaults and throws an error
+ * starting `"cut kit options:"` for anything it cannot honour.
+ */
+export interface KitOptions {
+  /** `"own-laser"` (default): SVG, laid out on sheets. `"service"`: DXF, one cut-only file per piece. */
+  destination?: "own-laser" | "service";
+  /** Derived from `destination`; when given it must match. */
+  cutFormat?: "svg" | "dxf";
+  /** mm, 0–0.5: the cut lines move out by half of it. Default 0 (nominal geometry). */
+  kerf?: number;
+  colors?: "lightburn";
+  /** Sheet size in mm per stock group; `"*"` is an explicit default. `null` (default) is 300 × 300 mm for every group. */
+  stock?: Array<{ group: string; size: [number, number] }> | null;
+  /** mm, 0–50. Default 5. */
+  margin?: number;
+  /** mm, 1–50. Default 3. */
+  spacing?: number;
+  printFormat?: "stl" | "3mf";
+  /** Whole number, 1–20. Default 1. */
+  sets?: number;
+}
 
 /**
  * A semantic click result: which sub-part was hit, where (in the sub-part's own
@@ -346,9 +387,11 @@ export interface ExportPartsOptions {
   /** Sub-part names, as `listExportableParts()` reports them. */
   parts: string[];
   format: ExportFormat;
-  /** Mesh quality for STL/3MF. Defaults to `"print"`. */
+  /** Mesh quality for STL/3MF (and a kit's printed parts). Defaults to `"print"`. */
   quality?: "preview" | "print";
   onProgress?: (phase: string) => void;
+  /** The cut & print kit's download options (`format: "bundle"`; the other formats ignore them). */
+  options?: KitOptions;
 }
 
 export interface CaptureCurrentOptions {
@@ -581,9 +624,12 @@ export interface PartRuntime {
   onContextLost(listener: () => void): () => void;
   /**
    * Every exportable sub-part — excludes any `exportable: false` part, respects
-   * each part's `enabled(params)` — INDEPENDENT of the active view.
+   * each part's `enabled(params)` — INDEPENDENT of the active view. A sheet
+   * part's row adds `sheet`, evaluated at the current params (omitted when that throws).
    */
-  listExportableParts(): Array<{ name: string; label: string }>;
+  listExportableParts(): Array<{ name: string; label: string; sheet?: ExportableSheetInfo }>;
+  /** The formats `exportParts` writes in this version — fresh copies of `EXPORT_FORMATS`. */
+  listExportFormats(): ExportFormatInfo[];
   /**
    * Headless export of a chosen subset. Resolves once the file is written
    * (handed to your `onDownload` sink, or downloaded directly); rejects on
@@ -648,6 +694,27 @@ export interface PartRuntime {
 /** Mount a full parametric-part app from a `PartDefinition`. */
 export function mount(part: PartDefinition, options: MountOptions): PartRuntime;
 
+/** Every format `exportParts` can write in this version (`runtime.listExportFormats()` returns copies). */
+export const EXPORT_FORMATS: ReadonlyArray<ExportFormatInfo>;
+
+/** The prefix every cut & print kit options error starts with. */
+export const KIT_OPTIONS_ERROR: "cut kit options:";
+
+/** The kit's option defaults; `stock: null` is 300 × 300 mm for every stock group. */
+export const KIT_DEFAULTS: Readonly<{
+  destination: "own-laser";
+  kerf: number;
+  colors: "lightburn";
+  stock: null;
+  margin: number;
+  spacing: number;
+  printFormat: "stl";
+  sets: number;
+}>;
+
+/** Normalise kit options — defaults filled, `cutFormat` derived — or throw a `"cut kit options: …"` error. */
+export function validateKitOptions(options: unknown): Required<KitOptions>;
+
 /**
  * The sub-parts a view shows: declared in the view and `enabled` for these
  * params, in `Object.keys(part.parts)` order. Handy for app-side view logic.

package/types/part.d.ts

@@ -441,6 +441,10 @@ export interface SheetDeclaration<P = ResolvedParams, D = Derived> {
   pose: SheetPose | ((p: P, d: D) => SheetPose | null) | null;
   /** The build `sheetPart` made; `sub.build !== sub.sheet.generatedBuild` is a custom build. */
   generatedBuild: (k: GeometryKernel, p: P, d: D) => Solid;
+  /** The author's own `place` (the spec's), run after the pose; `null` when there is none. */
+  place: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
+  /** The `place` `sheetPart` installed (the pose, then the author's own), or `null`; `sub.place !== sub.sheet.generatedPlace` is a replaced place. */
+  generatedPlace: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
 }
 
 export interface ViewDefinition {

package/types/testing.d.ts

@@ -8,6 +8,7 @@
 
 import type { GeometryKernel, Mesh, Point3, Solid } from "./kernel.js";
 import type { Derived, FontSource, PartDefinition, ResolvedParams } from "./part.js";
+import type { KitOptions } from "./index.js";
 
 export type { Derived, GeometryKernel, Mesh, PartDefinition, ResolvedParams, Solid };
 
@@ -46,7 +47,8 @@ export type MatchTarget =
 
 /** A job the worker loop accepts. */
 export interface WorkerJob {
-  type: "generate" | "export-stl" | "export-step" | "export-3mf" | "inspect";
+  /** `export-bundle` builds the cut & print kit (a ZIP) from `parts`, as `exportParts({ format: "bundle" })` does. */
+  type: "generate" | "export-stl" | "export-step" | "export-3mf" | "export-bundle" | "inspect";
   view?: string;
   params?: ResolvedParams;
   /** `generate`: which sub-parts to build. */
@@ -55,10 +57,12 @@ export interface WorkerJob {
   parts?: string[];
   quality?: "preview" | "print";
   cache?: boolean;
-  /** Correlation id echoed on every reply. */
-  jobId?: number;
+  /** Correlation id echoed on every reply (the export controller mints strings). */
+  jobId?: number | string;
   /** Single-file export name base. */
   name?: string;
+  /** `export-bundle` only: the kit's download options; absent means every default. */
+  options?: KitOptions;
   /**
    * `inspect`: score the part's six canonical silhouettes against these. Absent or
    * empty leaves `match` off the report entirely.