@floless/app 0.58.0 → 0.59.1

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.58.0" : void 0,
+    define: true ? "0.59.1" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.58.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.59.1" : void 0 });
 }
 
 // workflow-update.ts
@@ -59194,6 +59194,14 @@ function rollupDetails(details) {
 }
 
 // contract-score.ts
+function isFilterMissing(contract) {
+  const f = contract?.filter;
+  if (!f || typeof f !== "object") return true;
+  const sheets = f.sheets;
+  if (Array.isArray(sheets) && sheets.length > 0) return false;
+  if (f.page) return false;
+  return true;
+}
 var ORDER = { rfi: 0, low: 1, med: 2, high: 3, verified: 4 };
 var factor = (factors, key, state2) => factors.find((f) => f.key === key && (state2 === void 0 || f.state === state2));
 function reasonFor(m) {
@@ -59231,7 +59239,8 @@ function scoreContract2(contractInput) {
     members: s.byMember.length,
     rfiCount: s.overall.rfiCount,
     counts,
-    worklist
+    worklist,
+    filterMissing: isFilterMissing(contractInput)
   };
 }
 
@@ -64500,7 +64509,9 @@ async function startServer() {
   const REBAKE_INSTRUCTION = "Re-read the attached drawing and re-bake the extracted values into this app's config.yaml (the literals the deterministic run uses), then `aware app compile` the app and tell me to approve the new lock. Do not change node logic \u2014 only the baked config values.";
   app.post(
     "/api/rebake",
-    { bodyLimit: 25 * 1024 * 1024 },
+    // A drawing SET is now multiple files (up to 8) — a single 25 MB cap would 413 a legit multi-sheet
+    // rebake. 96 MB fits several large structural PDFs (base64-inflated); localhost, single-user, transient.
+    { bodyLimit: 96 * 1024 * 1024 },
     async (req, reply) => {
       const { appId, inputName, instruction, snapshots } = req.body ?? {};
       const sourceName = typeof req.body?.sourceName === "string" ? req.body.sourceName : void 0;

package/dist/schemas/steel.takeoff.v1.schema.json

@@ -61,11 +61,12 @@
           "properties": {
             "w": { "type": "number", "minimum": 1 },
             "h": { "type": "number", "minimum": 1 },
-            "bg_b64": { "type": "string", "description": "Base64 JPEG of the page (title block excluded). CONFIDENTIAL — machine-local, stripped from the baked .flo (contract-bake.ts), never committed." }
+            "bg_b64": { "type": "string", "description": "Base64 JPEG of the page (title block excluded). CONFIDENTIAL — machine-local, stripped from the baked .flo (contract-bake.ts), never committed." },
+            "rect": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] in vector-frame coords: the region `bg_b64` was clipped to, so the viewer registers the raster to it (not the whole page). Absent = covers the steelBbox (legacy)." }
           }
         },
         "steelBbox": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] of the steel linework, for Zoom-to-steel." },
-        "mode": { "enum": ["thickness", "layer", "color", "thickness+layer", "thickness+color"], "description": "Active match mode." },
+        "mode": { "enum": ["", "thickness", "layer", "color", "thickness+layer", "thickness+color", "layer+color", "thickness+layer+color"], "description": "Active match dimensions, '+'-joined and AND-ed (canonical order: thickness, layer, color). Any combo of layer/thickness/color; \"\" = match nothing (all boxes unchecked — a valid saved state)." },
         "hide_title_block": { "type": "boolean" },
         "layers": {
           "type": "array",
@@ -142,7 +143,8 @@
           "properties": {
             "w": { "type": "number", "minimum": 1 },
             "h": { "type": "number", "minimum": 1 },
-            "bg_b64": { "type": "string", "description": "Base64 JPEG of this sheet (title block excluded). CONFIDENTIAL — stripped before bake, never committed." }
+            "bg_b64": { "type": "string", "description": "Base64 JPEG of this sheet (title block excluded). CONFIDENTIAL — stripped before bake, never committed." },
+            "rect": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] in the same vector-frame coords as element `d` paths: the region `bg_b64` was clipped to. The viewer registers the raster to THIS rect (not the whole page) so it aligns 1:1 with the linework. Absent = the raster covers the steelBbox (legacy)." }
           }
         },
         "steelBbox": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] of this sheet's steel linework, for Zoom-to-steel." },

package/dist/skills/floless-app-rebake/SKILL.md

