opentakeoff-mcp 0.1.0

package/dist/server-core.js

@@ -0,0 +1,1217 @@
+// src/hush.ts
+console.log = console.error.bind(console);
+if (typeof Promise.withResolvers !== "function") {
+  Promise.withResolvers = function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  };
+}
+
+// server.ts
+import { pathToFileURL } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/session.ts
+import path2 from "node:path";
+
+// src/pdf.ts
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import * as pdfjs from "pdfjs-dist";
+
+// ../web/src/lib/sheets.ts
+import * as pdfjsLib from "pdfjs-dist";
+var RENDER_SCALE = 2;
+var PX_PER_IN = 72 * RENDER_SCALE;
+var arch = (inPerFt) => 1 / inPerFt / PX_PER_IN;
+var eng = (ftPerIn) => ftPerIn / PX_PER_IN;
+var metric = (r) => r / 12 / PX_PER_IN;
+var STANDARD_SCALES = [
+  { label: `1/16" = 1'-0"`, upp: arch(1 / 16) },
+  { label: `3/32" = 1'-0"`, upp: arch(3 / 32) },
+  { label: `1/8" = 1'-0"`, upp: arch(1 / 8) },
+  { label: `3/16" = 1'-0"`, upp: arch(3 / 16) },
+  { label: `1/4" = 1'-0"`, upp: arch(1 / 4) },
+  { label: `3/8" = 1'-0"`, upp: arch(3 / 8) },
+  { label: `1/2" = 1'-0"`, upp: arch(1 / 2) },
+  { label: `3/4" = 1'-0"`, upp: arch(3 / 4) },
+  { label: `1" = 1'-0"`, upp: arch(1) },
+  { label: `1-1/2" = 1'-0"`, upp: arch(1.5) },
+  { label: `3" = 1'-0"`, upp: arch(3) },
+  { label: `1" = 10'`, upp: eng(10) },
+  { label: `1" = 20'`, upp: eng(20) },
+  { label: `1" = 30'`, upp: eng(30) },
+  { label: `1" = 40'`, upp: eng(40) },
+  { label: `1" = 50'`, upp: eng(50) },
+  { label: `1" = 60'`, upp: eng(60) },
+  { label: "1:20", upp: metric(20) },
+  { label: "1:25", upp: metric(25) },
+  { label: "1:50", upp: metric(50) },
+  { label: "1:75", upp: metric(75) },
+  { label: "1:100", upp: metric(100) },
+  { label: "1:125", upp: metric(125) },
+  { label: "1:200", upp: metric(200) },
+  { label: "1:250", upp: metric(250) },
+  { label: "1:500", upp: metric(500) }
+];
+var SHEET_NO_RE = /^[A-Z]{1,3}[-. ]?\d{1,3}(\.\d{1,2})?[A-Z]?$/;
+function extractSheetNumber(textContent, viewport) {
+  const W = viewport.width, H = viewport.height;
+  let best = null, bestH = 0;
+  for (const it of textContent.items || []) {
+    const raw = (it.str || "").trim().toUpperCase().replace(/\s+/g, "");
+    if (raw.length < 2 || raw.length > 8 || !SHEET_NO_RE.test(raw)) continue;
+    const t = pdfjsLib.Util.transform(viewport.transform, it.transform);
+    const x = t[4], y = t[5], h = Math.hypot(t[2], t[3]) || it.height || 0;
+    if (x < W * 0.6 || y < H * 0.55) continue;
+    const score = h + x / W * 4 + y / H * 4;
+    if (score > bestH) {
+      bestH = score;
+      best = raw;
+    }
+  }
+  return best;
+}
+var _canonScaleText = (s) => s.replace(/[“”″]/g, '"').replace(/[‘’′]/g, "'").replace(/\s+/g, "").toUpperCase();
+var SCALE_KEYS = STANDARD_SCALES.map((s) => {
+  const full = _canonScaleText(s.label);
+  const keys = /* @__PURE__ */ new Set([full]);
+  if (full.endsWith(`=1'-0"`)) keys.add(full.slice(0, -3));
+  else if (full.endsWith("'")) keys.add(`${full}-0"`);
+  return { ...s, keys: [...keys] };
+});
+function _findScales(canon) {
+  const out = [];
+  for (const sc of SCALE_KEYS) {
+    let hit = false;
+    for (const k of sc.keys) {
+      let i = canon.indexOf(k);
+      while (i !== -1 && !hit) {
+        const prev = canon[i - 1];
+        const next = canon[i + k.length];
+        if (!(prev >= "0" && prev <= "9") && prev !== "/" && prev !== "-" && !(next >= "0" && next <= "9")) hit = true;
+        else i = canon.indexOf(k, i + 1);
+      }
+      if (hit) break;
+    }
+    if (hit) out.push(sc);
+  }
+  return out;
+}
+function detectScale(textContent, viewport) {
+  const W = viewport.width, H = viewport.height;
+  let all = "", tb = "";
+  for (const it of textContent.items || []) {
+    const str = it.str || "";
+    if (!str.trim()) continue;
+    all += str + " ";
+    const t = pdfjsLib.Util.transform(viewport.transform, it.transform);
+    if (t[4] > W * 0.55 && t[5] > H * 0.5) tb += str + " ";
+  }
+  const tbHits = _findScales(_canonScaleText(tb));
+  const allHits = _findScales(_canonScaleText(all));
+  if (tbHits.length) return { upp: tbHits[0].upp, label: tbHits[0].label, multi: allHits.length > 1 };
+  if (allHits.length === 1) return { upp: allHits[0].upp, label: allHits[0].label, multi: false };
+  return null;
+}
+
+// src/pdf.ts
+var requireHere = createRequire(import.meta.url);
+var PDFJS_ROOT = path.dirname(requireHere.resolve("pdfjs-dist/package.json"));
+var OPS2 = pdfjs.OPS;
+async function openPdf(filePath) {
+  const bytes = await readFile(filePath);
+  const doc = await pdfjs.getDocument({
+    // getDocument({ data }) may DETACH the buffer it is handed — always pass a
+    // fresh copy (new Uint8Array(view) copies), never the read buffer itself.
+    data: new Uint8Array(bytes),
+    verbosity: 0,
+    standardFontDataUrl: path.join(PDFJS_ROOT, "standard_fonts") + path.sep,
+    cMapUrl: path.join(PDFJS_ROOT, "cmaps") + path.sep,
+    cMapPacked: true,
+    isEvalSupported: false
+  }).promise;
+  return {
+    numPages: doc.numPages,
+    async page(n) {
+      const page = await doc.getPage(n);
+      const vp = page.getViewport({ scale: RENDER_SCALE });
+      const vp1 = page.getViewport({ scale: 1 });
+      const textContent = await page.getTextContent();
+      return {
+        pageNum: n,
+        widthPt: vp1.width,
+        heightPt: vp1.height,
+        viewport: { width: vp.width, height: vp.height, transform: vp.transform },
+        textContent,
+        operatorList: async () => await page.getOperatorList()
+      };
+    },
+    destroy: () => doc.destroy().then(() => void 0)
+  };
+}
+function positionedText(ph) {
+  const out = [];
+  for (const it of ph.textContent.items || []) {
+    const str = it.str || "";
+    if (!str.trim()) continue;
+    const t = pdfjs.Util.transform(ph.viewport.transform, it.transform);
+    out.push({ str, x: +t[4].toFixed(1), y: +t[5].toFixed(1) });
+  }
+  return out;
+}
+
+// src/format.ts
+var UserError = class extends Error {
+};
+var ok = (payload) => ({
+  content: [{ type: "text", text: JSON.stringify(payload) }]
+});
+var fail = (err) => ({
+  isError: true,
+  content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }]
+});
+var round2 = (n) => +n.toFixed(2);
+var round1 = (n) => +n.toFixed(1);
+
+// ../web/src/lib/oneclick.ts
+var MASK_MAX_DIM = 3e3;
+var LEAK_FRACTION = 0.3;
+var TINY_PX = 30;
+var MIN_THICK = 4;
+var CURVE_STEPS = 8;
+var SEG_CURVE = 1;
+var SEG_CLIP = 2;
+var SEG_FILLONLY = 4;
+var HATCH_ANGLE_TOL = 2;
+var HATCH_MIN_RUN = 10;
+var HATCH_MAX_PITCH = 24;
+var HATCH_PITCH_TOL = 0.35;
+var HATCH_MIN_REGULAR = 0.7;
+var HATCH_OVERLAP_FRAC = 0.5;
+var ROW_EPS = 1.5;
+var WIDE_PROTECT_RATIO = 2;
+var SPAN_PROTECT_RATIO = 3;
+var HATCH_BOUND_FRAC = 0.7;
+var HATCH_ESCALATE_FRAC = 0.35;
+var HATCH_GROWTH_MAX = 2.5;
+var SENS_STRICT = 0;
+var SENS_BALANCED = 0.5;
+var SENS_AGGRESSIVE = 1;
+var SENS_ANCHORS = [
+  [SENS_STRICT, HATCH_BOUND_FRAC, 1.5],
+  // moderate band empties (escalateFrac == HATCH_BOUND_FRAC) ⇒ pre-#32
+  [SENS_BALANCED, HATCH_ESCALATE_FRAC, HATCH_GROWTH_MAX],
+  // calibrated on the sample plan (issue #32)
+  [SENS_AGGRESSIVE, 0.2, 4]
+  // cross more hatch, tolerate more growth
+];
+function escalationParams(sensitivity) {
+  const s = Math.max(0, Math.min(1, Number.isFinite(sensitivity) ? sensitivity : SENS_BALANCED));
+  let a = SENS_ANCHORS[0], b = SENS_ANCHORS[SENS_ANCHORS.length - 1];
+  for (let i = 1; i < SENS_ANCHORS.length; i++) {
+    if (s <= SENS_ANCHORS[i][0]) {
+      a = SENS_ANCHORS[i - 1];
+      b = SENS_ANCHORS[i];
+      break;
+    }
+  }
+  const t = b[0] === a[0] ? 0 : (s - a[0]) / (b[0] - a[0]);
+  return { escalateFrac: a[1] + (b[1] - a[1]) * t, growthMax: a[2] + (b[2] - a[2]) * t };
+}
+function extractVectorGeometry(opList, transform, OPS3) {
+  const points = [];
+  const segs = [];
+  const metaArr = [];
+  let imageArea = 0;
+  let m = transform.slice();
+  let lw = 1;
+  const stack = [];
+  const mul = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
+  const tx = (x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+  const fns = opList.fnArray, A = opList.argsArray;
+  const paintFlags = (i) => {
+    for (let j = i + 1; j < fns.length && j <= i + 3; j++) {
+      const f = fns[j];
+      if (f === OPS3.clip || f === OPS3.eoClip) continue;
+      if (f === OPS3.endPath) return SEG_CLIP;
+      if (f === OPS3.fill || f === OPS3.eoFill) return SEG_FILLONLY;
+      break;
+    }
+    return 0;
+  };
+  for (let i = 0; i < fns.length; i++) {
+    const fn = fns[i], args = A[i];
+    if (fn === OPS3.save) stack.push([m.slice(), lw]);
+    else if (fn === OPS3.restore) {
+      const p = stack.pop();
+      if (p) {
+        m = p[0];
+        lw = p[1];
+      }
+    } else if (fn === OPS3.transform) m = mul(m, args);
+    else if (fn === OPS3.setLineWidth) lw = args[0];
+    else if (fn === OPS3.setGState) {
+      for (const pr of args[0] || []) if (pr && pr[0] === "LW") lw = pr[1];
+    } else if (fn === OPS3.paintFormXObjectBegin) {
+      stack.push([m.slice(), lw]);
+      if (args && args[0]) m = mul(m, args[0]);
+    } else if (fn === OPS3.paintFormXObjectEnd) {
+      const p = stack.pop();
+      if (p) {
+        m = p[0];
+        lw = p[1];
+      }
+    } else if (fn === OPS3.paintImageXObject || fn === OPS3.paintInlineImageXObject || fn === OPS3.paintImageMaskXObject) {
+      imageArea += Math.abs(m[0] * m[3] - m[1] * m[2]);
+    } else if (fn === OPS3.paintImageXObjectRepeat) {
+      const [, scaleX, scaleY, positions] = args;
+      const count = positions ? positions.length >> 1 : 0;
+      imageArea += Math.abs(m[0] * m[3] - m[1] * m[2]) * Math.abs(scaleX * scaleY) * count;
+    } else if (fn === OPS3.paintImageMaskXObjectRepeat) {
+      const [, ra, rb, rc, rd, positions] = args;
+      const count = positions ? positions.length >> 1 : 0;
+      imageArea += Math.abs(m[0] * m[3] - m[1] * m[2]) * Math.abs(ra * rd - rb * rc) * count;
+    } else if (fn === OPS3.paintImageMaskXObjectGroup) {
+      const ctmDet = Math.abs(m[0] * m[3] - m[1] * m[2]);
+      for (const im of args[0] || []) {
+        const t = im && im.transform;
+        if (t) imageArea += ctmDet * Math.abs(t[0] * t[3] - t[1] * t[2]);
+      }
+    } else if (fn === OPS3.paintInlineImageXObjectGroup) {
+      const ctmDet = Math.abs(m[0] * m[3] - m[1] * m[2]);
+      for (const mp of args[1] || []) {
+        const t = mp && mp.transform;
+        if (t) imageArea += ctmDet * Math.abs(t[0] * t[3] - t[1] * t[2]);
+      }
+    } else if (fn === OPS3.constructPath) {
+      const devW = Math.min(15, Math.max(0, Math.ceil((lw || 0) * Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])))));
+      const flags = paintFlags(i) | devW << 4;
+      const ops = args[0], co = args[1];
+      let c = 0, cur = null, start = null;
+      const visit = (p) => {
+        points.push(p);
+      };
+      const lineTo = (p) => {
+        if (cur) {
+          segs.push(cur[0], cur[1], p[0], p[1]);
+          metaArr.push(flags);
+        }
+        cur = p;
+        visit(p);
+      };
+      for (const op of ops) {
+        if (op === OPS3.moveTo) {
+          cur = tx(co[c], co[c + 1]);
+          start = cur;
+          visit(cur);
+          c += 2;
+        } else if (op === OPS3.lineTo) {
+          lineTo(tx(co[c], co[c + 1]));
+          c += 2;
+        } else if (op === OPS3.curveTo || op === OPS3.curveTo2 || op === OPS3.curveTo3) {
+          let p1, p2, p3;
+          if (op === OPS3.curveTo) {
+            p1 = tx(co[c], co[c + 1]);
+            p2 = tx(co[c + 2], co[c + 3]);
+            p3 = tx(co[c + 4], co[c + 5]);
+            c += 6;
+          } else if (op === OPS3.curveTo2) {
+            p1 = cur || tx(co[c], co[c + 1]);
+            p2 = tx(co[c], co[c + 1]);
+            p3 = tx(co[c + 2], co[c + 3]);
+            c += 4;
+          } else {
+            p1 = tx(co[c], co[c + 1]);
+            p2 = p3 = tx(co[c + 2], co[c + 3]);
+            c += 4;
+          }
+          const p0 = cur || p1;
+          for (let k = 1; k <= CURVE_STEPS; k++) {
+            const t = k / CURVE_STEPS, u = 1 - t;
+            const q = [
+              u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+              u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1]
+            ];
+            if (cur) {
+              segs.push(cur[0], cur[1], q[0], q[1]);
+              metaArr.push(flags | SEG_CURVE);
+            }
+            cur = q;
+          }
+          visit(p3);
+        } else if (op === OPS3.closePath) {
+          if (cur && start) {
+            segs.push(cur[0], cur[1], start[0], start[1]);
+            metaArr.push(flags);
+            cur = start;
+          }
+        } else if (op === OPS3.rectangle) {
+          const x = co[c], y = co[c + 1], w = co[c + 2], h = co[c + 3];
+          c += 4;
+          const q = [tx(x, y), tx(x + w, y), tx(x + w, y + h), tx(x, y + h)];
+          for (let k = 0; k < 4; k++) {
+            const a = q[k], b = q[(k + 1) % 4];
+            segs.push(a[0], a[1], b[0], b[1]);
+            metaArr.push(flags);
+            visit(a);
+          }
+          cur = q[0];
+          start = q[0];
+        }
+      }
+    }
+  }
+  return { points, segs, meta: Uint8Array.from(metaArr), imageArea };
+}
+function classifyHatchSegs(segs, meta, ws) {
+  const n = segs.length >> 2;
+  const soft = new Uint8Array(n);
+  if (!meta || !n) return soft;
+  const cand = [];
+  for (let i = 0; i < n; i++) {
+    const mt = meta[i];
+    if (mt & SEG_CURVE) continue;
+    if (mt & SEG_CLIP) {
+      soft[i] = 1;
+      continue;
+    }
+    if (mt & SEG_FILLONLY) continue;
+    const x1 = segs[i * 4] * ws, y1 = segs[i * 4 + 1] * ws, x2 = segs[i * 4 + 2] * ws, y2 = segs[i * 4 + 3] * ws;
+    const dx = x2 - x1, dy = y2 - y1;
+    const len = Math.hypot(dx, dy);
+    if (len < 0.75) continue;
+    let ang = Math.atan2(dy, dx) * 180 / Math.PI;
+    if (ang < 0) ang += 180;
+    if (ang >= 180) ang -= 180;
+    cand.push({ i, ang, x1, y1, x2, y2, w: meta[i] >> 4 });
+  }
+  if (cand.length < HATCH_MIN_RUN) return soft;
+  cand.sort((a, b) => a.ang - b.ang);
+  const clusters = [];
+  let cl = [cand[0]];
+  for (let k = 1; k < cand.length; k++) {
+    if (cand[k].ang - cand[k - 1].ang <= HATCH_ANGLE_TOL) cl.push(cand[k]);
+    else {
+      clusters.push(cl);
+      cl = [cand[k]];
+    }
+  }
+  clusters.push(cl);
+  if (clusters.length > 1) {
+    const first = clusters[0], last = clusters[clusters.length - 1];
+    if (first[0].ang < HATCH_ANGLE_TOL && last[last.length - 1].ang > 180 - HATCH_ANGLE_TOL) {
+      for (const s of last) s.ang -= 180;
+      clusters[0] = last.concat(first);
+      clusters.pop();
+    }
+  }
+  const median = (arr) => {
+    const a = arr.slice().sort((x, y) => x - y);
+    return a[a.length >> 1];
+  };
+  for (const members of clusters) {
+    if (members.length < HATCH_MIN_RUN) continue;
+    let sum = 0;
+    for (const s of members) sum += s.ang;
+    const th = sum / members.length * Math.PI / 180;
+    const dxu = Math.cos(th), dyu = Math.sin(th);
+    const nxu = -dyu, nyu = dxu;
+    const rowsIn = members.map((s) => ({
+      s,
+      d: (s.x1 + s.x2) / 2 * nxu + (s.y1 + s.y2) / 2 * nyu,
+      t0: Math.min(s.x1 * dxu + s.y1 * dyu, s.x2 * dxu + s.y2 * dyu),
+      t1: Math.max(s.x1 * dxu + s.y1 * dyu, s.x2 * dxu + s.y2 * dyu)
+    })).sort((a, b) => a.d - b.d);
+    const rows = [];
+    let row = { d: rowsIn[0].d, t0: rowsIn[0].t0, t1: rowsIn[0].t1, segs: [rowsIn[0].s] };
+    for (let k = 1; k < rowsIn.length; k++) {
+      const r = rowsIn[k];
+      if (r.d - row.d <= ROW_EPS) {
+        row.t0 = Math.min(row.t0, r.t0);
+        row.t1 = Math.max(row.t1, r.t1);
+        row.segs.push(r.s);
+      } else {
+        rows.push(row);
+        row = { d: r.d, t0: r.t0, t1: r.t1, segs: [r.s] };
+      }
+    }
+    rows.push(row);
+    let runStart = 0;
+    const flushRun = (a, b) => {
+      const count = b - a + 1;
+      if (count < HATCH_MIN_RUN) return;
+      const gaps = [];
+      for (let k = a + 1; k <= b; k++) gaps.push(rows[k].d - rows[k - 1].d);
+      const med = median(gaps);
+      if (!med) return;
+      let reg = 0;
+      for (const g of gaps) if (Math.abs(g - med) <= med * HATCH_PITCH_TOL) reg++;
+      if (reg / gaps.length < HATCH_MIN_REGULAR) return;
+      const widths = [];
+      for (let k = a; k <= b; k++) for (const s of rows[k].segs) widths.push(s.w);
+      const modalW = Math.max(1, median(widths));
+      const spans = [];
+      for (let k = a; k <= b; k++) spans.push(rows[k].t1 - rows[k].t0);
+      const medSpan = Math.max(1, median(spans));
+      for (let k = a + 1; k < b; k++) {
+        if (rows[k].t1 - rows[k].t0 > SPAN_PROTECT_RATIO * medSpan) continue;
+        for (const s of rows[k].segs)
+          if (s.w < WIDE_PROTECT_RATIO * modalW) soft[s.i] = 1;
+      }
+    };
+    for (let k = 1; k < rows.length; k++) {
+      const gap = rows[k].d - rows[k - 1].d;
+      const ov = Math.min(rows[k].t1, rows[k - 1].t1) - Math.max(rows[k].t0, rows[k - 1].t0);
+      const need = HATCH_OVERLAP_FRAC * Math.min(rows[k].t1 - rows[k].t0, rows[k - 1].t1 - rows[k - 1].t0);
+      if (gap > HATCH_MAX_PITCH || ov < need) {
+        flushRun(runStart, k - 1);
+        runStart = k;
+      }
+    }
+    flushRun(runStart, rows.length - 1);
+  }
+  return soft;
+}
+function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null) {
+  const ws = Math.min(1, maxDim / Math.max(imgW, imgH, 1));
+  const mw = Math.max(2, Math.ceil(imgW * ws)), mh = Math.max(2, Math.ceil(imgH * ws));
+  const mask = new Uint8Array(mw * mh);
+  const soft = meta ? classifyHatchSegs(segs, meta, ws) : null;
+  let softCount = 0;
+  for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
+    const v = soft && soft[si] ? 2 : 1;
+    if (v === 2) softCount++;
+    let x0 = Math.round(segs[i] * ws), y0 = Math.round(segs[i + 1] * ws);
+    const x1 = Math.round(segs[i + 2] * ws), y1 = Math.round(segs[i + 3] * ws);
+    const dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+    let e = dx + dy;
+    for (; ; ) {
+      if (x0 >= 0 && y0 >= 0 && x0 < mw && y0 < mh) mask[y0 * mw + x0] |= v;
+      if (x0 === x1 && y0 === y1) break;
+      const e2 = 2 * e;
+      if (e2 >= dy) {
+        e += dy;
+        x0 += sx;
+      }
+      if (e2 <= dx) {
+        e += dx;
+        y0 += sy;
+      }
+    }
+  }
+  return { mask, mw, mh, ws, softCount };
+}
+function floodPass(maskObj, ix, iy, barrier) {
+  const { mask, mw, mh, ws } = maskObj;
+  let sx = Math.round(ix * ws), sy = Math.round(iy * ws);
+  if (sx < 0 || sy < 0 || sx >= mw || sy >= mh) return { status: "boundary" };
+  if (mask[sy * mw + sx] & barrier) {
+    let found = null;
+    for (let r = 1; r <= 3 && !found; r++) {
+      for (let dy = -r; dy <= r && !found; dy++) for (let dx = -r; dx <= r; dx++) {
+        const nx = sx + dx, ny = sy + dy;
+        if (nx >= 0 && ny >= 0 && nx < mw && ny < mh && !(mask[ny * mw + nx] & barrier)) {
+          found = [nx, ny];
+          break;
+        }
+      }
+    }
+    if (!found) return { status: "boundary" };
+    sx = found[0];
+    sy = found[1];
+  }
+  const region = new Uint8Array(mw * mh);
+  const cap = Math.floor(mw * mh * LEAK_FRACTION);
+  let count = 0, leaked = false, hardHits = 0, softHits = 0;
+  let bx0 = sx, bx1 = sx, by0 = sy, by1 = sy;
+  const stack = [[sx, sy]];
+  while (stack.length) {
+    const popped = stack.pop();
+    const px = popped[0], py = popped[1];
+    let x0 = px;
+    while (x0 > 0 && !(mask[py * mw + x0 - 1] & barrier) && !region[py * mw + x0 - 1]) x0--;
+    if (x0 > 0 && mask[py * mw + x0 - 1] & barrier) {
+      if (mask[py * mw + x0 - 1] & 1) hardHits++;
+      else softHits++;
+    }
+    let x1 = px;
+    while (x1 < mw - 1 && !(mask[py * mw + x1 + 1] & barrier) && !region[py * mw + x1 + 1]) x1++;
+    if (x1 < mw - 1 && mask[py * mw + x1 + 1] & barrier) {
+      if (mask[py * mw + x1 + 1] & 1) hardHits++;
+      else softHits++;
+    }
+    if (x0 === 0 || x1 === mw - 1 || py === 0 || py === mh - 1) leaked = true;
+    if (x0 < bx0) bx0 = x0;
+    if (x1 > bx1) bx1 = x1;
+    if (py < by0) by0 = py;
+    if (py > by1) by1 = py;
+    let upOpen = false, downOpen = false;
+    for (let x = x0; x <= x1; x++) {
+      const idx = py * mw + x;
+      if (region[idx]) {
+        upOpen = downOpen = false;
+        continue;
+      }
+      region[idx] = 1;
+      count++;
+      if (py > 0) {
+        const u = idx - mw;
+        if (!(mask[u] & barrier) && !region[u]) {
+          if (!upOpen) {
+            stack.push([x, py - 1]);
+            upOpen = true;
+          }
+        } else {
+          if (mask[u] & barrier) {
+            if (mask[u] & 1) hardHits++;
+            else softHits++;
+          }
+          upOpen = false;
+        }
+      }
+      if (py < mh - 1) {
+        const d = idx + mw;
+        if (!(mask[d] & barrier) && !region[d]) {
+          if (!downOpen) {
+            stack.push([x, py + 1]);
+            downOpen = true;
+          }
+        } else {
+          if (mask[d] & barrier) {
+            if (mask[d] & 1) hardHits++;
+            else softHits++;
+          }
+          downOpen = false;
+        }
+      }
+    }
+    if (count > cap) return { status: "leak" };
+  }
+  if (leaked) return { status: "leak" };
+  if (count < TINY_PX || bx1 - bx0 + 1 < MIN_THICK || by1 - by0 + 1 < MIN_THICK) return { status: "tiny", count };
+  return { status: "ok", region, count, mw, mh, ws, hardHits, softHits };
+}
+function floodRegion(maskObj, ix, iy, sensitivity = SENS_BALANCED) {
+  const r1 = floodPass(maskObj, ix, iy, 3);
+  if (!maskObj.softCount) return r1;
+  if (r1.status === "leak") return r1;
+  const { escalateFrac, growthMax } = escalationParams(sensitivity);
+  let growthCap = Infinity;
+  if (r1.status === "ok") {
+    const blocks = (r1.hardHits || 0) + (r1.softHits || 0);
+    const softFrac = blocks ? (r1.softHits || 0) / blocks : 0;
+    if (softFrac < escalateFrac) return r1;
+    if (softFrac < HATCH_BOUND_FRAC) growthCap = growthMax;
+  }
+  const r2 = floodPass(maskObj, ix, iy, 1);
+  if (r2.status === "ok" && (r1.status !== "ok" || r2.count <= r1.count * growthCap)) {
+    r2.hatchFiltered = true;
+    return r2;
+  }
+  return r1;
+}
+function traceRegion(reg, epsMaskPx = 1.5) {
+  const { region, mw, mh, ws } = reg;
+  let s = -1;
+  for (let i = 0; i < region.length; i++) if (region[i]) {
+    s = i;
+    break;
+  }
+  if (s < 0) return [];
+  const sx = s % mw, sy = s / mw | 0;
+  const at = (x, y) => x >= 0 && y >= 0 && x < mw && y < mh && !!region[y * mw + x];
+  const N = [[-1, 0], [-1, -1], [0, -1], [1, -1], [1, 0], [1, 1], [0, 1], [-1, 1]];
+  const pts = [];
+  let cx = sx, cy = sy, dir = 6;
+  const maxSteps = mw * mh * 4;
+  for (let step = 0; step < maxSteps; step++) {
+    pts.push([cx, cy]);
+    let found = false;
+    for (let k = 0; k < 8; k++) {
+      const d = (dir + 6 + k) % 8;
+      const nx = cx + N[d][0], ny = cy + N[d][1];
+      if (at(nx, ny)) {
+        cx = nx;
+        cy = ny;
+        dir = d;
+        found = true;
+        break;
+      }
+    }
+    if (!found) break;
+    if (cx === sx && cy === sy && pts.length > 2) break;
+  }
+  const ring = rdpClosed(pts, epsMaskPx);
+  return ring.map(([x, y]) => [x / ws, y / ws]);
+}
+function perpDist(p, a, b) {
+  const dx = b[0] - a[0], dy = b[1] - a[1];
+  const L = Math.hypot(dx, dy);
+  if (!L) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  return Math.abs(dy * p[0] - dx * p[1] + b[0] * a[1] - b[1] * a[0]) / L;
+}
+function rdpOpen(pts, eps) {
+  if (pts.length < 3) return pts.slice();
+  let imax = 0, dmax = -1;
+  const a = pts[0], b = pts[pts.length - 1];
+  for (let i = 1; i < pts.length - 1; i++) {
+    const d = perpDist(pts[i], a, b);
+    if (d > dmax) {
+      dmax = d;
+      imax = i;
+    }
+  }
+  if (dmax <= eps) return [a, b];
+  const left = rdpOpen(pts.slice(0, imax + 1), eps);
+  const right = rdpOpen(pts.slice(imax), eps);
+  return left.slice(0, -1).concat(right);
+}
+function rdpClosed(pts, eps) {
+  if (pts.length < 4) return pts.slice();
+  let split = 0, dmax = -1;
+  for (let i = 1; i < pts.length; i++) {
+    const d = (pts[i][0] - pts[0][0]) ** 2 + (pts[i][1] - pts[0][1]) ** 2;
+    if (d > dmax) {
+      dmax = d;
+      split = i;
+    }
+  }
+  const h1 = rdpOpen(pts.slice(0, split + 1), eps);
+  const h2 = rdpOpen(pts.slice(split).concat([pts[0]]), eps);
+  const ring = h1.slice(0, -1).concat(h2.slice(0, -1));
+  return ring.length >= 3 ? ring : pts.slice();
+}
+function snapVertices(poly, nearest, tolPx = 6, minGapPx = 2) {
+  const snapped = poly.map(([x, y]) => {
+    const hit = nearest(x, y, tolPx);
+    return hit ? [hit[0], hit[1]] : [x, y];
+  });
+  const out = [];
+  for (const p of snapped) {
+    const prev = out[out.length - 1];
+    if (!prev || Math.hypot(p[0] - prev[0], p[1] - prev[1]) > minGapPx) out.push(p);
+  }
+  while (out.length > 1 && Math.hypot(out[0][0] - out[out.length - 1][0], out[0][1] - out[out.length - 1][1]) <= minGapPx) out.pop();
+  return out.length >= 3 ? out : poly;
+}
+function ringArea(pts) {
+  let a = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const [x1, y1] = pts[i], [x2, y2] = pts[(i + 1) % pts.length];
+    a += x1 * y2 - x2 * y1;
+  }
+  return Math.abs(a) / 2;
+}
+
+// ../web/src/lib/geometry.js
+function buildSnapGrid(points, cell) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const k = `${Math.floor(p[0] / cell)},${Math.floor(p[1] / cell)}`;
+    let a = map.get(k);
+    if (!a) {
+      a = [];
+      map.set(k, a);
+    }
+    if (a.length < 40) a.push(p);
+  }
+  return { cell, map };
+}
+function nearestSnap(grid, x, y, maxDist) {
+  if (!grid) return null;
+  const { cell, map } = grid, cx = Math.floor(x / cell), cy = Math.floor(y / cell);
+  let best = null, bestD = maxDist * maxDist;
+  for (let gx = cx - 1; gx <= cx + 1; gx++) for (let gy = cy - 1; gy <= cy + 1; gy++) {
+    const a = map.get(`${gx},${gy}`);
+    if (!a) continue;
+    for (const p of a) {
+      const dx = p[0] - x, dy = p[1] - y, d = dx * dx + dy * dy;
+      if (d < bestD) {
+        bestD = d;
+        best = p;
+      }
+    }
+  }
+  return best;
+}
+function closedMetrics(pts) {
+  const n = pts.length;
+  if (n < 3) {
+    let perim2 = 0;
+    for (let i = 1; i < n; i++) perim2 += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
+    return { area: 0, perim: perim2 };
+  }
+  let area = 0, perim = 0;
+  for (let i = 0; i < n; i++) {
+    const [x1, y1] = pts[i], [x2, y2] = pts[(i + 1) % n];
+    area += x1 * y2 - x2 * y1;
+    perim += Math.hypot(x2 - x1, y2 - y1);
+  }
+  return { area: Math.abs(area) / 2, perim };
+}
+function openLen(pts) {
+  let L = 0;
+  for (let i = 1; i < pts.length; i++) L += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
+  return L;
+}
+
+// ../web/src/lib/num.js
+var round22 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+
+// ../web/src/lib/totals.js
+function accumulateRole(acc, s) {
+  const cp = s.computed || {};
+  switch (s.measure_role) {
+    case "deduct":
+      acc.floor -= cp.area_sf || 0;
+      break;
+    case "floor_area":
+      acc.floor += cp.area_sf || 0;
+      break;
+    case "surface_area":
+      acc.wall += cp.area_sf || 0;
+      break;
+    case "linear":
+      acc.lf += cp.perimeter_lf || 0;
+      acc.border += cp.area_sf || 0;
+      break;
+    case "count":
+      acc.ea += cp.count || 1;
+      break;
+    default:
+      break;
+  }
+}
+function conditionTotals(conditions, shapes) {
+  return conditions.map((c) => {
+    const mult = c.multiplier || 1;
+    const waste = Math.max(0, Number(c.waste_pct) || 0);
+    const w = 1 + waste / 100;
+    const cs = shapes.filter((s) => s.condition_id === c.id);
+    const acc = { floor: 0, wall: 0, border: 0, lf: 0, ea: 0 };
+    for (const s of cs) accumulateRole(acc, s);
+    let { floor, wall, border, lf, ea } = acc;
+    floor *= mult;
+    wall *= mult;
+    border *= mult;
+    lf *= mult;
+    ea *= mult;
+    const total = floor + wall + border;
+    const materials = (c.materials || []).filter((m) => m && m.name).map((m) => {
+      const per = Math.max(0, Number(m.per) || 0);
+      const basisVal = m.basis === "linear" ? lf : m.basis === "count" ? ea : total;
+      let qty = per > 0 ? basisVal / per : 0;
+      qty = m.round === false ? round22(qty) : Math.ceil(qty - 1e-9);
+      return { name: m.name, unit: m.unit || "", per, basis: m.basis || "area", round: m.round !== false, note: m.note || "", basis_qty: round22(basisVal), qty };
+    });
+    return {
+      id: c.id,
+      finish_tag: c.finish_tag,
+      color: c.color,
+      fill: c.fill,
+      hatch: c.hatch,
+      multiplier: mult,
+      waste_pct: waste,
+      shape_count: cs.length,
+      floor_sf: round22(floor),
+      wall_sf: round22(wall),
+      border_sf: round22(border),
+      lf: round22(lf),
+      ea,
+      total_sf: round22(total),
+      // waste-adjusted (order quantities)
+      floor_sf_net: round22(floor * w),
+      wall_sf_net: round22(wall * w),
+      border_sf_net: round22(border * w),
+      lf_net: round22(lf * w),
+      total_sf_net: round22(total * w),
+      sy_net: round22(total * w / 9),
+      materials
+    };
+  });
+}
+function grandTotals(rows) {
+  const sum = (k) => rows.reduce((n, r) => n + (r[k] || 0), 0);
+  return {
+    total_sf: round22(sum("total_sf")),
+    total_sf_net: round22(sum("total_sf_net")),
+    lf: round22(sum("lf")),
+    lf_net: round22(sum("lf_net")),
+    ea: sum("ea"),
+    sy_net: round22(sum("sy_net"))
+  };
+}
+
+// src/session.ts
+var SNAP_CELL = 24;
+var SNAP_TOL = 7;
+var PALETTE = ["#c96442", "#2f7d54", "#2563eb", "#9333ea", "#b8860b", "#0d9488", "#be185d", "#1f2937", "#dc2626", "#0891b2"];
+var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert", "grid", "brick", "plank", "herring", "basket", "checker", "wave", "fleur", "speckle"];
+var _idn = 0;
+var uid = (p) => `${p}-${Date.now().toString(36)}-${(_idn++).toString(36)}`;
+var ANN_SCHEMA = "opentakeoff.takeoff_canvas.v1";
+var sheetSummary = (s) => ({
+  sheet: s.key,
+  page: s.pageNum,
+  width_pt: s.widthPt,
+  height_pt: s.heightPt,
+  width_px: s.widthPx,
+  height_px: s.heightPx,
+  ...s.sheetNumber ? { sheet_number: s.sheetNumber } : {},
+  ...s.detected ? { detected_scale: s.detected.label } : {}
+});
+var Session = class {
+  file = null;
+  doc = null;
+  sheets = /* @__PURE__ */ new Map();
+  conditions = [];
+  shapes = [];
+  /** load_plan replaces the session's document: the old doc is destroyed and
+   * ALL state — scales, caches, conditions, shapes — is cleared. */
+  async loadPlan(filePath) {
+    if (this.doc) await this.doc.destroy().catch(() => {
+    });
+    this.doc = null;
+    this.sheets.clear();
+    this.conditions = [];
+    this.shapes = [];
+    this.file = null;
+    const doc = await openPdf(filePath);
+    this.doc = doc;
+    this.file = path2.basename(filePath);
+    for (let n = 1; n <= doc.numPages; n++) {
+      const ph = await doc.page(n);
+      const key = n === 1 ? this.file : `${this.file}#${n}`;
+      this.sheets.set(key, {
+        key,
+        pageNum: n,
+        widthPt: ph.widthPt,
+        heightPt: ph.heightPt,
+        widthPx: ph.viewport.width,
+        heightPx: ph.viewport.height,
+        sheetNumber: extractSheetNumber(ph.textContent, ph.viewport),
+        detected: detectScale(ph.textContent, ph.viewport),
+        upp: null,
+        text: positionedText(ph),
+        page: ph
+      });
+    }
+    return {
+      file: this.file,
+      page_count: doc.numPages,
+      sheets: [...this.sheets.values()].map(sheetSummary),
+      note: "Replaced the previous session \u2014 all prior scales, conditions, and shapes were cleared."
+    };
+  }
+  sheet(name) {
+    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    const hit = this.sheets.get(name);
+    if (hit) return hit;
+    const wanted = name.toUpperCase().replace(/\s+/g, "");
+    for (const s of this.sheets.values()) if (s.sheetNumber === wanted) return s;
+    throw new UserError(`Unknown sheet "${name}" \u2014 loaded sheets: ${[...this.sheets.keys()].join(", ")}.`);
+  }
+  async ensureGeometry(s) {
+    if (!s.geo) {
+      const opList = await s.page.operatorList();
+      s.geo = extractVectorGeometry(opList, s.page.viewport.transform, OPS2);
+      s.snap = buildSnapGrid(s.geo.points, SNAP_CELL);
+    }
+    return s.geo;
+  }
+  /** 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. */
+  async ensureMask(name) {
+    const s = this.sheet(name);
+    if (s.mask === void 0) {
+      const geo = await this.ensureGeometry(s);
+      s.mask = geo.segs.length ? buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta) : null;
+    }
+    return s.mask;
+  }
+  async sheetInfo(name) {
+    const s = this.sheet(name);
+    const geo = await this.ensureGeometry(s);
+    return {
+      ...sheetSummary(s),
+      seg_count: geo.segs.length >> 2,
+      has_vector_linework: geo.segs.length > 0,
+      scale_set: s.upp != null,
+      ...s.upp != null ? { upp: s.upp } : {},
+      shape_count: this.shapes.filter((x) => x.sheet_id === s.key).length
+    };
+  }
+  scaleGate(s) {
+    return `Set the scale for ${s.key} first \u2014 use set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.`;
+  }
+  setScale(name, mode) {
+    const s = this.sheet(name);
+    let upp;
+    let label;
+    let source;
+    if (mode.label !== void 0) {
+      const sc = STANDARD_SCALES.find((x) => x.label === mode.label);
+      if (!sc) throw new UserError(`Unknown scale label ${JSON.stringify(mode.label)}. Valid labels: ${STANDARD_SCALES.map((x) => x.label).join(" | ")}`);
+      upp = sc.upp;
+      label = sc.label;
+      source = "label";
+    } else if (mode.upp !== void 0) {
+      if (!(mode.upp > 0)) throw new UserError("upp must be a positive number (real feet per image px at render scale 2.0).");
+      upp = mode.upp;
+      source = "upp";
+    } else if (mode.calibrate !== void 0) {
+      const { p1, p2, feet } = mode.calibrate;
+      const px = Math.hypot(p2[0] - p1[0], p2[1] - p1[1]);
+      if (!(px > 0)) throw new UserError("Calibration points are identical \u2014 click two points along a known dimension.");
+      if (!(feet > 0)) throw new UserError("Calibration feet must be positive.");
+      upp = feet / px;
+      source = "calibrate";
+    } else if (mode.use_detected) {
+      if (!s.detected) throw new UserError(`No detected scale for ${s.key} \u2014 read the title block with read_sheet_text, or calibrate from a known dimension.`);
+      upp = s.detected.upp;
+      label = s.detected.label;
+      source = "detected";
+    } else {
+      throw new UserError("Provide exactly one of: label, upp, calibrate, use_detected.");
+    }
+    s.upp = upp;
+    return { sheet: s.key, upp, ...label ? { label } : {}, source };
+  }
+  conditionFor(tag) {
+    let c = this.conditions.find((x) => x.finish_tag === tag);
+    if (!c) {
+      const lc = PALETTE[this.conditions.length % PALETTE.length];
+      c = {
+        id: uid("cnd"),
+        finish_tag: tag,
+        color: lc,
+        fill: lc,
+        hatch: HATCH_IDS[1 + this.conditions.length % (HATCH_IDS.length - 1)],
+        multiplier: 1,
+        waste_pct: 0,
+        materials: []
+      };
+      this.conditions.push(c);
+    }
+    return c;
+  }
+  commit(s, tag, role, vertsPx, computed, origin) {
+    const c = this.conditionFor(tag);
+    const shape = {
+      id: uid("shp"),
+      sheet_id: s.key,
+      condition_id: c.id,
+      measure_role: role,
+      verts_norm: vertsPx.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
+      computed,
+      ...origin ? { origin } : {}
+    };
+    this.shapes.push(shape);
+    return shape;
+  }
+  async oneClick(name, x, y, opts) {
+    const s = this.sheet(name);
+    const mask = await this.ensureMask(name);
+    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);
+    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);
+    if (ring.length < 3) throw new UserError("Couldn't trace that space into a polygon.");
+    const areaPx2 = ringArea(ring);
+    const perimPx = closedMetrics(ring).perim;
+    const common = {
+      status: "ok",
+      nverts: ring.length,
+      ...f.hatchFiltered ? { hatch_filtered: true } : {},
+      ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
+    };
+    if (s.upp == null) {
+      return {
+        ...common,
+        area_px2: round1(areaPx2),
+        perimeter_px: round1(perimPx),
+        warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.`
+      };
+    }
+    const upp = s.upp;
+    const area_sf = round2(areaPx2 * upp * upp);
+    const perimeter_lf = round2(perimPx * upp);
+    let shape_id;
+    if (opts.condition) {
+      shape_id = this.commit(s, opts.condition, opts.role, ring, { area_sf, perimeter_lf }, {
+        method: "one_click_v1",
+        seed_norm: [x / s.widthPx, y / s.heightPx],
+        reviewed: true,
+        ...f.hatchFiltered ? { hatch_filtered: true } : {}
+      }).id;
+    }
+    return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
+  }
+  measurePolygon(name, verts, opts) {
+    const s = this.sheet(name);
+    if (s.upp == null) throw new UserError(this.scaleGate(s));
+    const met = closedMetrics(verts);
+    const area_sf = round2(met.area * s.upp * s.upp);
+    const perimeter_lf = round2(met.perim * s.upp);
+    let shape_id;
+    if (opts.condition) shape_id = this.commit(s, opts.condition, opts.role, verts, { area_sf, perimeter_lf }).id;
+    return { area_sf, perimeter_lf, nverts: verts.length, ...shape_id ? { shape_id } : {} };
+  }
+  measureLine(name, pts, opts) {
+    const s = this.sheet(name);
+    if (s.upp == null) throw new UserError(this.scaleGate(s));
+    const length_lf = round2(openLen(pts) * s.upp);
+    let shape_id;
+    if (opts.condition) shape_id = this.commit(s, opts.condition, "linear", pts, { area_sf: 0, perimeter_lf: length_lf }).id;
+    return { length_lf, npts: pts.length, ...shape_id ? { shape_id } : {} };
+  }
+  summary() {
+    const rows = conditionTotals(this.conditions, this.shapes);
+    const lean = rows.map(({ color, fill, hatch, materials, ...rest }) => rest);
+    return { conditions: lean, totals: grandTotals(rows) };
+  }
+  deleteShape(id) {
+    const i = this.shapes.findIndex((x) => x.id === id);
+    if (i < 0) throw new UserError(`No shape with id ${JSON.stringify(id)}.`);
+    this.shapes.splice(i, 1);
+    return { deleted: id, shape_count: this.shapes.length };
+  }
+  /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
+   * store.saveAnnotations stamps) — importable by the app. */
+  exportPayload() {
+    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    return {
+      schema: ANN_SCHEMA,
+      project_name: "",
+      units: "imperial",
+      sheets: [...this.sheets.values()].filter((s) => s.upp != null).map((s) => ({ sheet_id: s.key, units_per_px: s.upp })),
+      conditions: this.conditions,
+      shapes: this.shapes,
+      markups: [],
+      sheet_group: [],
+      last_group: [],
+      sheet_tabs: [],
+      sheet_levels: {}
+    };
+  }
+  readSheetText(name, region) {
+    const s = this.sheet(name);
+    const items = region ? s.text.filter((t) => t.x >= region.x0 && t.x <= region.x1 && t.y >= region.y0 && t.y <= region.y1) : s.text;
+    return { sheet: s.key, items, text: items.map((t) => t.str).join(" ") };
+  }
+};
+
+// src/tools.ts
+import { z } from "zod";
+var COORDS = "Coordinates are image px at render scale 2.0: PDF pt \xD7 2, origin top-left, y down (the browser canvas's native space). Sheet payloads carry dims in both px and pt.";
+var pointSchema = z.tuple([z.number(), z.number()]);
+var roleSchema = z.enum(["floor_area", "deduct"]).default("floor_area");
+var run = (fn) => async (args) => {
+  try {
+    return ok(await fn(args));
+  } catch (e) {
+    return fail(e);
+  }
+};
+function registerTools(server, session) {
+  server.registerTool("load_plan", {
+    description: `Open a plan PDF from disk and replace the whole session (previous document, scales, conditions, and shapes are cleared). Returns file, page_count, and one entry per sheet: dims, title-block sheet_number, and the detected drawn scale where present. ${COORDS}`,
+    inputSchema: { path: z.string().describe("Path to a plan PDF on disk") }
+  }, run(({ path: path3 }) => session.loadPlan(path3)));
+  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}`,
+    inputSchema: { sheet: z.string().describe('Sheet key ("plan.pdf", "plan.pdf#2") or title-block number ("A-101")') }
+  }, run(({ sheet }) => session.sheetInfo(sheet)));
+  server.registerTool("set_scale", {
+    description: `Set a sheet's scale \u2014 exactly ONE of: label (a standard scale, e.g. '1/4" = 1'-0"'), upp (real feet per image px), calibrate (two points along a known dimension plus its real feet), or use_detected (adopt the drawn scale note read off the sheet). The detected scale is never applied automatically \u2014 setting it is always this explicit call. ${COORDS}`,
+    inputSchema: {
+      sheet: z.string(),
+      label: z.string().optional().describe("A standard scale label, exactly as listed in the error on a miss"),
+      upp: z.number().optional().describe("Real feet per image px at render scale 2.0"),
+      calibrate: z.object({ p1: pointSchema, p2: pointSchema, feet: z.number() }).optional().describe("Two points (image px) a known real distance apart, and that distance in feet"),
+      use_detected: z.boolean().optional().describe("true = adopt the sheet's detected scale")
+    }
+  }, run((a) => {
+    const given = [a.label !== void 0, a.upp !== void 0, a.calibrate !== void 0, a.use_detected !== void 0].filter(Boolean).length;
+    if (given !== 1) throw new UserError("Provide exactly one of: label, upp, calibrate, use_detected.");
+    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. ${COORDS}`,
+    inputSchema: {
+      sheet: z.string(),
+      x: z.number(),
+      y: z.number(),
+      condition: z.string().optional().describe("Finish tag to commit under (minted on first use)"),
+      role: roleSchema,
+      return_verts: z.boolean().default(false).describe("Include the traced polygon's vertices (image px)")
+    }
+  }, run((a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts })));
+  server.registerTool("measure_polygon", {
+    description: `Measure a closed polygon you supply (min 3 vertices, image px): area_sf and perimeter_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it; role "deduct" subtracts. ${COORDS}`,
+    inputSchema: {
+      sheet: z.string(),
+      verts: z.array(pointSchema).min(3),
+      condition: z.string().optional(),
+      role: roleSchema
+    }
+  }, run((a) => session.measurePolygon(a.sheet, a.verts, { condition: a.condition, role: a.role })));
+  server.registerTool("measure_line", {
+    description: `Measure an open polyline (min 2 points, image px): length_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it as a linear shape (base, transitions, feature strips). ${COORDS}`,
+    inputSchema: {
+      sheet: z.string(),
+      pts: z.array(pointSchema).min(2),
+      condition: z.string().optional()
+    }
+  }, run((a) => session.measureLine(a.sheet, a.pts, { condition: a.condition })));
+  server.registerTool("takeoff_summary", {
+    description: `Per-condition totals (floor/wall/border SF, LF, EA, SY, with and without waste) plus grand totals \u2014 the Report's numbers, computed by the same rules. ${COORDS}`,
+    inputSchema: {}
+  }, run(() => session.summary()));
+  server.registerTool("export_takeoff", {
+    description: `The full "opentakeoff.takeoff_canvas.v1" annotations payload \u2014 exactly what the app autosaves, importable by it. Returned inline; pass path to also write it to disk as JSON. ${COORDS}`,
+    inputSchema: { path: z.string().optional().describe("File path to write the payload to") }
+  }, run(async ({ path: outPath }) => {
+    const payload = session.exportPayload();
+    if (outPath) {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(outPath, JSON.stringify(payload));
+    }
+    return payload;
+  }));
+  server.registerTool("delete_shape", {
+    description: `Remove a committed shape by the id returned when it was committed. ${COORDS}`,
+    inputSchema: { shape_id: z.string() }
+  }, run(({ shape_id }) => session.deleteShape(shape_id)));
+  server.registerTool("read_sheet_text", {
+    description: `The sheet's text with positions \u2014 items [{str, x, y}] in image px plus the joined text. Optionally restrict to a region {x0, y0, x1, y1}. Use it to read title blocks, room labels, finish schedules, and scale notes. ${COORDS}`,
+    inputSchema: {
+      sheet: z.string(),
+      region: z.object({ x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number() }).optional()
+    }
+  }, run((a) => session.readSheetText(a.sheet, a.region)));
+}
+
+// server.ts
+function buildServer(session = new Session()) {
+  const server = new McpServer({ name: "opentakeoff", version: "0.1.0" });
+  registerTools(server, session);
+  return server;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await buildServer().connect(new StdioServerTransport());
+}
+export {
+  buildServer
+};