opentakeoff-mcp 0.9.20 → 0.9.21

package/README.md

@@ -108,7 +108,7 @@ 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. |
@@ -244,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,105 @@ 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;
@@ -2865,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);
@@ -2887,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);
@@ -3002,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;
@@ -3016,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) {
@@ -3038,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");
@@ -3092,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 = [];
@@ -3111,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;
@@ -3159,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) {
@@ -3191,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;
       }
@@ -4085,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"),
@@ -4099,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"),
@@ -5925,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)));
@@ -5945,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(),
@@ -5959,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"),
@@ -6348,7 +6541,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.20",
+  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.",
@@ -6364,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.20",
+  "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",