@@ -2,7 +2,7 @@
 name: floless-app-rebake
 description: This skill should be used when the user swaps the source drawing of a BAKED floless.app workflow and wants it re-read — the "Re-read & re-bake" (B3) loop for Visual Inputs. Triggers on a pending floless `rebake` request (queued from the app's "Re-read & re-bake ▸" button), or asks like "re-bake screenshot-to-saved-settings with this new schedule", "I swapped the drawing, re-read it", "re-extract and re-bake the config". It teaches the host AI to read the new image, re-extract its values, rewrite ONLY the app's config.yaml baked literals, recompile, and ask the user to approve — all at COMPOSE time (AWARE forbids reading a drawing during a run).
 metadata:
-  version: 0.1.0
+  version: 0.2.0
 ---
 
 # Re-read & re-bake a baked Visual Input (B3)
@@ -31,10 +31,12 @@ up here.
 
 1. **Find the request.** `GET http://localhost:<port>/api/requests` → find the entry with
    `type: "rebake"`. It carries `appId`, the `inputName` (the baked input, e.g. `drawing`),
-   an `instruction`, and `snapshots: ["<abs path to the new image>"]`. (The user may also just
-   ask in prose with an image attached — same procedure, skip the request lookup.)
-2. **Read the new drawing.** Open the image at `snapshots[0]` (a real PNG/JPEG/WebP on disk).
-   Read it with your own vision — this is the compose-time extraction.
+   an `instruction`, and `snapshots: ["<abs path>", …]` — **one OR MORE** new files (the user can
+   attach a set). (The user may also just ask in prose with image(s) attached — same procedure, skip
+   the request lookup.)
+2. **Read the new drawing(s).** Open **every** file in `snapshots[]` (real PNG/JPEG/WebP/PDF on
+   disk) — not just the first. Read them with your own vision as one combined set — this is the
+   compose-time extraction.
 3. **Re-extract the same schema the app already bakes.** Open the app source +
    `config.yaml` under `~/.aware/apps/<appId>/` (and the editable copy under `demos/<appId>/`
    if present). Identify the baked literals (e.g. `config.schedule-rows`). Re-extract **the same

package/dist/skills/floless-app-steel-takeoff/SKILL.md

@@ -2,7 +2,7 @@
 name: floless-app-steel-takeoff
 description: Read a structural steel drawing into an editable steel.takeoff/v1 contract in floless.app — the "Steel Takeoff" reader. Triggers on a pending floless `rebake` request for the `steel-model` app (queued from its "Re-read & re-bake ▸" button), or asks like "read this framing plan into a takeoff", "turn this structural drawing into a takeoff", "bake my drawing into steel-model", "extract members from this PDF". Teaches the host AI to READ a steel drawing (PDF/image) with its own vision at COMPOSE time, build a steel.takeoff/v1 contract (members + profiles + elevations + weights from AISC lookup), write it to the contract store, and hand control to the editor — no model in the run path, no API key.
 metadata:
-  version: 0.2.0
+  version: 0.3.0
 ---
 
 # Steel Takeoff — read a drawing into a steel.takeoff/v1 contract
@@ -31,15 +31,29 @@ but do not attempt them here.
 
 ## The loop
 
-### 1. Find the drawing
+### 1. Find the drawing(s)
 
 From a `rebake` request: `GET http://localhost:<port>/api/requests` → the entry with
-`type:"rebake"` and `appId:"steel-model"` carries `snapshots: ["<abs path>"]` (the drawing
-file) and optionally `sourceName` (the original filename — use it for the `source.name`
-provenance field). If the user just attaches or points at a drawing in prose, skip the lookup
-and proceed from that path.
-
-### 1b. Filter pre-stage — isolate the steel linework FIRST (the `filter` node)
+`type:"rebake"` and `appId:"steel-model"` carries `snapshots: ["<abs path>", …]` and optionally
+`sourceName` (the original filename of the first file — use it for the `source.name` provenance
+field). **`snapshots` may hold MULTIPLE files** — the user can attach a whole set (e.g. separate
+PDFs for S-201 / S-202 / S-301, or one multi-sheet PDF plus a detail sheet). **Read every file in
+`snapshots[]`, not just the first** — treat them as one combined set: run the sheet index (step 2.1)
+across all of them, and the per-sheet filter pass (1b) and member read span every file. If the user
+just attaches or points at a drawing in prose, skip the lookup and proceed from that path (again,
+handle all the files they gave you).
+
+### 1b. Filter step — isolate the steel linework FIRST (the `filter` node) — MANDATORY, DON'T SKIP
+
+> 🚦 **This is a hard gate, not an optional pre-stage. You MUST populate the `filter` block and hand
+> the Filter node to the user to Save BEFORE you read any members (step 2).** The member read is
+> *downstream of* the filter — skipping straight to members is the #1 failure of this skill: the run
+> then renders the shipped example filter (`S-ANNO-BEAM-STEL` / `S-ANNO-GRID` / …) as if it were the
+> user's drawing, and the members get bound by a length heuristic instead of the real steel linework.
+> The `/score` endpoint reports `filterMissing: true` until you've done this — treat that as a blocking
+> worklist item (see step 3). Whenever the drawing has vector linework (any PDF `page.get_drawings()`
+> returns paths), this step is required; a pure raster/photo with no vector paths is the only exception,
+> and even then say so explicitly.
 
 Before the heavy read, do **one** deterministic PyMuPDF pass **per framing-plan sheet** that enumerates
 *every* drawing element by **layer · thickness · colour** and bakes it into the contract's `filter`
@@ -54,6 +68,11 @@ sheets (Foundation, each Floor, Roof). **Show the user the list and get an expli
 "I found these framing plans: S-201, S-202, S-301 — filter all of these?" — before the pass. (The full
 elevation/detail classification is the broader workflow; here we only need the plan set.)
 
+⚠️ **This ONE plan-scope confirm covers both the filter pass AND the member read — they run on the
+same sheet set. Getting the OK does NOT mean "go read members"; the very next thing you do is the
+filter pass below, then hand off the Filter node. Do not let the confirm gate double as permission to
+skip the filter** (that collision is exactly how a real session read 28 members with no filter block).
+
 Then, for **each** confirmed plan sheet, one pass in display space (`page.rotation_matrix` — never mix
 native/display coords):
 
@@ -61,10 +80,13 @@ native/display coords):
    pt>, color:<#rrggbb stroke>, d:<SVG path>, dashed:<bool> }`.
 2. **Text** — `page.get_text("dict")`: per span keep `{ kind:"text", layer:<OCG>, w:0, color:<#hex>,
    text:<string>, bbox:[x0,y0,x1,y1] }`.
