opentakeoff-mcp 0.9.19 → 0.9.21

package/README.md

@@ -108,13 +108,14 @@ includes document text, shape vertices, or result payload content.
 | `load_plan` | Open a plan PDF from disk. Default replaces the whole session; **`merge: true` ADDS the document to the working set** (#152) — plans + schedule + addenda as one takeoff, sheet graph spanning the whole set, marked set covering every worked sheet. Returns per-sheet dims, title-block `sheet_number`, and the detected drawn scale where present. |
 | `sheet_info` | One sheet's dims, vector segment count, scale status, detected suggestion, committed shape count. |
 | `set_scale` | Set a sheet's scale — exactly one of `label`, `upp`, `calibrate {p1, p2, feet}`, `use_detected`. |
-| `one_click` | One-Click Area at (x, y): flood fill bounded by the plan linework, traced, vertices snapped. Pass `condition` to commit; `role: "deduct"` subtracts. |
+| `one_click` | One-Click Area at (x, y): flood fill bounded by the plan linework, traced, vertices snapped. On a SCANNED sheet (no usable linework) the flood falls back automatically to the rendered pixels — same engine as the canvas — with `raster_traced` disclosed on the reply and on the shape's origin (#154). Pass `condition` to commit; `role: "deduct"` subtracts. |
 | `detect_rooms` | Batch One-Click: reads every room-number label off the sheet's text layer and floods each — one call instead of `read_sheet_text` + reasoning + N `one_click` calls. Only cleanly-traced rooms come back; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible / unresolved), never dropped silently. To commit: `assign_from_schedule: true` routes each room through its OWN room-finish schedule row and commits under the FLOOR finish that row states (rooms the schedule can't answer for return in `unresolved[]` with reasons and re-seedable coordinates); or pass `condition` to commit every room under one stated tag. |
 | `measure_polygon` | Area + perimeter of a polygon you supply (min 3 verts). Requires scale. |
 | `measure_line` | Length of an open polyline (min 2 points). Requires scale. |
 | `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
 | `measure_surface` | **Wall SF**: an open run traced along the wall, quantified as traced LF × the condition's height (the canvas's H knob — pass `height_ft` to set it, or set it once with `edit_condition`). Wall tile, wainscot, wall systems. Refuses without a height, minting nothing. |
 | `place_count` | **EA markers**: one point, one each — thresholds, stair nosings, floor boxes. No scale required (EA is scale-free). One shape per point; the whole call is one undo step. |
+| `symbol_sweep` | **Every instance of a repeated plan symbol, from ONE example**: marquee a tight `seed_rect` around a single drain/threshold/fixture symbol and the sheet's vector linework is searched deterministically for every other placement — translation plus 0/90/180/270 rotation and mirroring (both on by default). Score = length-weighted fraction of the seed's segments matched within `tolerance_px`; ≥ 0.92 is a match, the 0.75–0.92 band returns in `withheld` with reasons (never committed, never dropped silently), and the work cap is disclosed when it bites. `commit: true` + `condition` commits every match center as an EA count marker through the `place_count` path — one undo step, `origin.method "symbol_sweep"` with per-marker score and transform. No scale required. |
 | `takeoff_summary` | Per-condition totals + grand totals, computed by the Report's rules. |
 | `export_takeoff` | The full `opentakeoff.takeoff_canvas.v1` payload — exactly what the app autosaves. Inline, and to disk with `path`. |
 | `delete_shape` | Remove a committed shape by id. |
@@ -126,7 +127,7 @@ includes document text, shape vertices, or result payload content.
 | `export_marked_pdf` | The **marked-up planset** — the deliverable. Writes a distribution-ready PDF: a legend cover (per-condition totals, swatches, by-sheet breakdown) plus every sheet that carries work, vector-copied from the source with shapes, hatches, per-shape quantity chips, and annotations burned in — built by the same module as the canvas's MARKED SET button. Machine-traced shapes are disclosed as pending human review on the document itself, and the cover states where the finish tags came from (`Finish assignment: N schedule-resolved · N agent-asserted · …`, plus any rooms the last assign run withheld). Default path: `<plan> - marked set.pdf` next to the plan. Works without `@napi-rs/canvas`. |
 | `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, review state, and assignment verdict (`schedule` \| `asserted` — where its finish tag came from) in one compact read — the ids `edit_shape`/`delete_shape` assume you have, without pulling the whole `export_takeoff` payload. Filters by sheet/condition narrow; empty is a result, not an error. |
 | `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored, a condition edit's waste/multiplier pair restored. A whole `detect_rooms` sweep is **one** step. |
-| `annotate` | Place a note ABOUT the work — cloud/highlight (`rect`), text (`at`), callout (`at` + `target`), **arrow** (`from` + `to` — plank/seam direction), **bubble** (`at` + optional `r` — keynote circle, centered text). Attach to a condition and it wears that scope's colour on the canvas and in the marked set. No review gate: notes are not geometry. |
+| `annotate` | Place a note ABOUT the work — cloud/highlight (`rect`), text (`at`), callout (`at` + `target`), **arrow** (`from` + `to` — plank/seam direction), **bubble** (`at` + optional `r` — keynote circle, centered text), **dimension** (`from` + `to` — a dimension line with end ticks, labelled with the measured length at the sheet's scale; the one annotation the scale gate applies to — an unscaled sheet refuses like the measure tools). Attach to a condition and it wears that scope's colour on the canvas and in the marked set. No review gate: notes are not geometry. |
 | `list_annotations` | Every annotation with its condition RESOLVED to a finish tag, coordinates back in image px; filter by sheet/condition. `unattached` counts the link_annotation candidates. |
 | `link_annotation` | Attach an existing annotation to a condition (or detach with an empty tag) — the canvas's Attach/Detach control, reachable by an agent. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |
@@ -243,9 +244,12 @@ sheet number (`A-101`) wherever a sheet is named.
 
 ## Limits (v1)
 
-- **Vector + text sheets only.** A scanned sheet has no vector linework, so
-  `one_click` reports it plainly; a raster fallback is a planned seam
-  (`src/session.ts`, `ensureMask`), not yet built.
+- **Scanned sheets flood, but don't index.** `one_click` and `detect_rooms`
+  fall back to the sheet's rendered pixels where vectors can't bound the room
+  (#154) — disclosed as `raster_traced` — but a scan with no text layer still
+  has nothing for `detect_rooms`/`sheet_graph`/`resolve_tag` to read: seeds
+  come from you (`view_sheet`, then `one_click`). The raster path needs the
+  same optional `@napi-rs/canvas` as `view_sheet`.
 - `load_plan` replaces the session by default; `merge: true` builds a multi-document working set (#152). Reloading a merged file is refused — reload = replace, deliberately.
 - The takeoff lives in memory. `export_takeoff` (the app's exact save payload,
   nothing lost in translation) and `export_marked_pdf` (the reviewable marked

package/dist/server-core.js

@@ -193,6 +193,19 @@ async function openPdf(filePath) {
             factory.destroy(target);
           }
         },
+        async renderRgba(scale, width, height) {
+          await ensureCanvasGlobals();
+          const rvp = page.getViewport({ scale });
+          const factory = doc.canvasFactory;
+          const target = factory.create(width, height);
+          try {
+            await page.render({ canvasContext: target.context, viewport: rvp, background: "#ffffff" }).promise;
+            const ctx = target.context;
+            return ctx.getImageData(0, 0, width, height).data;
+          } finally {
+            factory.destroy(target);
+          }
+        },
         async renderRegionPng(region, longEdge, draw) {
           await ensureCanvasGlobals();
           const w = region.x1 - region.x0;
@@ -1316,6 +1329,334 @@ var fail = (err) => ({
 var round2 = (n) => +n.toFixed(2);
 var round1 = (n) => +n.toFixed(1);
 
+// ../web/src/lib/rastermask.ts
+var RASTER_MIN_IMG_FRAC = 0.1;
+var RASTER_MIN_SEGS = 500;
+var RASTER_T = 0.15;
+var RASTER_ABS_INK = 100;
+var RASTER_WIN_MIN = 15;
+var RASTER_WIN_DIV = 32;
+var INVERT_MEAN = 128;
+var RASTER_RDP_EPS = 2.5;
+function toGray(rgba, n) {
+  const gray = new Uint8Array(n);
+  let sum = 0;
+  for (let i = 0, j = 0; i < n; i++, j += 4) {
+    const g = 77 * rgba[j] + 151 * rgba[j + 1] + 28 * rgba[j + 2] >> 8;
+    gray[i] = g;
+    sum += g;
+  }
+  return { gray, mean: n ? sum / n : 255 };
+}
+function interiorMean(gray, mw, mh, marginFrac = 0.12) {
+  const mx = Math.floor(mw * marginFrac), my = Math.floor(mh * marginFrac);
+  const x0 = mx, x1 = mw - mx, y0 = my, y1 = mh - my;
+  if (x1 <= x0 || y1 <= y0) {
+    let sum2 = 0;
+    for (let i = 0; i < gray.length; i++) sum2 += gray[i];
+    return gray.length ? sum2 / gray.length : 255;
+  }
+  let sum = 0, count = 0;
+  for (let y = y0; y < y1; y++) {
+    const row = y * mw;
+    for (let x = x0; x < x1; x++) {
+      sum += gray[row + x];
+      count++;
+    }
+  }
+  return count ? sum / count : 255;
+}
+function adaptiveThreshold(gray, mw, mh, t = RASTER_T, absInk = RASTER_ABS_INK) {
+  const iw = mw + 1;
+  const integral = new Uint32Array(iw * (mh + 1));
+  for (let y = 0; y < mh; y++) {
+    let rowSum = 0;
+    for (let x = 0; x < mw; x++) {
+      rowSum += gray[y * mw + x];
+      integral[(y + 1) * iw + (x + 1)] = integral[y * iw + (x + 1)] + rowSum;
+    }
+  }
+  const win = Math.max(RASTER_WIN_MIN, Math.round(Math.min(mw, mh) / RASTER_WIN_DIV)) | 1;
+  const half = win >> 1;
+  const out = new Uint8Array(mw * mh);
+  for (let y = 0; y < mh; y++) {
+    const y0 = Math.max(0, y - half), y1 = Math.min(mh - 1, y + half);
+    for (let x = 0; x < mw; x++) {
+      const x0 = Math.max(0, x - half), x1 = Math.min(mw - 1, x + half);
+      const area = (x1 - x0 + 1) * (y1 - y0 + 1);
+      const sum = integral[(y1 + 1) * iw + (x1 + 1)] - integral[y0 * iw + (x1 + 1)] - integral[(y1 + 1) * iw + x0] + integral[y0 * iw + x0];
+      const g = gray[y * mw + x];
+      if (g < absInk || g * area < sum * (1 - t)) out[y * mw + x] = 1;
+    }
+  }
+  return out;
+}
+function closeMask(mask, mw, mh) {
+  const pass = (src, horizontal, dilate) => {
+    const dst = new Uint8Array(mw * mh);
+    for (let y = 0; y < mh; y++) {
+      for (let x = 0; x < mw; x++) {
+        const i = y * mw + x;
+        let a, b, c;
+        if (horizontal) {
+          a = x > 0 ? src[i - 1] : src[i];
+          b = src[i];
+          c = x < mw - 1 ? src[i + 1] : src[i];
+        } else {
+          a = y > 0 ? src[i - mw] : src[i];
+          b = src[i];
+          c = y < mh - 1 ? src[i + mw] : src[i];
+        }
+        dst[i] = dilate ? a | b | c : a & b & c;
+      }
+    }
+    return dst;
+  };
+  let m = pass(mask, true, true);
+  m = pass(m, false, true);
+  m = pass(m, true, false);
+  m = pass(m, false, false);
+  return m;
+}
+function buildRasterMask(rgba, mw, mh, ws = 1, opts = {}) {
+  const n = mw * mh;
+  const { gray } = toGray(rgba, n);
+  const polarityMean = interiorMean(gray, mw, mh);
+  if (polarityMean < INVERT_MEAN) for (let i = 0; i < n; i++) gray[i] = 255 - gray[i];
+  let mask = adaptiveThreshold(gray, mw, mh, opts.t, opts.absInk);
+  if (opts.bridge !== false) mask = closeMask(mask, mw, mh);
+  return { mask, mw, mh, ws, softCount: 0 };
+}
+
+// ../web/src/lib/symbolsweep.ts
+var SWEEP_TOL_PX = 2;
+var SWEEP_SCORE_HIGH = 0.92;
+var SWEEP_SCORE_LOW = 0.75;
+var SWEEP_MAX_CANDIDATES = 2e4;
+var ANCHOR_COUNT = 3;
+var MIN_SEG_LEN = 0.5;
+var MAX_SEED_SEGS = 2e3;
+function transformsFor(rotations, mirror) {
+  const rots = [
+    [0, [1, 0, 0, 1]],
+    [90, [0, -1, 1, 0]],
+    [180, [-1, 0, 0, -1]],
+    [270, [0, 1, -1, 0]]
+  ];
+  const use = rotations ? rots : rots.slice(0, 1);
+  const out = use.map(([rotation, m]) => ({ rotation, mirrored: false, m }));
+  if (mirror) {
+    for (const [rotation, m] of use) out.push({ rotation, mirrored: true, m: [-m[0], m[1], -m[2], m[3]] });
+  }
+  return out;
+}
+var apply = (m, x, y) => [m[0] * x + m[1] * y, m[2] * x + m[3] * y];
+var EndpointGrid = class {
+  constructor(segs, tol) {
+    this.segs = segs;
+    this.cell = Math.max(2 * tol, 4);
+    const n = segs.length >> 2;
+    for (let i = 0; i < n; i++) {
+      this.add(segs[i * 4], segs[i * 4 + 1], i);
+      this.add(segs[i * 4 + 2], segs[i * 4 + 3], i);
+    }
+  }
+  cells = /* @__PURE__ */ new Map();
+  cell;
+  key(cx, cy) {
+    return cx * 73856093 ^ cy * 19349663;
+  }
+  add(x, y, i) {
+    const k = this.key(Math.floor(x / this.cell), Math.floor(y / this.cell));
+    const a = this.cells.get(k);
+    if (a) {
+      if (a[a.length - 1] !== i) a.push(i);
+    } else this.cells.set(k, [i]);
+  }
+  /** Indices of segments with an endpoint within one cell of (x, y). */
+  near(x, y, out) {
+    out.length = 0;
+    const cx = Math.floor(x / this.cell), cy = Math.floor(y / this.cell);
+    for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+      const a = this.cells.get(this.key(cx + dx, cy + dy));
+      if (a) for (const i of a) out.push(i);
+    }
+    return out;
+  }
+};
+var segLen = (segs, i) => Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+function sweepSymbols(segs, seedRect, opts = {}) {
+  const tol = opts.tolPx ?? SWEEP_TOL_PX;
+  const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
+  const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
+  const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
+  const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
+  const n = segs.length >> 2;
+  const rx0 = Math.min(seedRect[0][0], seedRect[1][0]), rx1 = Math.max(seedRect[0][0], seedRect[1][0]);
+  const ry0 = Math.min(seedRect[0][1], seedRect[1][1]), ry1 = Math.max(seedRect[0][1], seedRect[1][1]);
+  const inside = (x, y) => x >= rx0 && x <= rx1 && y >= ry0 && y <= ry1;
+  const seedIdx = [];
+  for (let i = 0; i < n; i++) {
+    if (inside(segs[i * 4], segs[i * 4 + 1]) && inside(segs[i * 4 + 2], segs[i * 4 + 3]) && segLen(segs, i) >= MIN_SEG_LEN) {
+      seedIdx.push(i);
+    }
+  }
+  if (!seedIdx.length) {
+    throw new Error("No vector segments sit fully inside the seed rect \u2014 marquee tightly around one whole symbol instance (segments crossing the rect edge don't count as the symbol).");
+  }
+  if (seedIdx.length > MAX_SEED_SEGS) {
+    throw new Error(`The seed rect holds ${seedIdx.length} segments \u2014 that is a region, not one symbol instance. Marquee a single symbol.`);
+  }
+  let totalLen = 0, cxw = 0, cyw = 0;
+  for (const i of seedIdx) {
+    const L = segLen(segs, i);
+    totalLen += L;
+    cxw += (segs[i * 4] + segs[i * 4 + 2]) / 2 * L;
+    cyw += (segs[i * 4 + 1] + segs[i * 4 + 3]) / 2 * L;
+  }
+  const seedCx = cxw / totalLen, seedCy = cyw / totalLen;
+  const rel = seedIdx.map((i) => [
+    segs[i * 4] - seedCx,
+    segs[i * 4 + 1] - seedCy,
+    segs[i * 4 + 2] - seedCx,
+    segs[i * 4 + 3] - seedCy,
+    segLen(segs, i)
+  ]);
+  let sbx0 = Infinity, sby0 = Infinity, sbx1 = -Infinity, sby1 = -Infinity;
+  for (const i of seedIdx) {
+    sbx0 = Math.min(sbx0, segs[i * 4], segs[i * 4 + 2]);
+    sby0 = Math.min(sby0, segs[i * 4 + 1], segs[i * 4 + 3]);
+    sbx1 = Math.max(sbx1, segs[i * 4], segs[i * 4 + 2]);
+    sby1 = Math.max(sby1, segs[i * 4 + 1], segs[i * 4 + 3]);
+  }
+  const lenBucket = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const b = Math.round(segLen(segs, i));
+    const a = lenBucket.get(b);
+    if (a) a.push(i);
+    else lenBucket.set(b, [i]);
+  }
+  const bucketBand = (L) => {
+    const out = [];
+    for (let b = Math.floor(L - 2 * tol); b <= Math.ceil(L + 2 * tol); b++) {
+      const a = lenBucket.get(b);
+      if (a) {
+        for (const i of a) if (Math.abs(segLen(segs, i) - L) <= 2 * tol) out.push(i);
+      }
+    }
+    return out;
+  };
+  const byLenQ = /* @__PURE__ */ new Map();
+  for (let k = 0; k < rel.length; k++) {
+    const L = rel[k][4];
+    const q = Math.round(L);
+    if (!byLenQ.has(q)) byLenQ.set(q, { relIdx: k, len: L, rarity: bucketBand(L).length });
+  }
+  const anchors = [...byLenQ.values()].sort((a, b) => a.rarity - b.rarity || b.len - a.len || a.relIdx - b.relIdx).slice(0, ANCHOR_COUNT);
+  const proposals = [];
+  const seen = /* @__PURE__ */ new Set();
+  const quant = Math.max(tol, 1);
+  for (let xi = 0; xi < xforms.length; xi++) {
+    const { m } = xforms[xi];
+    for (const anc of anchors) {
+      const r = rel[anc.relIdx];
+      const A = apply(m, r[0], r[1]);
+      const B = apply(m, r[2], r[3]);
+      for (const j of bucketBand(anc.len)) {
+        const px = segs[j * 4], py = segs[j * 4 + 1], qx = segs[j * 4 + 2], qy = segs[j * 4 + 3];
+        for (const [ax, ay, bx, by] of [[A[0], A[1], B[0], B[1]], [B[0], B[1], A[0], A[1]]]) {
+          const c1x = px - ax, c1y = py - ay;
+          const c2x = qx - bx, c2y = qy - by;
+          if (Math.abs(c1x - c2x) > 2 * tol || Math.abs(c1y - c2y) > 2 * tol) continue;
+          const tx = (c1x + c2x) / 2, ty = (c1y + c2y) / 2;
+          const key = `${xi}:${Math.round(tx / quant)}:${Math.round(ty / quant)}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          proposals.push({ tx, ty, xf: xi });
+        }
+      }
+    }
+  }
+  proposals.sort((a, b) => a.ty - b.ty || a.tx - b.tx || a.xf - b.xf);
+  const considered = Math.min(proposals.length, maxCandidates);
+  const dropped = proposals.length - considered;
+  const grid = new EndpointGrid(segs, tol);
+  const scratch = [];
+  const tol2 = tol * tol;
+  const near = (x1, y1, x2, y2) => (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) <= tol2;
+  const scoreAt = (m, tx, ty) => {
+    let matched = 0;
+    for (const r of rel) {
+      const a = apply(m, r[0], r[1]);
+      const b = apply(m, r[2], r[3]);
+      const ax = a[0] + tx, ay = a[1] + ty, bx = b[0] + tx, by = b[1] + ty;
+      let hit = false;
+      for (const j of grid.near(ax, ay, scratch)) {
+        const px = segs[j * 4], py = segs[j * 4 + 1], qx = segs[j * 4 + 2], qy = segs[j * 4 + 3];
+        if (near(px, py, ax, ay) && near(qx, qy, bx, by) || near(qx, qy, ax, ay) && near(px, py, bx, by)) {
+          hit = true;
+          break;
+        }
+      }
+      if (hit) matched += r[4];
+    }
+    return matched / totalLen;
+  };
+  const scored = [];
+  for (let k = 0; k < considered; k++) {
+    const c = proposals[k];
+    const score = scoreAt(xforms[c.xf].m, c.tx, c.ty);
+    if (score < scoreLow) continue;
+    scored.push({ at: [c.tx, c.ty], score, rotation: xforms[c.xf].rotation, mirrored: xforms[c.xf].mirrored, xf: c.xf });
+  }
+  const mergeR = Math.max(2 * tol, 4);
+  const kept = [];
+  for (const s of scored) {
+    const twin = kept.find((k) => Math.hypot(k.at[0] - s.at[0], k.at[1] - s.at[1]) <= mergeR);
+    if (!twin) {
+      kept.push(s);
+      continue;
+    }
+    if (s.score > twin.score || s.score === twin.score && s.xf < twin.xf) {
+      twin.at = s.at;
+      twin.score = s.score;
+      twin.rotation = s.rotation;
+      twin.mirrored = s.mirrored;
+      twin.xf = s.xf;
+    }
+  }
+  const suppressR = Math.max(mergeR, Math.hypot(sbx1 - sbx0, sby1 - sby0) / 2);
+  const away = kept.filter((s) => Math.hypot(s.at[0] - seedCx, s.at[1] - seedCy) > suppressR);
+  const matches = [];
+  const withheld = [];
+  const pct = (v) => Math.round(v * 1e3) / 1e3;
+  const row = (s) => ({
+    at: [Math.round(s.at[0] * 10) / 10, Math.round(s.at[1] * 10) / 10],
+    score: pct(s.score),
+    rotation: s.rotation,
+    mirrored: s.mirrored
+  });
+  for (const s of away) if (s.score >= scoreHigh) matches.push(row(s));
+  for (const s of away) {
+    if (s.score >= scoreHigh) continue;
+    if (matches.some((m) => Math.hypot(m.at[0] - s.at[0], m.at[1] - s.at[1]) <= suppressR)) continue;
+    withheld.push({ ...row(s), reason: `matched ${Math.round(s.score * 100)}% of the seed's linework (commit bar ${Math.round(scoreHigh * 100)}%) \u2014 likely a variant or an overlapped instance; look before counting it` });
+  }
+  const order = (a, b) => a.at[1] - b.at[1] || a.at[0] - b.at[0] || a.rotation - b.rotation || Number(a.mirrored) - Number(b.mirrored);
+  matches.sort(order);
+  withheld.sort(order);
+  return {
+    seed: {
+      segments: seedIdx.length,
+      center: [Math.round(seedCx * 10) / 10, Math.round(seedCy * 10) / 10],
+      length_px: Math.round(totalLen * 10) / 10
+    },
+    matches,
+    withheld,
+    candidates: { considered, dropped }
+  };
+}
+
 // ../web/src/lib/geometry.js
 function starPath(cx, cy, R, points = 4, innerRatio = 0.38) {
   const r = R * innerRatio;
@@ -1463,6 +1804,21 @@ function attrValue(attrs, colId) {
   return visible(attrs?.[colId]);
 }
 
+// ../web/src/lib/units.ts
+var M_PER_FT = 0.3048;
+function dimLabel(feet, units = "imperial") {
+  if (!Number.isFinite(feet)) return "";
+  if (units === "metric") return `${(feet * M_PER_FT).toFixed(2)} m`;
+  const sign = feet < 0 ? "-" : "";
+  let ft = Math.floor(Math.abs(feet) + 1e-9);
+  let inch = Math.round((Math.abs(feet) - ft) * 12);
+  if (inch === 12) {
+    ft += 1;
+    inch = 0;
+  }
+  return `${sign}${ft}'-${inch}"`;
+}
+
 // ../web/src/lib/totals.js
 function accumulateRole(acc, s) {
   const cp = s.computed || {};
@@ -2621,9 +2977,9 @@ var Session = class _Session {
     }
     return segRoles(geo.layerOf, layerRoleCodes(geo.layerIds, infoById));
   }
-  /** v1 masks come from the sheet's vector linework only. Raster seam: a scanned
-   * sheet would render via a node canvas into a future rastermask module that
-   * returns this same MaskObj shape. Layer roles (#85) ride in as the stated
+  /** v1 masks come from the sheet's vector linework only; a scanned sheet
+   * (zero segments) is null here and the measuring tools fall back to
+   * ensureRasterMask (#154). Layer roles (#85) ride in as the stated
    * short-circuit; an unlayered sheet builds the identical pre-#85 mask. */
   async ensureMask(name) {
     const s = this.sheet(name);
@@ -2643,6 +2999,46 @@ var Session = class _Session {
     if (!geo.segs.length) return null;
     return buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta, this.rolesFor(s, geo, layersOpt));
   }
+  /** The raster-fallback mask (#154): a dedicated render of the sheet at mask
+   * scale (the view_sheet machinery — pdf.ts + @napi-rs/canvas), thresholded
+   * by the canvas's own rastermask engine into the same MaskObj shape
+   * buildMask emits, so floodRegion/traceRegion run unchanged on scans.
+   * Cached per sheet like geo/mask; where the optional native canvas never
+   * installed, renderRgba throws its plain install-hint Error and the tool
+   * reply carries it — a stated inability, never a guessed polygon. */
+  async ensureRasterMask(s) {
+    if (!s.rmask) {
+      const ws = Math.min(1, MASK_MAX_DIM / Math.max(s.widthPx, s.heightPx, 1));
+      const mw = Math.max(2, Math.ceil(s.widthPx * ws));
+      const mh = Math.max(2, Math.ceil(s.heightPx * ws));
+      const rgba = await s.page.renderRgba(RENDER_SCALE * ws, mw, mh);
+      s.rmask = buildRasterMask(rgba, mw, mh, ws);
+    }
+    return s.rmask;
+  }
+  /** The canvas's trigger policy (#154), verbatim (TakeoffCanvas.jsx /
+   * rastermask.ts constants): raster-ELIGIBLE = placed-image area covers
+   * ≥ RASTER_MIN_IMG_FRAC of the sheet (a scan wrapper or photo underlay);
+   * vector-VIABLE = enough segments that the vector mask can bound rooms.
+   * Vector is exact and always wins where it works — a pure-vector sheet
+   * never touches pixels; a scan wrapper with near-zero linework runs raster
+   * primary; a mixed sheet retries on pixels only after the vector flood
+   * fails. */
+  rasterPolicy(s, geo) {
+    const sheetArea = s.widthPx * s.heightPx;
+    return {
+      rasterEligible: sheetArea > 0 && geo.imageArea / sheetArea >= RASTER_MIN_IMG_FRAC,
+      vectorViable: geo.segs.length >> 2 >= RASTER_MIN_SEGS
+    };
+  }
+  /** Layer overrides (#85) name PDF Optional Content — scan pixels carry
+   * none, so a raster-path call that stated them is refused rather than
+   * silently no-opped (the rolesFor resolve-or-error doctrine). */
+  refuseLayersOnRaster(layersOpt) {
+    if (layersOpt && (layersOpt.include?.length || layersOpt.exclude?.length)) {
+      throw new UserError("Layer overrides can't apply here \u2014 this flood runs on the sheet's rendered pixels (raster fallback), and scan ink carries no PDF layers. Retry without layers.");
+    }
+  }
   async sheetInfo(name) {
     const s = this.sheet(name);
     const geo = await this.ensureGeometry(s);
@@ -2758,12 +3154,31 @@ var Session = class _Session {
   }
   async oneClick(name, x, y, opts) {
     const s = this.sheet(name);
-    const mask = await this.maskWithLayers(name, opts.layers);
-    if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
-    const f = floodRegion(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
-    if (f.status === "leak") throw new UserError("That space isn't enclosed on the plan linework \u2014 the fill spilled through a gap or opening.");
-    if (f.status !== "ok") throw new UserError("Landed in dense linework (hatching or text).");
-    const ring = snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
+    const { rasterEligible, vectorViable } = this.rasterPolicy(s, await this.ensureGeometry(s));
+    let f = null;
+    let raster = false;
+    if (!rasterEligible || vectorViable) {
+      const mask = await this.maskWithLayers(name, opts.layers);
+      if (!mask && !rasterEligible) throw new UserError("This sheet has no vector linework and no scan image to flood \u2014 nothing here bounds a region. Trace the space with measure_polygon instead.");
+      if (mask) {
+        const r = floodRegion(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
+        if (r.status === "ok") f = r;
+        else if (!rasterEligible) {
+          if (r.status === "leak") throw new UserError("That space isn't enclosed on the plan linework \u2014 the fill spilled through a gap or opening.");
+          throw new UserError("Landed in dense linework (hatching or text).");
+        }
+      }
+    }
+    if (!f) {
+      this.refuseLayersOnRaster(opts.layers);
+      const rmask = await this.ensureRasterMask(s);
+      const r = floodRegion(rmask, x, y);
+      if (r.status === "leak") throw new UserError("That space isn't enclosed on the scan \u2014 the fill escaped through a gap (faded line or open doorway). Seed a more enclosed spot, or trace it with measure_polygon.");
+      if (r.status !== "ok") throw new UserError("Landed on dense scan ink (text or hatching). Seed an open spot inside the room.");
+      f = r;
+      raster = true;
+    }
+    const ring = raster ? traceRegion(f, RASTER_RDP_EPS) : snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
     if (ring.length < 3) throw new UserError("Couldn't trace that space into a polygon.");
     const areaPx2 = ringArea(ring);
     const perimPx = closedMetrics(ring).perim;
@@ -2772,6 +3187,9 @@ var Session = class _Session {
       nverts: ring.length,
       ...f.hatchFiltered ? { hatch_filtered: true } : {},
       ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
+      // which path ran, disclosed both ways (#154): present = pixels bounded
+      // this trace, absent = the vector linework did
+      ...raster ? { raster_traced: true } : {},
       ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
     };
     if (s.upp == null) {
@@ -2794,12 +3212,18 @@ var Session = class _Session {
         reviewed: false,
         ...f.hatchFiltered ? { hatch_filtered: true } : {},
         ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
+        // #154 — a trace whose boundary was scan PIXELS is a different claim
+        // than one bounded by vector linework; the record says which (the
+        // canvas's raster_traced vocabulary, contribution.v2)
+        ...raster ? { raster_traced: true } : {},
         // #85 — a trace bounded by DECLARED boundary layers is categorically
-        // stronger evidence than one bounded by a pitch heuristic
-        ...(s.layers || []).some((l) => l.visible && (l.role === "boundary" || l.role === "structure")) ? { layer_bounded: true } : {},
+        // stronger evidence than one bounded by a pitch heuristic (vector
+        // path only: the raster mask never saw the layer table)
+        ...!raster && (s.layers || []).some((l) => l.visible && (l.role === "boundary" || l.role === "structure")) ? { layer_bounded: true } : {},
         // canvas-parity provenance: a non-default fill sensitivity is part of
-        // how the shape was made (ShapeOrigin.fill_sensitivity)
-        ...opts.sensitivity !== void 0 && opts.sensitivity !== SENS_BALANCED ? { fill_sensitivity: opts.sensitivity } : {}
+        // how the shape was made (ShapeOrigin.fill_sensitivity) — vector path
+        // only; the knob is inert on a single-tier raster mask
+        ...!raster && opts.sensitivity !== void 0 && opts.sensitivity !== SENS_BALANCED ? { fill_sensitivity: opts.sensitivity } : {}
       }).id;
     }
     this.flushCommits("one_click");
@@ -2848,8 +3272,17 @@ var Session = class _Session {
         throw new UserError("No room-finish schedule in the working set \u2014 load_plan the schedule sheet with merge: true, or pass condition to commit every room under one tag.");
       }
     }
-    const mask = await this.maskWithLayers(name, opts.layers);
-    if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
+    const geo = await this.ensureGeometry(s);
+    const { rasterEligible, vectorViable } = this.rasterPolicy(s, geo);
+    let mask = null;
+    let raster = false;
+    if (!rasterEligible || vectorViable) mask = await this.maskWithLayers(name, opts.layers);
+    if (!mask) {
+      if (!rasterEligible) throw new UserError("This sheet has no vector linework and no scan image to flood \u2014 nothing here bounds a region. Trace rooms with measure_polygon instead.");
+      this.refuseLayersOnRaster(opts.layers);
+      mask = await this.ensureRasterMask(s);
+      raster = true;
+    }
     const minAreaSf = opts.minAreaSf ?? 5;
     if (!s.spans) s.spans = textSpans(s.page);
     const labels = [];
@@ -2867,7 +3300,7 @@ var Session = class _Session {
       for (const probe of seedLadderPx(lb.bbox)) {
         const f = floodRegion(mask, probe[0], probe[1], opts.sensitivity ?? SENS_BALANCED);
         if (f.status !== "ok") continue;
-        const r = snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
+        const r = raster ? traceRegion(f, RASTER_RDP_EPS) : snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
         if (r.length < 3) {
           sawDegenerate = true;
           continue;
@@ -2915,6 +3348,7 @@ var Session = class _Session {
         ...c.merged.length ? { merged_labels: c.merged } : {},
         ...c.hatch ? { hatch_filtered: true } : {},
         ...c.gap ? { gap_bridged_px: c.gap } : {},
+        ...raster ? { raster_traced: true } : {},
         ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
       };
       if (upp == null) {
@@ -2947,6 +3381,7 @@ var Session = class _Session {
           reviewed: false,
           ...c.hatch ? { hatch_filtered: true } : {},
           ...c.gap ? { gap_bridged_px: c.gap } : {},
+          ...raster ? { raster_traced: true } : {},
           ...assignment ? { assignment } : {}
         }).id;
       }
@@ -3090,15 +3525,99 @@ var Session = class _Session {
    * computed {count: 1}, NO scale required (EA is scale-free; the canvas's
    * recompute skips count shapes for the same reason). One shape per point,
    * the whole call one journal gesture — undoing a placement sweep is one step,
-   * matching detect_rooms. */
+   * matching detect_rooms.
+   *
+   * `origins` (optional, aligned with points) lets a derived tool commit
+   * through this same path while telling the truth about the method —
+   * symbol_sweep stamps `{method: "symbol_sweep", …, symbol: {score, …}}` per
+   * marker; a bare place_count stays exactly the manual agent gesture it is. */
   placeCount(name, points, opts) {
     const s = this.sheet(name);
-    const ids = points.map(([x, y]) => this.commit(s, opts.condition, "count", [[x, y]], { count: 1 }, { method: "manual", actor: "agent" }).id);
-    this.flushCommits("place_count");
+    const ids = points.map(([x, y], i) => this.commit(
+      s,
+      opts.condition,
+      "count",
+      [[x, y]],
+      { count: 1 },
+      opts.origins?.[i] ? { ...opts.origins[i] } : { method: "manual", actor: "agent" }
+    ).id);
+    this.flushCommits(opts.tool ?? "place_count");
     const c = this.conditions.find((x) => x.finish_tag === opts.condition);
     const ea_total = this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "count").reduce((n, x) => n + (x.computed.count || 1), 0);
     return { committed: ids.length, shape_ids: ids, condition: c.finish_tag, ea_total };
   }
+  /** symbol_sweep — every placement of ONE example symbol, from the linework.
+   * The engine is pure (web/src/lib/symbolsweep.ts): fingerprint the seed
+   * rect's segments, propose placements by constellation anchoring under the
+   * square symmetry group, score each as the length-weighted fraction of seed
+   * segments reproduced within tolerance. This method is the plumbing plus
+   * the wire shapes: rect clamping, the scan refusal, and the commit path —
+   * match centers through placeCount (ONE undo step, EA scale-free), origins
+   * telling the truth (`method: "symbol_sweep"`, per-match score/transform),
+   * withheld placements NEVER committed. */
+  async symbolSweep(name, opts) {
+    const s = this.sheet(name);
+    if (opts.commit && !opts.condition) {
+      throw new UserError("commit: true needs a condition \u2014 the finish tag the match markers count under (e.g. 'FD-1').");
+    }
+    const geo = await this.ensureGeometry(s);
+    if (!geo.segs.length) {
+      throw new UserError("This sheet has no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments; raster fallback not yet available in the MCP server.");
+    }
+    const clampX = (v) => Math.max(0, Math.min(v, s.widthPx));
+    const clampY = (v) => Math.max(0, Math.min(v, s.heightPx));
+    const rect = [
+      [clampX(opts.seedRect[0][0]), clampY(opts.seedRect[0][1])],
+      [clampX(opts.seedRect[1][0]), clampY(opts.seedRect[1][1])]
+    ];
+    if (!(Math.abs(rect[1][0] - rect[0][0]) >= 1 && Math.abs(rect[1][1] - rect[0][1]) >= 1)) {
+      throw new UserError(`Empty seed rect \u2014 need two distinct corners in image px inside the sheet (${s.widthPx} \xD7 ${s.heightPx}).`);
+    }
+    const sweepOpts = {
+      rotations: opts.rotations ?? true,
+      mirror: opts.mirror ?? true,
+      tolPx: opts.tolerancePx ?? SWEEP_TOL_PX
+    };
+    let res;
+    try {
+      res = sweepSymbols(geo.segs, rect, sweepOpts);
+    } catch (e) {
+      throw new UserError(e instanceof Error ? e.message : String(e));
+    }
+    let committed;
+    if (opts.commit && res.matches.length) {
+      committed = this.placeCount(name, res.matches.map((m) => m.at), {
+        condition: opts.condition,
+        tool: "symbol_sweep",
+        origins: res.matches.map((m) => ({
+          method: "symbol_sweep",
+          actor: "agent",
+          reviewed: false,
+          symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored }
+        }))
+      });
+    }
+    return {
+      found: res.matches.length,
+      matches: res.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
+      withheld: res.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
+      seed: {
+        segments: res.seed.segments,
+        center: [round1(res.seed.center[0]), round1(res.seed.center[1])],
+        rect: [round1(rect[0][0]), round1(rect[0][1]), round1(rect[1][0]), round1(rect[1][1])],
+        length_px: res.seed.length_px
+      },
+      candidates: res.candidates,
+      ...committed ? {
+        committed: committed.committed,
+        shape_ids: committed.shape_ids,
+        condition: committed.condition,
+        ea_total: committed.ea_total
+      } : {},
+      ...opts.commit && !res.matches.length ? { note: "commit requested but nothing cleared the bar \u2014 no shapes were committed." } : {},
+      ...res.candidates.dropped > 0 ? { warning: `Work cap: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 the seed's linework is too common on this sheet for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep a region at a time and reconcile the counts.` } : {}
+    };
+  }
   /** The mid-session shape inventory (#149): every committed shape's id,
    * home, role, and quantities in one compact read — the ids edit_shape /
    * delete_shape assume you have, without pulling the whole export_takeoff
@@ -3418,7 +3937,14 @@ var Session = class _Session {
     if ((a.type === "cloud" || a.type === "highlight") && !a.rect) throw new UserError(`a ${a.type} needs rect: [[x0,y0],[x1,y1]] in image px`);
     if ((a.type === "text" || a.type === "callout" || a.type === "bubble") && !a.at) throw new UserError(`a ${a.type} needs at: [x,y] in image px`);
     if (a.type === "callout" && !a.target) throw new UserError("a callout needs target: [x,y] \u2014 the point the leader line aims at");
-    if (a.type === "arrow" && (!a.from || !a.to)) throw new UserError("an arrow needs from: [x,y] and to: [x,y] \u2014 tail and head, in image px");
+    if ((a.type === "arrow" || a.type === "dimension") && (!a.from || !a.to)) {
+      throw new UserError(a.type === "arrow" ? "an arrow needs from: [x,y] and to: [x,y] \u2014 tail and head, in image px" : "a dimension needs from: [x,y] and to: [x,y] \u2014 its two measured endpoints, in image px");
+    }
+    let len_ft;
+    if (a.type === "dimension") {
+      if (s.upp == null) throw new UserError(this.scaleGate(s));
+      len_ft = round2(Math.hypot(a.to[0] - a.from[0], a.to[1] - a.from[1]) * s.upp);
+    }
     const cond = a.condition ? this.conditionFor(a.condition) : null;
     const m = {
       id: uid("mk"),
@@ -3435,7 +3961,10 @@ var Session = class _Session {
       ...a.to ? { to: n(a.to) } : {},
       // bubble radius: px → fraction of sheet WIDTH (marked-set frame); the
       // canvas default is 0.02 when unset — stored explicitly so exports agree
-      ...a.type === "bubble" ? { r: a.r != null ? a.r / s.widthPx : 0.02 } : {}
+      ...a.type === "bubble" ? { r: a.r != null ? a.r / s.widthPx : 0.02 } : {},
+      // dimension: the measured length rides the markup so the renderers
+      // (canvas, marked set) draw the label without scale plumbing
+      ...len_ft !== void 0 ? { len_ft } : {}
     };
     this.markups.push(m);
     return {
@@ -3445,6 +3974,7 @@ var Session = class _Session {
       text: m.text,
       condition: cond?.finish_tag ?? "",
       condition_id: m.condition_id,
+      ...len_ft !== void 0 ? { length_lf: len_ft } : {},
       note: cond ? `Attached to ${cond.finish_tag} \u2014 it wears that condition's colour on the canvas and in the marked set.` : "Unattached \u2014 a note about the sheet. Pass condition to tie it to a scope."
     };
   }
@@ -3482,7 +4012,8 @@ var Session = class _Session {
         ...m.rect ? { rect: [px(m, m.rect[0]), px(m, m.rect[1])] } : {},
         ...m.from ? { from: px(m, m.from) } : {},
         ...m.to ? { to: px(m, m.to) } : {},
-        ...m.r != null ? { r: round1(m.r * (s0.get(m.sheet_id)?.widthPx ?? 0)) } : {}
+        ...m.r != null ? { r: round1(m.r * (s0.get(m.sheet_id)?.widthPx ?? 0)) } : {},
+        ...m.len_ft != null ? { length_lf: m.len_ft } : {}
       })),
       count: rows.length,
       unattached: rows.filter((m) => !m.condition_id).length
@@ -3745,6 +4276,7 @@ var oneClickOutput = {
   nverts: z.number().int().describe("Vertex count of the traced polygon"),
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
   gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region \u2014 the rescue rides provenance (origin.gap_bridged_px) rather than passing as a clean fill"),
+  raster_traced: z.literal(true).optional().describe("Present when the region was bounded by the sheet's RENDERED PIXELS (the scanned-sheet raster fallback, #154) rather than vector linework \u2014 absent means the vector path ran. Rides origin.raster_traced on the committed shape; a raster ring's corners are unsnapped (a scan has no true endpoints), so audit it with view_sheet overlay before trusting the total"),
   verts: z.array(point).optional().describe("Traced polygon vertices (image px), when return_verts was set"),
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
@@ -3759,6 +4291,7 @@ var detectedRoom = z.object({
   merged_labels: z.array(z.string()).optional().describe("Other labels that flooded to this same region \u2014 the area is counted once, under `label`"),
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
   gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region"),
+  raster_traced: z.literal(true).optional().describe("Present when the room was bounded by rendered pixels (scanned-sheet raster fallback, #154) rather than vector linework \u2014 sheet-wide per sweep, and it rides origin.raster_traced on the committed shape"),
   verts: z.array(point).optional().describe("Traced polygon vertices (image px), when return_verts was set"),
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
@@ -3811,6 +4344,33 @@ var placeCountOutput = {
   condition: z.string(),
   ea_total: z.number().describe("The condition's total EA after this call")
 };
+var sweepPlacement = {
+  at: z.tuple([z.number(), z.number()]).describe("The placed symbol's centroid (image px) \u2014 the point a commit places its count marker at"),
+  score: z.number().describe("Length-weighted fraction of the seed's segments matched within tolerance, 0..1"),
+  rotation: z.number().describe("Detected rotation in degrees (0 | 90 | 180 | 270)"),
+  mirrored: z.boolean()
+};
+var symbolSweepOutput = {
+  found: z.number().int().describe("Placements that cleared the commit bar \u2014 matches.length"),
+  matches: z.array(z.object(sweepPlacement)).describe("Deterministic reading order (y, then x). The seed's own location is never listed here"),
+  withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })).describe("Near-matches in the [0.75, 0.92) band \u2014 reported with a reason, NEVER committed. A withheld placement is a question you can answer with view_sheet; a hidden one is a miscount"),
+  seed: z.object({
+    segments: z.number().int().describe("Vector segments fully inside the seed rect \u2014 the fingerprint"),
+    center: z.tuple([z.number(), z.number()]).describe("The seed instance's own centroid (image px) \u2014 reported here, never double-committed as a match"),
+    rect: z.array(z.number()).length(4).describe("The seed rect actually used, post-clamp [x0, y0, x1, y1]"),
+    length_px: z.number().describe("Total seed linework length, image px")
+  }),
+  candidates: z.object({
+    considered: z.number().int(),
+    dropped: z.number().int().describe("Placements never scored because the work cap bit \u2014 always disclosed, never silent")
+  }),
+  committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per match"),
+  shape_ids: z.array(z.string()).optional(),
+  condition: z.string().optional().describe("commit mode: the finish tag the markers counted under"),
+  ea_total: z.number().optional().describe("commit mode: the condition's total EA after this call"),
+  note: z.string().optional(),
+  warning: z.string().optional().describe("Present when the work cap dropped candidates \u2014 what a tighter seed rect would recover")
+};
 var measureLineOutput = {
   length_lf: z.number(),
   npts: z.number().int(),
@@ -4129,9 +4689,10 @@ var annotationRow = z.object({
   at: z.tuple([z.number(), z.number()]).optional(),
   target: z.tuple([z.number(), z.number()]).optional(),
   rect: z.array(z.tuple([z.number(), z.number()]).optional()).optional(),
-  from: z.tuple([z.number(), z.number()]).optional().describe("Arrow tail (image px)"),
-  to: z.tuple([z.number(), z.number()]).optional().describe("Arrow head (image px)"),
-  r: z.number().optional().describe("Bubble radius (image px)")
+  from: z.tuple([z.number(), z.number()]).optional().describe("Arrow tail / dimension start (image px)"),
+  to: z.tuple([z.number(), z.number()]).optional().describe("Arrow head / dimension end (image px)"),
+  r: z.number().optional().describe("Bubble radius (image px)"),
+  length_lf: z.number().optional().describe("Dimension only: the measured length in real feet, snapshotted at annotate time from the sheet scale")
 });
 var annotateOutput = {
   id: z.string(),
@@ -4140,6 +4701,7 @@ var annotateOutput = {
   text: z.string(),
   condition: z.string(),
   condition_id: z.string(),
+  length_lf: z.number().optional().describe("Dimension only: the measured length (real feet) the annotation will label itself with"),
   note: z.string()
 };
 var listAnnotationsOutput = {
@@ -4158,6 +4720,24 @@ var linkAnnotationOutput = {
 import path3 from "node:path";
 import { readFile as readFile2, writeFile } from "node:fs/promises";
 
+// ../web/src/lib/approvals.js
+var APPROVAL_R = 0.022;
+var APPROVAL_INK = {
+  estimator: { light: "#1f6b4a", dark: "#55b083" },
+  agent: { light: "#6c6a5e", dark: "#9d9a8c" }
+};
+function approvalInk(actor, dark = false) {
+  const c = APPROVAL_INK[actor] || APPROVAL_INK.agent;
+  return dark ? c.dark : c.light;
+}
+function approvalTally(approvals) {
+  const t = { estimator: 0, agent: 0 };
+  for (const a of Array.isArray(approvals) ? approvals : []) {
+    if (a && a.actor in t) t[a.actor] += 1;
+  }
+  return t;
+}
+
 // ../web/src/lib/svgpath.js
 function isSep(c) {
   return c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === ",";
@@ -4813,7 +5393,7 @@ function invertPixels(cv) {
   ctx.fillRect(0, 0, cv.width, cv.height);
   ctx.restore();
 }
-async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, provenance = null, coverTitle = "Marked Set", units = "imperial" }) {
+async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, approvals = [], rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, provenance = null, coverTitle = "Marked Set", units = "imperial" }) {
   const M = units === "metric";
   const uA = (sf) => M ? sf * 0.09290304 : sf;
   const uL = (lf) => M ? lf * 0.3048 : lf;
@@ -4830,8 +5410,8 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
     }
     return m;
   };
-  const shapesBy = byKey(shapes), marksBy = byKey(markups);
-  const marked = sheets.filter((sh) => (shapesBy.get(sh.key) || []).length || (marksBy.get(sh.key) || []).length);
+  const shapesBy = byKey(shapes), marksBy = byKey(markups), apBy = byKey(approvals);
+  const marked = sheets.filter((sh) => (shapesBy.get(sh.key) || []).length || (marksBy.get(sh.key) || []).length || (apBy.get(sh.key) || []).length);
   if (!marked.length && !rfis?.length) throw new Error("Nothing to export \u2014 no sheet carries takeoffs or markups.");
   const markedShapes = marked.flatMap((sh) => shapesBy.get(sh.key) || []);
   const doc = await PDFDocument.create();
@@ -4907,6 +5487,11 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
       metaY -= 12;
       draw(provenance, { x: 52, y: metaY, size: 9.5, font, color: muted });
     }
+    const apCount = approvalTally(marked.flatMap((sh) => apBy.get(sh.key) || []));
+    if (apCount.estimator || apCount.agent) {
+      metaY -= 12;
+      draw(`Approval stamps: ${apCount.estimator} estimator-approved \xB7 ${apCount.agent} agent-marked`, { x: 52, y: metaY, size: 9.5, font, color: muted });
+    }
     let y = metaY - 34;
     const rows = conditionTotals(conditions, markedShapes).filter((r) => r.shape_count > 0);
     draw("CONDITIONS", { x: 52, y, size: 9, font: bold, color: muted });
@@ -4935,7 +5520,7 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
     for (const sh of marked) {
       if (y < 90) break;
       const items = shapesBy.get(sh.key) || [];
-      draw(`${sh.label} \xB7 page ${sh.page} \xB7 ${items.length + (marksBy.get(sh.key) || []).length} item(s)`, { x: 52, y, size: 9.5, font: bold, color: ink });
+      draw(`${sh.label} \xB7 page ${sh.page} \xB7 ${items.length + (marksBy.get(sh.key) || []).length + (apBy.get(sh.key) || []).length} item(s)`, { x: 52, y, size: 9.5, font: bold, color: ink });
       y -= 13;
       for (const r of bySheetId.get(sh.key)?.rows || []) {
         if (y < 92) break;
@@ -5177,6 +5762,21 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
         pg.drawSvgPath(arrowheadPath(pfx, -pfy, ptx, -pty, 6 * mw), { x: 0, y: 0, color: mcol, opacity: 0.95 });
         const t = lbl(m.text);
         if (t) text(t, (m.from[0] + m.to[0]) / 2 * W, (m.from[1] + m.to[1]) / 2 * H - 6 / ptScale, 8, mcol, bold);
+      } else if (m.type === "dimension" && m.from && m.to) {
+        const fx = m.from[0] * W, fy = m.from[1] * H, dxq = m.to[0] * W, dyq = m.to[1] * H;
+        line(fx, fy, dxq, dyq, mcol, 1.1 * mw, 0.95, mdash);
+        const dl = Math.hypot(dxq - fx, dyq - fy) || 1;
+        const dnx = -(dyq - fy) / dl, dny = (dxq - fx) / dl;
+        const tk = 5 / ptScale;
+        line(fx - dnx * tk, fy - dny * tk, fx + dnx * tk, fy + dny * tk, mcol, 1.1 * mw, 0.95);
+        line(dxq - dnx * tk, dyq - dny * tk, dxq + dnx * tk, dyq + dny * tk, mcol, 1.1 * mw, 0.95);
+        const t = lbl([Number(m.len_ft) > 0 ? dimLabel(m.len_ft, M ? "metric" : "imperial") : "", m.text].filter(Boolean).join(" \xB7 "));
+        if (t) {
+          const size = 8;
+          const tw = bold.widthOfTextAtSize(winAnsiSafe(t), size);
+          const [pmx, pmy] = toPage((fx + dxq) / 2 + dnx * (14 / ptScale), (fy + dyq) / 2 + dny * (14 / ptScale));
+          pg.drawText(winAnsiSafe(t), { x: pmx - tw / 2, y: pmy - size / 2.7, size, font: bold, color: mcol, rotate: chipRot });
+        }
       } else if (m.type === "bubble" && m.at) {
         const cxImg = m.at[0] * W, cyImg = m.at[1] * H;
         const [pcx, pcy] = toPage(cxImg, cyImg);
@@ -5213,6 +5813,26 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
         text(lbl(m.text), m.at[0] * W, m.at[1] * H, 8.5, mcol, bold);
       }
     }
+    for (const a of apBy.get(sh.key) || []) {
+      const isAgent = a.actor === "agent";
+      const acol = rgb(...hex(approvalInk(a.actor, dark)));
+      const cxImg = a.at[0] * W, cyImg = a.at[1] * H;
+      const rImg = APPROVAL_R * W, rPt = rImg * ptScale;
+      const [pcx, pcy] = toPage(cxImg, cyImg);
+      const backing = dark ? rgb(0.08, 0.1, 0.12) : rgb(1, 1, 1);
+      if (isAgent) {
+        const dia = (k) => [[cxImg, cyImg - rImg * k], [cxImg + rImg * k, cyImg], [cxImg, cyImg + rImg * k], [cxImg - rImg * k, cyImg]];
+        pg.drawSvgPath(svgPath(dia(1)), { x: 0, y: 0, color: backing, opacity: 0.72, borderColor: acol, borderWidth: rPt * 0.07 });
+        pg.drawSvgPath(svgPath(dia(0.72)), { x: 0, y: 0, borderColor: acol, borderWidth: rPt * 0.035 });
+      } else {
+        pg.drawEllipse({ x: pcx, y: pcy, xScale: rPt, yScale: rPt, color: backing, opacity: 0.72, borderColor: acol, borderWidth: rPt * 0.07 });
+        pg.drawEllipse({ x: pcx, y: pcy, xScale: rPt * 0.78, yScale: rPt * 0.78, borderColor: acol, borderWidth: rPt * 0.035 });
+      }
+      const label = isAgent ? "AGENT" : "APPROVED";
+      const size = rPt * (isAgent ? 0.3 : 0.26);
+      const tw = bold.widthOfTextAtSize(label, size);
+      pg.drawText(label, { x: pcx - tw / 2, y: pcy - size / 2.7, size, font: bold, color: acol, rotate: chipRot });
+    }
     text(`${sh.label} \xB7 marked set`, 14, 20, 8, muted);
   }
   const allPages = doc.getPages();
@@ -5498,7 +6118,7 @@ function registerTools(server, session) {
     return loaded;
   }));
   server.registerTool("sheet_info", {
-    description: `Sheet detail: dims (px and pt), vector segment count, whether the sheet has vector linework (one_click needs it), scale status, the detected scale suggestion, and this sheet's committed shape count. ${COORDS}`,
+    description: `Sheet detail: dims (px and pt), vector segment count, whether the sheet has vector linework (one_click floods it when present; a scanned sheet falls back to rendered pixels, disclosed as raster_traced), scale status, the detected scale suggestion, and this sheet's committed shape count. ${COORDS}`,
     inputSchema: { sheet: z2.string().describe('Sheet key ("plan.pdf", "plan.pdf#2") or title-block number ("A-101")') },
     outputSchema: sheetInfoOutput
   }, run("sheet_info", ({ sheet }) => session.sheetInfo(sheet)));
@@ -5518,7 +6138,7 @@ function registerTools(server, session) {
     return session.setScale(a.sheet, a);
   }));
   server.registerTool("one_click", {
-    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
+    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. SCANNED sheets work too (#154): where vectors can't bound the room (an image-only scan, or a scan wrapper whose only linework is the title block), the flood falls back automatically to the sheet's rendered pixels \u2014 same engine the canvas uses \u2014 and the reply plus the committed shape's origin carry raster_traced: true so a pixel-bounded ring is never mistaken for a vector-snapped one. Vector always wins where it works; a raster ring's corners are unsnapped, so audit it with view_sheet {overlay: true} before trusting the total. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       x: z2.number(),
@@ -5532,7 +6152,7 @@ function registerTools(server, session) {
     outputSchema: oneClickOutput
   }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity, layers: a.layers })));
   server.registerTool("detect_rooms", {
-    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
+    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. An OCR'd scan (text layer, no vector linework) floods the rendered pixels instead (#154), disclosed per room and on origin as raster_traced. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use). Mutually exclusive with assign_from_schedule"),
@@ -5588,6 +6208,26 @@ function registerTools(server, session) {
     },
     outputSchema: placeCountOutput
   }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
+  server.registerTool("symbol_sweep", {
+    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the sheet's vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep is ONE undo step, each marker carries origin.method "symbol_sweep" with its score and transform, and withheld placements are NEVER committed. No scale needed: EA is scale-free. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string(),
+      seed_rect: z2.tuple([pointSchema, pointSchema]).describe("Marquee around ONE example instance, [[x0,y0],[x1,y1]] in image px \u2014 tight: segments fully inside define the symbol"),
+      condition: z2.string().optional().describe("Finish tag to commit match markers under (minted on first use), e.g. 'FD-1'. Required when commit is true"),
+      commit: z2.boolean().default(false).describe("Commit every MATCH center as one EA count marker (withheld placements never commit)"),
+      rotations: z2.boolean().default(true).describe("Also match 90/180/270-rotated placements"),
+      mirror: z2.boolean().default(true).describe("Also match mirrored placements"),
+      tolerance_px: z2.number().positive().max(20).default(2).describe("Endpoint match tolerance in image px (default 2 \u2014 CAD jitter, not drift)")
+    },
+    outputSchema: symbolSweepOutput
+  }, run("symbol_sweep", (a) => session.symbolSweep(a.sheet, {
+    seedRect: a.seed_rect,
+    condition: a.condition,
+    commit: a.commit,
+    rotations: a.rotations,
+    mirror: a.mirror,
+    tolerancePx: a.tolerance_px
+  })));
   server.registerTool("derive_base", {
     description: `Mint the wall base from committed rooms (#148) \u2014 the estimator's most mechanical derivation: base LF = room perimeter \u2212 stated door openings. For every floor_area shape of source_condition, commits ONE linear shape under condition (e.g. 'RB-1') tracing that room's boundary, quantified NET of the openings you state per room. The openings are YOUR claim to make \u2014 look at the doors with view_sheet, state {shape_id, lf} per room (repeat a shape_id to stack openings); the tool never guesses, and your claim is recorded on origin.derived (from_shape_id, gross_lf, openings_lf). All-or-nothing: an unknown shape_id, a negative lf, or openings meeting a room's whole perimeter refuses the call before anything commits. The whole derivation is ONE undo step. Deriving onto the source condition is refused \u2014 base lands on its own tag.`,
     inputSchema: {
@@ -5785,21 +6425,21 @@ function registerTools(server, session) {
     return reply;
   });
   server.registerTool("annotate", {
-    description: `Place an annotation on a sheet \u2014 a note ABOUT the work, never a measurement of it. Types: cloud and highlight take rect:[[x0,y0],[x1,y1]] (a revision cloud around an area, a highlight box over it), text takes at:[x,y], callout takes at:[x,y] plus target:[x,y] (the point its leader aims at), arrow takes from:[x,y] and to:[x,y] (tail and head \u2014 plank/seam direction, the markup flooring drawings use most; #150), bubble takes at:[x,y] plus optional r (a keynote/detail circle carrying centered text). 
+    description: `Place an annotation on a sheet \u2014 a note ABOUT the work, never a measurement of it. Types: cloud and highlight take rect:[[x0,y0],[x1,y1]] (a revision cloud around an area, a highlight box over it), text takes at:[x,y], callout takes at:[x,y] plus target:[x,y] (the point its leader aims at), arrow takes from:[x,y] and to:[x,y] (tail and head \u2014 plank/seam direction, the markup flooring drawings use most; #150), bubble takes at:[x,y] plus optional r (a keynote/detail circle carrying centered text), dimension takes from:[x,y] and to:[x,y] (its two measured endpoints) and labels itself with the length between them at the sheet's scale \u2014 drawn as a dimension line with end ticks and the measurement centered. A dimension states a REAL length, so it is the one annotation the scale gate applies to: on an unscaled sheet it refuses exactly like the measure tools (set_scale first) rather than dressing a px figure up as feet. It still touches no quantity \u2014 a dimension is a note about a distance, not a takeoff line item.
 
 Pass condition to attach the note to a finish tag, which is what makes it part of that SCOPE rather than a floating remark: it then wears the condition's colour on the canvas and in the marked-set PDF, and travels with it into the report. The tag is minted on first touch like one_click/measure_polygon, so you can annotate CPT-1 before anything is traced for it. Omit condition for a note about the sheet itself. 
 
 No review gate: the pencil-not-ink rule exists to stop an agent inventing geometry, and a cloud reading "verify substrate" is not geometry. It touches no quantity. ${COORDS}`,
     inputSchema: {
       sheet: z2.string().describe("Sheet name or number, as sheet_info reports it"),
-      type: z2.enum(["cloud", "text", "callout", "highlight", "arrow", "bubble"]).describe("cloud/highlight need rect; text/callout/bubble need at; callout also needs target; arrow needs from + to"),
-      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'; a bubble's text draws centered in the circle"),
+      type: z2.enum(["cloud", "text", "callout", "highlight", "arrow", "bubble", "dimension"]).describe("cloud/highlight need rect; text/callout/bubble need at; callout also needs target; arrow and dimension need from + to"),
+      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'; a bubble's text draws centered in the circle; a dimension appends it after the measured length"),
       condition: z2.string().optional().describe("Finish tag to attach this note to, e.g. 'CPT-1' (minted on first use). Omit for an unattached sheet note"),
       at: pointSchema.optional().describe("Anchor point (image px) \u2014 text, callout, and bubble (the circle's center)"),
       target: pointSchema.optional().describe("What a callout's leader line points at (image px)"),
       rect: z2.tuple([pointSchema, pointSchema]).optional().describe("Corners (image px) \u2014 cloud and highlight"),
-      from: pointSchema.optional().describe("Arrow tail (image px)"),
-      to: pointSchema.optional().describe("Arrow head \u2014 what it points at (image px)"),
+      from: pointSchema.optional().describe("Arrow tail / dimension start (image px)"),
+      to: pointSchema.optional().describe("Arrow head / dimension end (image px)"),
       r: z2.number().positive().optional().describe("Bubble radius (image px); omitted \u2192 the canvas default (2% of sheet width)")
     },
     outputSchema: annotateOutput
@@ -5901,7 +6541,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.19",
+  version: "0.9.21",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -5917,7 +6557,7 @@ var package_default = {
     mcpb: "npm run build && node scripts/build-mcpb.mjs",
     prepublishOnly: "npm run typecheck && npm test && npm run build",
     typecheck: "tsc --noEmit",
-    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
@@ -16,7 +16,7 @@
     "mcpb": "npm run build && node scripts/build-mcpb.mjs",
     "prepublishOnly": "npm run typecheck && npm test && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",