-3. **Per-sheet entry** — push `{ sheet:<number>, title:<name?>, page:{ w, h, bg_b64 }, steelBbox,
+3. **Per-sheet entry** — push `{ sheet:<number>, title:<name?>, page:{ w, h, bg_b64, rect }, steelBbox,
    elements:[…] }` onto `filter.sheets`. `bg_b64` is a dimmed raster of THIS sheet's framing area
-   (**title block excluded** — CONFIDENTIAL, machine-local, never committed); `steelBbox` = the bbox
-   of this sheet's steel-layer elements (Zoom-to-steel).
+   (**title block excluded** — CONFIDENTIAL, machine-local, never committed). **`page.rect` = the exact
+   clip `[x0,y0,x1,y1]` you rendered `bg_b64` from, in the SAME display-space coords as the element `d`
+   paths** — the viewer registers the raster to `rect` (not the whole page), so it aligns 1:1 with the
+   linework. `w`/`h` stay the full display-space page size (the vectors' coordinate frame). `steelBbox`
+   = the bbox of this sheet's steel-layer elements (Zoom-to-steel).
 4. **Global facets (union across sheets)** — aggregate distinct `layers` / `thicknesses` / `colors`
    with a summed `count` each, ACROSS all sheets, into the top-level `filter.layers/thicknesses/colors`
    (NOT per-sheet). Round each element's `w` and the facet `w` the **same** way (matching is
@@ -74,17 +96,23 @@ native/display coords):
 5. Set `filter.mode: "layer"`, `filter.active: 0`. **PUT** the contract
    (`PUT /api/contract/steel-model`). On a re-read, preserve any existing per-facet `on` flags.
 
-Then tell the user to open the **Filter** node, flip through the sheets, narrow to the steel, and
-**Save**. The saved `on` flags + `mode` are what step 2 reads — **per sheet** (each sheet's elements
-passing `mode` + the global `on` flags).
+**Then STOP and hand off — checkpoint before the member read.** Tell the user to open the **Filter**
+node, flip through the sheets, narrow to the steel, and **Save**. The saved `on` flags + `mode` are
+what step 2 reads — **per sheet** (each sheet's elements passing `mode` + the global `on` flags). Only
+after the filter is baked (confirm with `GET /api/contract/steel-model` → a `filter` with `sheets`, or
+`POST …/score` → `filterMissing: false`) do you proceed to the member read. The member read binds to
+the user's kept steel; running it against a filter-less contract is the gap this checkpoint exists to
+close.
 
 ### 2. Read it with your own vision — the heavy pipeline
 
-> **Candidate geometry comes from the filter (1b) when present.** If the contract carries a saved
-> `filter`, the member candidate set **for each sheet** is that sheet's **kept** line elements
-> (`filter.sheets[i].elements` whose layer/thickness/colour pass the GLOBAL `mode` + `on` flags) —
-> bind labels to *those*, not to a length-filtered scan of the whole sheet. The length heuristic
-> below is the **fallback** only when no filter was saved.
+> **Candidate geometry comes from the filter (1b) — which you already baked.** By the time you reach
+> here, step 1b has run and the user has Saved the Filter node, so the contract carries a `filter`: the
+> member candidate set **for each sheet** is that sheet's **kept** line elements
+> (`filter.sheets[i].elements` whose layer/thickness/colour pass the GLOBAL `mode` + `on` flags) — bind
+> labels to *those*, not to a length-filtered scan of the whole sheet. The length heuristic below is a
+> **degraded fallback** for the raster-only exception in 1b (no vector paths to enumerate); if you find
+> yourself using it on a vector PDF, you skipped 1b — go back and do it.
 
 Follow the methodology condensed here (full detail + every gotcha in
 `docs/superpowers/specs/2026-06-17-steel-takeoff-agent-guidance.md`):
@@ -185,9 +213,17 @@ Content-Type: application/json
 { "contract": <your draft contract>, "target": <target_confidence, e.g. 70> }
 ```
 
-Returns `{ score, target, meetsTarget, gap, rfiCount, counts, worklist }` — the SAME aggregate the
-editor's Confidence chip shows. `worklist` is the rfi/low/med members dragging the score, worst-first
-(heaviest first within a band), each with a `reason`. (Omit `contract` to score the stored one.)
+Returns `{ score, target, meetsTarget, gap, rfiCount, counts, worklist, filterMissing }` — the SAME
+aggregate the editor's Confidence chip shows. `worklist` is the rfi/low/med members dragging the score,
+worst-first (heaviest first within a band), each with a `reason`. (Omit `contract` to score the stored
+one.)
+
+**`filterMissing` is the completeness gate — independent of the confidence score.** `true` means the
+contract has no usable `filter` block: step 1b never ran, so the members were bound by the length
+heuristic, not the user's steel. A filter-less contract can still hit `meetsTarget` (as one real
+session did at 73%) — so **do not treat `meetsTarget` alone as "done."** If `filterMissing` is `true`,
+go back to step 1b, bake the filter, and hand off the Filter node before continuing. Hand-off (step 6)
+requires `filterMissing: false`.
 
 **The loop** — iterate at COMPOSE time until the goal is met:
 
@@ -404,6 +440,10 @@ offending fields, and re-PUT. You can read back the current contract with
 
 ### 6. Hand off to the user
 
+**Precondition:** `POST …/score` returns `filterMissing: false` (the Filter node was baked in 1b and the
+member read bound to it). If it's still `true`, you are not done — return to step 1b. Do not present a
+takeoff whose filter was skipped as finished.
+
 Tell the user:
 - What you read (e.g. "read 14 beams and 6 columns on sheets S-201/S-202; 3 MF members await
   Frame-Elevation resolution; aggregate confidence 78% — above your 70% target").

package/dist/web/app.css

@@ -2854,6 +2854,21 @@ body {
   .fm-file-replace, .fm-file-clear { font-size: 10px; padding: 3px 8px; background: var(--surface); border: 1px solid var(--border-strong); color: var(--text-muted); border-radius: 3px; cursor: pointer; font-family: var(--ui); }
   .fm-file-replace:hover { color: var(--text); border-color: var(--accent-dim); }
   .fm-file-clear:hover { color: var(--err); border-color: var(--err); }
+  /* ===== Visual Input: MULTI image/PDF file field (e.g. a framing set) ===== */
+  .fm-files { position: relative; }
+  .fm-files .fm-file-input { position: absolute; width: 1px; height: 1px; opacity: 0; pointer-events: none; }
+  .fm-files .fm-drop.at-cap { cursor: not-allowed; border-style: solid; border-color: var(--border-strong); background: var(--surface-2); color: var(--text-dim); outline: none; }
+  .fm-files-list { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 8px; }
+  .fm-files-list[hidden] { display: none; }
+  .fm-filechip { display: inline-flex; align-items: center; gap: 6px; max-width: 100%; padding: 4px 6px 4px 8px; border: 1px solid var(--border-strong); border-radius: 4px; background: var(--surface-2); }
+  .fm-filechip.is-reading { opacity: 0.6; }
+  .fm-filechip-name { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: var(--mono); font-size: 11px; color: var(--text); }
+  .fm-filechip-del { flex: none; width: 16px; height: 16px; padding: 0; display: inline-flex; align-items: center; justify-content: center; font-size: 11px; line-height: 1; background: transparent; border: 1px solid var(--border-strong); border-radius: 2px; color: var(--text-muted); cursor: pointer; }
+  .fm-filechip-del:hover, .fm-filechip-del:focus-visible { color: var(--err); border-color: var(--err); }
+  /* Re-bake "currently loaded" context row (inert — not a field) */
+  .rebake-current { display: flex; align-items: center; gap: 8px; padding: 7px 10px; margin-bottom: 12px; background: var(--surface-2); border-radius: 4px; }
+  .rebake-current-label { flex: none; text-transform: uppercase; letter-spacing: 0.08em; font-size: 10px; color: var(--text-muted); }
+  .rebake-current .fm-file-name { flex: 1; }
   /* Visual Input chip on the canvas input node */
   .agent-card .node-inputs .ni-pair-file { align-items: center; }
   .agent-card .node-inputs .ni-file-glyph { display: inline-flex; align-items: center; justify-content: center; width: 22px; height: 15px; border: 1px solid var(--accent-dim); border-radius: 3px; background: var(--accent-soft); color: var(--accent); font: 700 8px/1 var(--mono); letter-spacing: 0.04em; text-transform: uppercase; flex-shrink: 0; }

package/dist/web/aware.js

@@ -1386,26 +1386,43 @@
     const app = currentId && apps.get(currentId);
     if (!app || !app.rebakeInput) return;
     const name = app.rebakeInput;
+    // Show what's currently baked in (the source the run uses) so the user knows what they're
+    // replacing. Contract-backed apps carry it in source.name; suppress the shipped example, and
+    // skip silently for apps that bake into config (no contract) — the "if there is anything" case.
+    let current = '';
+    try {
+      const cr = await fetch(`/api/contract/${encodeURIComponent(app.id)}`);
+      if (cr.ok) {
+        const doc = await cr.json().catch(() => null);
+        const nm = doc && doc.source && typeof doc.source.name === 'string' ? doc.source.name : '';
+        if (nm && !/^example\b/i.test(nm)) current = nm;
+      }
+    } catch { /* no current source — fine, just don't show the row */ }
+    const fields = [];
+    if (current) fields.push({ type: 'current', name: '__current', label: 'Currently loaded', value: current });
+    fields.push({ name, label: `${name} — new source drawing(s)`, type: 'files', accept: ['pdf', 'png', 'jpg', 'webp'], required: true });
     const res = await formModal({
       title: `Re-read & re-bake · ${app.displayName}`,
-      sub: 'Attach the new drawing (PDF or image). Your terminal AI re-reads it and updates this workflow, then asks you to approve — nothing changes until you do.',
-      fields: [{ name, label: `${name} — new source drawing`, type: 'file', accept: ['pdf', 'png', 'jpg', 'webp'] }],
+      sub: 'Attach the new drawings (PDF or image) — one or several sheets. Your terminal AI re-reads them and updates this workflow, then asks you to approve — nothing changes until you do.',
+      fields,
       okLabel: 'Queue re-bake',
     });
     if (!res) return;
-    const dataUrl = res[name];
-    const sourceName = res[name + '__filename'] || undefined;
-    if (typeof dataUrl !== 'string' || !dataUrl.startsWith('data:')) { showToast('attach a drawing to re-bake', 'warn'); return; }
+    const files = Array.isArray(res[name]) ? res[name] : [];
+    if (!files.length) { showToast('attach a drawing to re-bake', 'warn'); return; }
+    const sourceName = files[0].name || undefined; // provenance: the first file's name
+    const n = files.length;
     try {
       const r = await fetch('/api/rebake', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ appId: app.id, inputName: name, ...(sourceName ? { sourceName } : {}), snapshots: [{ dataUrl }] }),
+        body: JSON.stringify({ appId: app.id, inputName: name, ...(sourceName ? { sourceName } : {}), snapshots: files.map((f) => ({ name: f.name, dataUrl: f.dataUrl })) }),
       });
+      if (r.status === 413) { showToast('those files are too large to queue together — attach fewer or smaller sheets', 'warn'); return; }
       const out = await r.json().catch(() => ({ ok: false, error: `re-bake failed (${r.status})` }));
       if (!out || !out.ok) { showToast((out && out.error) || 'could not queue re-bake', 'err'); return; }
-      showToast('Queued — your terminal AI will re-read it and update this workflow, then ask you to approve.', 'ok');
-      appendNarration(`<strong>Re-bake queued</strong> for <strong>${escapeHtml(name)}</strong>. Your terminal AI will re-read the drawing, update this workflow, and ask you to approve the new lock.`);
+      showToast(`Queued — your terminal AI will re-read ${n} drawing${n > 1 ? 's' : ''} and update this workflow, then ask you to approve.`, 'ok');
+      appendNarration(`<strong>Re-bake queued</strong> for <strong>${escapeHtml(name)}</strong> (${n} file${n > 1 ? 's' : ''}). Your terminal AI will re-read the drawing${n > 1 ? 's' : ''}, update this workflow, and ask you to approve the new lock.`);
     } catch { showToast('could not queue re-bake', 'err'); }
   }
 
@@ -2250,6 +2267,13 @@
         if (f.type === 'checkbox') {
           return `<label class="modal-check" for="${id}"><input type="checkbox" id="${id}" data-fm-check="${escapeHtml(f.name)}"${f.value ? ' checked' : ''}><span>${escapeHtml(f.label || f.name)}</span></label>`;
         }
+        // Read-only "what's currently loaded" context row (e.g. the source drawing already
+        // baked into a re-bake app). Inert — a muted label + glyph + filename, not a field.
+        if (f.type === 'current') {
+          const cext = (/\.([a-z0-9]+)$/i.exec(f.value || '') || [])[1];
+          const cglyph = String(cext || '').toLowerCase() === 'pdf' ? 'pdf' : 'img';
+          return `<div class="rebake-current"><span class="rebake-current-label">${escapeHtml(f.label || 'Currently loaded')}</span><span class="fm-file-glyph">${cglyph}</span><span class="fm-file-name" title="${escapeAttr(f.value)}">${escapeHtml(f.value)}</span></div>`;
+        }
         let ctl;
         if (f.type === 'images') {
           ctl = `<div class="fm-images" data-fm-images="${escapeHtml(f.name)}">
@@ -2266,6 +2290,17 @@
             <div class="fm-drop" role="button" tabindex="0" aria-label="Attach an image or PDF"></div>
             <input type="file" accept="${escapeAttr(acceptAttr)}" class="fm-file-input" tabindex="-1" aria-hidden="true">
           </div>`;
+        } else if (f.type === 'files') {
+          // MULTI image/PDF Visual Input (e.g. a whole framing set). Persistent drop zone +
+          // a wrap-flow chip list below; drag-drop + click + paste; up to 8 (server cap).
+          const accepts = (f.accept && f.accept.length) ? f.accept : ['pdf', 'png', 'jpg', 'webp'];
+          const acceptAttr = accepts.map((e) => '.' + String(e).replace(/^\./, '')).join(',');
+          const hint = accepts.join(', ').toUpperCase();
+          ctl = `<div class="fm-files" data-fm-files="${escapeAttr(f.name)}" data-accept-hint="${escapeAttr(hint)}"${f.required ? ' data-required="1"' : ''}>
+            <div class="fm-drop" role="button" tabindex="0" aria-label="Attach drawings — drop or click"><span class="fm-drop-main">Drop or click to attach files</span><span class="fm-drop-hint">${escapeHtml(hint)} · paste also works</span></div>
+            <input type="file" accept="${escapeAttr(acceptAttr)}" multiple class="fm-file-input" tabindex="-1" aria-hidden="true">
+            <div class="fm-files-list" aria-live="polite" hidden></div>
+          </div>`;
         } else {
           ctl = f.multiline
             ? `<textarea id="${id}" rows="4" data-fm="${escapeHtml(f.name)}" placeholder="${ph}">${escapeHtml(val)}</textarea>`
@@ -2281,10 +2316,18 @@
       $ok.classList.toggle('primary', !danger);
       $cancel.classList.toggle('primary', !!danger);
       showModal($formModal);
-      const first = $body.querySelector('input:not(.fm-file-input),textarea');
+      // Prefer a real text input; else a file drop zone (so keyboard users land somewhere
+      // actionable rather than a possibly-disabled OK button).
+      const first = $body.querySelector('input:not(.fm-file-input),textarea')
+        || $body.querySelector('.fm-files .fm-drop, .fm-file .fm-drop, .fm-images .fm-drop');
       if (first) { first.focus(); if (first.select) first.select(); }
       else if (danger) $cancel.focus();
       else $ok.focus();
+      // OK-gate probes: required consent checks (below) AND required multi-file fields must be
+      // satisfied. Declared here so the fm-files setup can re-run the gate; wired after all setups.
+      let runGate = () => {};
+      const fileGateProbes = [];
+      let modalClosed = false; // set in done(); guards async FileReader callbacks from touching a closed modal
       // ── images-field setup ──────────────────────────────────────────────────────
       const imageStates = new Map();
       $body.querySelectorAll('.fm-images').forEach((box) => {
@@ -2362,6 +2405,90 @@
         fileStates.set(name, { st, setFile });
         render();
       });
+      // ── multi-file field setup (image/PDF set, e.g. a framing set) ─────────────────
+      const fileListStates = new Map();
+      $body.querySelectorAll('.fm-files').forEach((box) => {
+        const name = box.dataset.fmFiles;
+        const MAX = 8;
+        const hint = box.dataset.acceptHint || 'PDF, PNG, JPG, WEBP';
+        const acceptExts = hint.toLowerCase().split(/[,\s]+/).filter(Boolean);
+        const state = []; // { name, ext, dataUrl, reading }
+        const drop = box.querySelector('.fm-drop');
+        const main = drop.querySelector('.fm-drop-main');
+        const hintEl = drop.querySelector('.fm-drop-hint');
+        const fileInput = box.querySelector('.fm-file-input');
+        const list = box.querySelector('.fm-files-list');
+        const isFileDrag = (e) => !!e.dataTransfer && Array.from(e.dataTransfer.types || []).includes('Files');
+        // Prefer the filename extension; fall back to the MIME type for a no-name paste. Normalize
+        // jpeg→jpg so a `.jpeg` file (or a pasted image/jpeg) is accepted like the server does.
+        const extOf = (fn, type) => {
+          const m = /\.([a-z0-9]+)$/i.exec(fn || '');
+          let e = (m ? m[1] : '').toLowerCase();
+          if (!e && type) e = type === 'application/pdf' ? 'pdf' : type.startsWith('image/') ? type.slice(6) : '';
+          return e === 'jpeg' ? 'jpg' : e;
+        };
+        const readyCount = () => state.filter((s) => !s.reading && s.dataUrl).length;
+        const syncDrop = () => {
+          const n = state.length;
+          const atCap = n >= MAX;
+          drop.classList.toggle('at-cap', atCap);
+          if (atCap) { main.textContent = `Maximum ${MAX} files attached`; hintEl.textContent = 'Remove one to add another'; }
+          else if (n > 0) { main.textContent = `${n} of ${MAX} attached — drop or click to add more`; hintEl.textContent = `${hint} · paste also works`; }
+          else { main.textContent = 'Drop or click to attach files'; hintEl.textContent = `${hint} · paste also works · up to ${MAX}`; }
+        };
+        const renderList = () => {
+          list.hidden = state.length === 0;
+          list.innerHTML = state.map((s, i) => s.reading
+            ? `<div class="fm-filechip is-reading"><span class="fm-file-glyph">${s.ext === 'pdf' ? 'pdf' : 'img'}</span><span class="fm-filechip-name">Reading…</span></div>`
+            : `<div class="fm-filechip"><span class="fm-file-glyph">${s.ext === 'pdf' ? 'pdf' : 'img'}</span><span class="fm-filechip-name" title="${escapeAttr(s.name)}">${escapeHtml(s.name)}</span><button type="button" class="fm-filechip-del" data-i="${i}" aria-label="Remove ${escapeAttr(s.name)}">×</button></div>`
+          ).join('');
+          list.querySelectorAll('.fm-filechip-del').forEach((b) => {
+            b.onclick = () => {
+              const idx = Number(b.dataset.i);
+              state.splice(idx, 1);
+              renderList(); syncDrop(); runGate();
+              // Keep focus in the field, not lost to <body>: next chip's ×, else the drop zone.
+              const dels = list.querySelectorAll('.fm-filechip-del');
+              (dels[Math.min(idx, dels.length - 1)] || drop).focus();
+            };
+          });
+        };
+        const addFile = (file) => {
+          if (!file) return;
+          if (state.length >= MAX) { showToast(`Max ${MAX} files`, 'warn'); return; }
+          const ext = extOf(file.name, file.type);
+          if (acceptExts.length && !acceptExts.includes(ext)) { showToast(`${file.name || 'file'} — ${hint} only`, 'warn'); return; }
+          const entry = { name: file.name || ('pasted.' + (ext || 'png')), ext, dataUrl: '', reading: true };
+          state.push(entry);
+          renderList(); syncDrop(); runGate(); // disable OK while this file reads (gate blocks on any reading)
+          const reader = new FileReader();
+          // Guard on modalClosed: a large read can finish after the modal is cancelled/closed; without
+          // this the stale callback would mutate the SHARED $ok gate of the next formModal.
+          reader.onload = () => { if (modalClosed) return; entry.dataUrl = reader.result; entry.reading = false; renderList(); syncDrop(); runGate(); };
+          reader.onerror = () => { if (modalClosed) return; const i = state.indexOf(entry); if (i >= 0) state.splice(i, 1); renderList(); syncDrop(); runGate(); showToast(`could not read ${file.name || 'the file'}`, 'err'); };
+          reader.readAsDataURL(file);
+        };
+        const addFiles = (files) => {
+          const arr = Array.from(files || []);
+          const room = Math.max(0, MAX - state.length);
+          if (arr.length > room) showToast(`Max ${MAX} files`, 'warn');
+          arr.slice(0, room).forEach(addFile);
+        };
+        drop.onclick = () => { if (state.length < MAX) fileInput.click(); };
+        drop.onkeydown = (e) => { if ((e.key === 'Enter' || e.key === ' ') && state.length < MAX) { e.preventDefault(); fileInput.click(); } };
+        fileInput.onchange = () => { addFiles(fileInput.files); fileInput.value = ''; };
+        // Native drag-drop: bind on the whole box (so the chip area isn't a dead zone), toggle the
+        // visual on the inner drop. dragover MUST preventDefault or `drop` never fires.
+        box.ondragenter = (e) => { if (isFileDrag(e)) { e.preventDefault(); if (state.length < MAX) { drop.classList.add('drag-over'); main.textContent = 'Drop to attach'; } } };
+        box.ondragover = (e) => { if (isFileDrag(e)) { e.preventDefault(); e.dataTransfer.dropEffect = state.length < MAX ? 'copy' : 'none'; } };
+        box.ondragleave = (e) => { if (!box.contains(e.relatedTarget)) { drop.classList.remove('drag-over'); syncDrop(); } };
+        box.ondrop = (e) => { if (!isFileDrag(e)) return; e.preventDefault(); drop.classList.remove('drag-over'); addFiles(e.dataTransfer.files); syncDrop(); };
+        fileListStates.set(name, { state, addFiles });
+        // Gate probe returns 0 (blocks OK) while ANY file is still reading — so you can't submit a
+        // partial set (collect() drops still-reading files); ready count only once all reads finish.
+        if (box.dataset.required) fileGateProbes.push(() => (state.some((s) => s.reading) ? 0 : readyCount()));
+        renderList(); syncDrop();
+      });
       // ── paste support: an image into the modal → the images field, else the file field ──
       $body.onpaste = (e) => {
         const items = Array.from((e.clipboardData && e.clipboardData.items) || []);
@@ -2386,6 +2513,14 @@
           });
           return;
         }
+        const filesBox = $body.querySelector('.fm-files');
+        if (filesBox) {
+          if (!fileItems.length) return;
+          e.preventDefault();
+          const entry = fileListStates.get(filesBox.dataset.fmFiles);
+          if (entry) entry.addFiles(fileItems.map((it) => it.getAsFile()).filter(Boolean));
+          return;
+        }
         const fileBox = $body.querySelector('.fm-file');
         if (!fileBox || !fileItems.length) return;
         e.preventDefault();
@@ -2393,15 +2528,26 @@
         const file = fileItems[0].getAsFile();
         if (entry && file) entry.setFile(file);
       };
+      // Stray-drop guard: a file dropped onto the modal but MISSING a drop zone must not
+      // navigate the page to the file. The .fm-files box handles real drops; this only
+      // neutralizes the misses.
+      $body.ondragover = (e) => { if (e.dataTransfer && Array.from(e.dataTransfer.types || []).includes('Files')) e.preventDefault(); };
+      $body.ondrop = (e) => { if (e.dataTransfer && Array.from(e.dataTransfer.types || []).includes('Files')) e.preventDefault(); };
       // Required consent checkboxes (e.g. the fork liability terms) disable OK until ticked.
       const requiredChecks = Array.from($body.querySelectorAll('[data-fm-check]')).filter((el) => {
         const f = fields.find((x) => x.name === el.dataset.fmCheck);
         return f && f.required;
       });
-      if (requiredChecks.length) {
-        const syncOkGate = () => { $ok.disabled = requiredChecks.some((el) => !el.checked); };
-        requiredChecks.forEach((el) => { el.onchange = syncOkGate; });
-        syncOkGate();
+      // Unified OK gate: every required consent check ticked AND every required multi-file field
+      // has ≥1 ready file. (runGate was declared up top so fm-files callbacks can re-run it.)
+      if (requiredChecks.length || fileGateProbes.length) {
+        runGate = () => {
+          const checksOk = !requiredChecks.some((el) => !el.checked);
+          const filesOk = !fileGateProbes.some((getN) => getN() < 1);
+          $ok.disabled = !(checksOk && filesOk);
+        };
+        requiredChecks.forEach((el) => { el.onchange = runGate; });
+        runGate();
       }
       const collect = () => {
         const out = {};
@@ -2413,12 +2559,17 @@
           // expose filename alongside so callers can capture provenance (e.g. rebake → sourceName)
           out[name + '__filename'] = entry.st.name || '';
         });
+        // Multi-file field → array of { name, dataUrl } (only fully-read files).
+        fileListStates.forEach((entry, name) => {
+          out[name] = entry.state.filter((s) => !s.reading && s.dataUrl).map((s) => ({ name: s.name, dataUrl: s.dataUrl }));
+        });
         return out;
       };
       const done = (result) => {
         _formModalOpen = false;
+        modalClosed = true;
         hideModal($formModal);
-        $ok.onclick = null; $cancel.onclick = null; $formModal.onclick = null; $formModal.onkeydown = null; $body.onpaste = null;
+        $ok.onclick = null; $cancel.onclick = null; $formModal.onclick = null; $formModal.onkeydown = null; $body.onpaste = null; $body.ondragover = null; $body.ondrop = null;
         $ok.classList.remove('danger'); $ok.classList.add('primary'); $cancel.classList.remove('primary'); $ok.disabled = false; // reset chrome for the next caller
         resolve(result);
       };

package/dist/web/steel-filter-core.js

@@ -10,24 +10,37 @@
  *
  * Shapes:
  *   element : { kind:'line'|'text', layer:string, w:number, color:string, d?:string, text?:string, bbox?:number[], dashed?:boolean }
- *   mode    : 'thickness' | 'layer' | 'color' | 'thickness+layer' | 'thickness+color'
+ *   mode    : any '+'-joined combo of 'layer'/'thickness'/'color', AND-ed (e.g. 'thickness+layer').
+ *             '' = match nothing. Canonical order = MODE_ORDER (keeps legacy 'thickness+…' strings).
  *   sel     : { layers:Set<string>, thicknesses:Set<number>, colors:Set<string> }
  *   filter  : { mode, layers:[{name,count,steel?,drawable?,on?}], thicknesses:[{w,count,on?}], colors:[{hex,count,on?}], elements:[…] }
  */
 
-/** The active match predicate — does this element pass the current mode + selection? */
+/** Canonical dimension order for a mode string — keeps legacy 'thickness+layer'/'thickness+color'. */
+export const MODE_ORDER = ['thickness', 'layer', 'color'];
+
+/** The dimensions a mode activates, order-agnostic: 'thickness+layer' -> ['thickness','layer']. */
+export function modeDims(mode) {
+  return String(mode || '').split('+').filter((d) => MODE_ORDER.includes(d));
+}
+
+/** Build the canonical mode string from a set/list of checked dimensions. */
+export function canonicalMode(dims) {
+  const set = new Set(dims);
+  return MODE_ORDER.filter((d) => set.has(d)).join('+');
+}
+
+/**
+ * The active match predicate — an element passes when it matches EVERY checked dimension (AND).
+ * Zero checked dimensions match nothing (a valid, visible "0 shown" state, not a fall-through to all).
+ */
 export function matchesActive(el, mode, sel) {
-  const byLayer = () => sel.layers.has(el.layer);
-  const byThk = () => sel.thicknesses.has(el.w);
-  const byColor = () => sel.colors.has(el.color);
-  switch (mode) {
-    case 'thickness': return byThk();
-    case 'layer': return byLayer();
-    case 'color': return byColor();
-    case 'thickness+layer': return byThk() && byLayer();
-    case 'thickness+color': return byThk() && byColor();
-    default: return false;
-  }
+  const dims = modeDims(mode);
+  if (!dims.length) return false;
+  return dims.every((d) =>
+    d === 'layer' ? sel.layers.has(el.layer)
+      : d === 'thickness' ? sel.thicknesses.has(el.w)
+        : sel.colors.has(el.color));
 }
 
 /**
@@ -66,6 +79,24 @@ export function countShown(elements, mode, sel) {
   return n;
 }
 
+/**
+ * Where a sheet's background raster (`page.bg_b64`) maps, in the same vector-frame coords as the
+ * elements' `d` paths — so the raster registers 1:1 with the linework. The producer clips the raster
+ * to the framing area and records that clip in `page.rect` ([x0,y0,x1,y1]); the renderer places the
+ * <image> there (preserveAspectRatio="none") instead of stretching it across the whole page.
+ *
+ * ponytail: `steelBbox` fallback bridges pre-`rect` contracts (the producer clipped the raster to the
+ * steel bbox, so it aligns exactly). Upgrade path: drop it once every baked contract carries page.rect.
+ */
+export function bgRect(sheet) {
+  const pg = (sheet && sheet.page) || {};
+  const valid = (r) => Array.isArray(r) && r.length === 4 && r[2] - r[0] > 0 && r[3] - r[1] > 0;
+  // Try each candidate in order — a degenerate page.rect must NOT skip a valid steelBbox.
+  const r = valid(pg.rect) ? pg.rect : (valid(sheet && sheet.steelBbox) ? sheet.steelBbox : null);
+  if (r) return { x: r[0], y: r[1], w: r[2] - r[0], h: r[3] - r[1] };
+  return { x: 0, y: 0, w: pg.w || 0, h: pg.h || 0 };
+}
+
 /**
  * Write the live selection + mode back onto the filter block's `on` flags so it persists on the
  * contract (what Save PUTs, and what the reader reads). Mutates and returns `filter`.

package/dist/web/steel-filter.html

@@ -38,11 +38,9 @@ header select#sheetSel{font-weight:600;min-width:200px;max-width:320px}
 .opts label em{margin-left:auto;color:var(--mut);font-style:normal;font-size:11px}
 .opts .sw{width:12px;height:12px;border-radius:3px;flex:0 0 12px;border:1px solid var(--line)}
 .opts label.textlayer{opacity:.55;cursor:default}
-/* Fully custom checkbox/radio — the native unchecked widget is a white/grey square that breaks the dark baseline. */
-input[type=radio],input[type=checkbox]{-webkit-appearance:none;appearance:none;width:14px;height:14px;flex:none;border:1px solid #475569;border-radius:3px;background:transparent;cursor:pointer;margin:0;vertical-align:middle}
-input[type=radio]{border-radius:50%}
+/* Fully custom checkbox — the native unchecked widget is a white/grey square that breaks the dark baseline. */
+input[type=checkbox]{-webkit-appearance:none;appearance:none;width:14px;height:14px;flex:none;border:1px solid #475569;border-radius:3px;background:transparent;cursor:pointer;margin:0;vertical-align:middle}
 input[type=checkbox]:checked{background:var(--brand);border-color:var(--brand);background-image:url("data:image/svg+xml,%3Csvg viewBox='0 0 10 8' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M1 4l3 3 5-5' stroke='%23fff' stroke-width='1.6' fill='none' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:center}
-input[type=radio]:checked{background:var(--brand);border-color:var(--brand);box-shadow:inset 0 0 0 3px var(--panel)}
 input:focus-visible{outline:2px solid var(--brand);outline-offset:1px}
 .facet.dim{opacity:.4} .facet.dim .opts,.facet.dim .acts{pointer-events:none}
 .hint{color:var(--mut);font-size:11px;line-height:1.5}
@@ -82,12 +80,11 @@ footer{margin-top:auto;display:flex;align-items:center;gap:6px;flex-wrap:wrap;bo
 <div id="app">
   <aside id="panel">
     <section id="modes">
-      <h2>Match mode</h2>
-      <label><input type="radio" name="mode" value="layer" checked /> Layer only</label>
-      <label><input type="radio" name="mode" value="thickness" /> Thickness only</label>
-      <label><input type="radio" name="mode" value="color" /> Color only</label>
-      <label><input type="radio" name="mode" value="thickness+layer" /> Thickness + Layer</label>
-      <label><input type="radio" name="mode" value="thickness+color" /> Thickness + Color</label>
+      <h2>Match on</h2>
+      <label><input type="checkbox" name="dim" value="layer" checked /> Layer</label>
+      <label><input type="checkbox" name="dim" value="thickness" /> Thickness</label>
+      <label><input type="checkbox" name="dim" value="color" /> Color</label>
+      <p class="hint">Checked criteria must all match (AND).</p>
     </section>
     <section class="facet" id="facet-layers">
       <h2>Layers <span class="acts"><button data-all="layers">all</button><button data-none="layers">none</button></span></h2>
@@ -128,7 +125,7 @@ footer{margin-top:auto;display:flex;align-items:center;gap:6px;flex-wrap:wrap;bo
 </div>
 
 <script type="module">
-import { matchesActive, selFromFilter, eyedropperAdd, countShown, applySelToFilter, normalizeFilter } from './steel-filter-core.js';
+import { matchesActive, modeDims, canonicalMode, selFromFilter, eyedropperAdd, countShown, bgRect, applySelToFilter, normalizeFilter } from './steel-filter-core.js';
 
 const APP_ID = new URLSearchParams(location.search).get('app') || '';
 const SVGNS = 'http://www.w3.org/2000/svg';
@@ -183,9 +180,11 @@ function showEmpty(msg){
 }
 
 function initFromFilter(){
-  mode = F.mode || 'layer';
-  document.querySelector(`input[name=mode][value="${mode}"]`)?.setAttribute('checked','');
-  document.querySelectorAll('input[name=mode]').forEach(r => { r.checked = (r.value === mode); });
+  // Canonicalize on load (drops unknown tokens, orders dims) so a facet-only save writes a valid
+  // enum string; a saved-empty '' round-trips as '', while an absent mode defaults to 'layer'.
+  mode = (F.mode == null) ? 'layer' : canonicalMode(modeDims(F.mode));
+  const on = new Set(modeDims(mode));
+  document.querySelectorAll('input[name=dim]').forEach(cb => { cb.checked = on.has(cb.value); });
   // layer colours: steel layers vivid+distinct, others a single muted slate (GLOBAL facets)
   let si = 0;
   layerColor = {};
@@ -217,7 +216,16 @@ function setSheet(i){
   const sh = sheets[active] || {};
   const pg = (sh.page && sh.page.w > 0 && sh.page.h > 0) ? sh.page : { w: 1000, h: 1000 };  // guard empty page → no NaN viewBox
   svg.setAttribute('viewBox', `0 0 ${pg.w} ${pg.h}`);
-  if(pg.bg_b64){ bgImg.setAttribute('href', 'data:image/jpeg;base64,' + pg.bg_b64); bgImg.setAttribute('width', pg.w); bgImg.setAttribute('height', pg.h); bgImg.style.display=''; }
+  if(pg.bg_b64){
+    // Register the raster to its true extent (the framing-area clip), NOT the whole page — else a
+    // crop gets stretched over the full viewBox and floats off-scale from the vector linework.
+    const r = bgRect(sh);
+    bgImg.setAttribute('href', 'data:image/jpeg;base64,' + pg.bg_b64);
+    bgImg.setAttribute('x', r.x); bgImg.setAttribute('y', r.y);
+    bgImg.setAttribute('width', r.w); bgImg.setAttribute('height', r.h);
+    bgImg.setAttribute('preserveAspectRatio', 'none');
+    bgImg.style.display='';
+  }
   else bgImg.style.display = 'none';
   buildOverlay();
   base = { x: 0, y: 0, w: pg.w, h: pg.h }; vb = { ...base }; setVB();
@@ -309,13 +317,17 @@ function apply(){
     html += ' · <b>' + sa + '</b> of <b>' + ta + '</b> total (' + sheets.length + ' sheets)';
   }
   countEl.innerHTML = html;
-  document.getElementById('facet-layers').classList.toggle('dim', !(mode === 'layer' || mode === 'thickness+layer'));
-  document.getElementById('facet-thicknesses').classList.toggle('dim', !mode.startsWith('thickness'));
-  document.getElementById('facet-colors').classList.toggle('dim', !(mode === 'color' || mode === 'thickness+color'));
+  const dims = new Set(modeDims(mode));
+  document.getElementById('facet-layers').classList.toggle('dim', !dims.has('layer'));
+  document.getElementById('facet-thicknesses').classList.toggle('dim', !dims.has('thickness'));
+  document.getElementById('facet-colors').classList.toggle('dim', !dims.has('color'));
 }
 
 // --- modes + all/none ---
-document.querySelectorAll('input[name=mode]').forEach(r => r.addEventListener('change', () => { if(r.checked){ mode = r.value; markDirty(); apply(); } }));
+document.querySelectorAll('input[name=dim]').forEach(cb => cb.addEventListener('change', () => {
+  mode = canonicalMode([...document.querySelectorAll('input[name=dim]:checked')].map(c => c.value));
+  markDirty(); apply();
+}));
 document.querySelectorAll('[data-all]').forEach(b => b.addEventListener('click', () => setAllFacet(b.dataset.all, true)));
 document.querySelectorAll('[data-none]').forEach(b => b.addEventListener('click', () => setAllFacet(b.dataset.none, false)));
 function setAllFacet(facet, on){

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.58.0",
+  "version": "0.59.1",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {