opentakeoff-mcp 0.9.63 → 0.9.65

package/README.md

@@ -158,6 +158,7 @@ reads the tool list once. ([#230](https://github.com/Kentucky-ai/opentakeoff/iss
 | `export_report` | The **computed Report document**—`opentakeoff.report.v1`, the same JSON the canvas Report exports: gross + waste-adjusted quantities, the computed materials **buy list** per condition plus the project-wide roll-up, per-sheet base subtotals, and scale provenance. The contract for pricing consumers—`export_takeoff` carries materials as config rows, `takeoff_summary` strips them. Inline, and to disk with `path` (see **Writing to disk** below). |
 | `import_takeoff` | **The way back in**: load a `takeoff_canvas.v1` file (a prior `export_takeoff`, or the app's own save) through the SAME merge rules as the app's Sheet-menu import—finish-tag identity joins conditions (this session's knobs win), new ids append, duplicates skip (idempotent re-import), this session's calibration wins per sheet. Resume, extend, or audit. Correction rules (#88) ride the file too—`apply_rules` re-runs them. |
 | `apply_rules` | **Re-run the correction rules the takeoff arrived with** (#207)—the lessons an estimator TAUGHT the canvas (#88), for example, "every room like this loses the mechanical chase". Same pure `rules.ts` engine the canvas Preview runs; committed as the ONE batch its Apply makes (`reviewed: false`, one undo step, `origin {method rule_v1, actor rule}` with the rule/seed/room citation). The reply's per-rule disclosure—produced, skipped, ids—IS the preview an agent gets. Idempotent by construction: anything an existing deduct covers is dropped by the engine, so re-running after new rooms commit is the intended workflow. Rules arrive ONLY through `import_takeoff`; minting one is an estimator's correction and stays behind the canvas's human Preview→Apply gate. |
+| `export_dxf` | The takeoff as a **CAD drawing**—a DXF (R2000) that AutoCAD, BricsCAD, LibreCAD and Revit import as native geometry. One sheet per file, like a DWG: every committed shape becomes an `LWPOLYLINE` (floor rings closed, walls and linear runs open, counts a circle) on a layer named for its finish—`OT-<TAG>`, with `-DEDUCT` / `-HOLE` / `-WALL` / `-LINEAR` / `-COUNT` suffix layers and room labels on `OT-LABELS`. Real units in the sheet's frame (origin bottom-left, Y up; feet, or `units:"m"`), and a ring's CAD area equals its `export_report` area to rounding. Refuses without a scale; with several sheets carrying shapes, `sheet` picks the drawing. Names every shape left out and why. `path` required. |
 | `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 (see **Writing to disk** below). Works without `@napi-rs/canvas`. |
 | `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, room `label`, 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. |

package/dist/server-core.js

@@ -1432,6 +1432,306 @@ function classifyOffsetAnnotationSegs(segs, meta, ws, maxOffsetPx, minOffsetPx,
   }
   return soft;
 }
+var DIMSTR_ANGLE_TOL = 2;
+var DIMSTR_CHAIN_GAP_FT = 0.6;
+var DIMSTR_CHAIN_GAP_PX = 3;
+var DIMSTR_CHAIN_OFF_FT = 0.06;
+var DIMSTR_CHAIN_OFF_PX = 1.25;
+var DIMSTR_RUN_MIN_FT = 4;
+var DIMSTR_ISO_OFF_FT = 1;
+var DIMSTR_ISO_OVERLAP = 0.4;
+var DIMSTR_WITNESS_MIN_FT = 0.3;
+var DIMSTR_WITNESS_SOFT_MAX_FT = 8;
+var DIMSTR_ATTACH_FT = 0.35;
+var DIMSTR_ATTACH_PX = 2;
+var DIMSTR_JUNCTION_MIN_FT = 1.5;
+var DIMSTR_WIT_PER_JUNCTION_MAX = 2;
+var DIMSTR_TICK_MIN_FT = 0.2;
+var DIMSTR_TICK_MAX_FT = 1.5;
+var DIMSTR_TICK_ANG_LO = 20;
+var DIMSTR_TICK_ANG_HI = 70;
+var DIMSTR_TICK_AT_JUNCTION_FT = 0.5;
+var DIMSTR_MIN_JUNCTIONS = 2;
+var DIMSTR_MIN_TICKED = 2;
+var DIMSTR_TICKED_FRAC = 0.5;
+var DIMSTR_OVERSHOOT_FT = 0.1;
+var DIMSTR_OVERSHOOT_PX = 2;
+var DIMSTR_TOUCH_CLUTTER_MAX = 1;
+var DIMTEXT_NEAR_FT = 1;
+var DIMTEXT_REACH_FT = 40;
+var DIMTEXT_MIN_LINE_X = 1.5;
+var DIMTEXT_STUB_MAX_FT = 2.5;
+var DIMSTR_LINE_MARGIN_FT = 0.5;
+var DIMSTR_PIECE_MAX_DIMFRAC = 0.66;
+var DIMSTR_PIECE_MAX_CURVEFRAC = 0.25;
+var DIMSTR_BAND_FT = 0.7;
+var DIMSTR_BAND_CLUTTER_MAX = 4;
+function sweepDimensionStrings(segs, meta, ws, ftPx, rejects, dimTexts) {
+  const n = segs.length >> 2;
+  const soft = new Uint8Array(n);
+  const hits = [];
+  if (!meta || !n || !(ftPx > 0)) return { soft, runs: hits };
+  const cand = [];
+  for (let i = 0; i < n; i++) {
+    if (meta[i] & (SEG_CURVE | SEG_CLIP | 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 L = Math.hypot(x2 - x1, y2 - y1);
+    if (!(L > 0)) continue;
+    let ang = Math.atan2(y2 - y1, x2 - x1) * 180 / Math.PI;
+    if (ang < 0) ang += 180;
+    if (ang >= 180) ang -= 180;
+    cand.push({ i, ang, x1, y1, x2, y2, L });
+  }
+  if (!cand.length) return { soft, runs: hits };
+  const BIN = DIMSTR_ANGLE_TOL, NB = Math.round(180 / BIN);
+  const gap = Math.max(DIMSTR_CHAIN_GAP_PX, DIMSTR_CHAIN_GAP_FT * ftPx);
+  const offTol = Math.max(DIMSTR_CHAIN_OFF_PX, DIMSTR_CHAIN_OFF_FT * ftPx);
+  const chains = [];
+  const claimed = new Uint8Array(n);
+  for (const shift of [0, BIN / 2]) {
+    const bins = /* @__PURE__ */ new Map();
+    for (const c of cand) {
+      if (claimed[c.i]) continue;
+      let b = Math.floor((c.ang + shift) / BIN);
+      if (b >= NB) b -= NB;
+      const axis = ((b * BIN - shift + BIN / 2) % 180 + 180) % 180;
+      const th = axis * Math.PI / 180, dx = Math.cos(th), dy = Math.sin(th), nx = -dy, ny = dx;
+      const r = {
+        c,
+        d: (c.x1 + c.x2) / 2 * nx + (c.y1 + c.y2) / 2 * ny,
+        t0: Math.min(c.x1 * dx + c.y1 * dy, c.x2 * dx + c.y2 * dy),
+        t1: Math.max(c.x1 * dx + c.y1 * dy, c.x2 * dx + c.y2 * dy)
+      };
+      const arr2 = bins.get(b);
+      if (arr2) arr2.push(r);
+      else bins.set(b, [r]);
+    }
+    for (const [b, rows] of bins) {
+      const axis = ((b * BIN - shift + BIN / 2) % 180 + 180) % 180;
+      rows.sort((a, z4) => a.d - z4.d || a.t0 - z4.t0);
+      let g0 = 0;
+      for (let k = 1; k <= rows.length; k++) {
+        if (k < rows.length && rows[k].d - rows[k - 1].d <= offTol) continue;
+        const grp = rows.slice(g0, k).sort((a, z4) => a.t0 - z4.t0 || a.t1 - z4.t1);
+        let cur = null;
+        const flush = () => {
+          if (!cur) return;
+          if (shift === 0 || cur.members.length > 1 || !claimed[cur.members[0]]) {
+            if (shift === 0 && cur.members.length < 2) {
+              cur = null;
+              return;
+            }
+            cur.d = cur.dSum / cur.members.length;
+            cur.len = cur.t1 - cur.t0;
+            const th = axis * Math.PI / 180, dx = Math.cos(th), dy = Math.sin(th), nx = -dy, ny = dx;
+            cur.p0 = [cur.t0 * dx + cur.d * nx, cur.t0 * dy + cur.d * ny];
+            cur.p1 = [cur.t1 * dx + cur.d * nx, cur.t1 * dy + cur.d * ny];
+            chains.push(cur);
+            for (const m of cur.members) claimed[m] = 1;
+          }
+          cur = null;
+        };
+        for (const r of grp) {
+          if (cur && r.t0 - cur.t1 <= gap) {
+            cur.t1 = Math.max(cur.t1, r.t1);
+            cur.members.push(r.c.i);
+            cur.dSum += r.d;
+          } else {
+            flush();
+            cur = { axis, d: 0, dSum: r.d, t0: r.t0, t1: r.t1, len: 0, members: [r.c.i], p0: [0, 0], p1: [0, 0] };
+          }
+        }
+        flush();
+        g0 = k;
+      }
+    }
+  }
+  const runMin = DIMSTR_RUN_MIN_FT * ftPx, isoOff = DIMSTR_ISO_OFF_FT * ftPx;
+  const wMin = DIMSTR_WITNESS_MIN_FT * ftPx, wSoftMax = DIMSTR_WITNESS_SOFT_MAX_FT * ftPx;
+  const attach = Math.max(DIMSTR_ATTACH_PX, DIMSTR_ATTACH_FT * ftPx);
+  const jMin = DIMSTR_JUNCTION_MIN_FT * ftPx;
+  const tickMin = DIMSTR_TICK_MIN_FT * ftPx, tickMax = DIMSTR_TICK_MAX_FT * ftPx;
+  const tickAt = DIMSTR_TICK_AT_JUNCTION_FT * ftPx;
+  const over = Math.max(DIMSTR_OVERSHOOT_PX, DIMSTR_OVERSHOOT_FT * ftPx);
+  const band = DIMSTR_BAND_FT * ftPx;
+  const hasParallelPartner = (C, skip) => {
+    const th = C.axis * Math.PI / 180, dx = Math.cos(th), dy = Math.sin(th), nx = -dy, ny = dx;
+    for (const O of chains) {
+      if (O === C || O === skip) continue;
+      let rel = Math.abs(O.axis - C.axis);
+      if (rel > 90) rel = 180 - rel;
+      if (rel > 3 * DIMSTR_ANGLE_TOL) continue;
+      const d0 = O.p0[0] * nx + O.p0[1] * ny - C.d, d1 = O.p1[0] * nx + O.p1[1] * ny - C.d;
+      const gapAbs = Math.min(Math.abs(d0), Math.abs(d1));
+      if (gapAbs > isoOff || gapAbs < attach / 2) continue;
+      const t0 = Math.min(O.p0[0] * dx + O.p0[1] * dy, O.p1[0] * dx + O.p1[1] * dy);
+      const t1 = Math.max(O.p0[0] * dx + O.p0[1] * dy, O.p1[0] * dx + O.p1[1] * dy);
+      if (Math.min(t1, C.t1) - Math.max(t0, C.t0) >= DIMSTR_ISO_OVERLAP * C.len) return true;
+    }
+    return false;
+  };
+  const reject = (R, why) => {
+    rejects?.push({ axis: R.axis, d: R.d, t0: R.t0, t1: R.t1, lenFt: R.len / ftPx, why });
+  };
+  for (const R of chains) {
+    if (R.len < runMin) continue;
+    if (hasParallelPartner(R, null)) {
+      reject(R, "iso");
+      continue;
+    }
+    const th = R.axis * Math.PI / 180, dx = Math.cos(th), dy = Math.sin(th), nx = -dy, ny = dx;
+    const wit = [], ticks = [];
+    let touchClutter = 0;
+    for (const C of chains) {
+      if (C === R) continue;
+      const d0 = C.p0[0] * nx + C.p0[1] * ny - R.d, d1 = C.p1[0] * nx + C.p1[1] * ny - R.d;
+      const near0 = Math.abs(d0) <= attach, near1 = Math.abs(d1) <= attach;
+      const crosses = d0 < -attach && d1 > attach || d1 < -attach && d0 > attach;
+      if (!near0 && !near1 && !crosses) continue;
+      const t0 = C.p0[0] * dx + C.p0[1] * dy, t1 = C.p1[0] * dx + C.p1[1] * dy;
+      const tm = (t0 + t1) / 2;
+      const tRef = near0 && !near1 ? t0 : near1 && !near0 ? t1 : tm;
+      if (tRef < R.t0 - attach || tRef > R.t1 + attach) continue;
+      let rel = Math.abs(C.axis - R.axis);
+      if (rel > 90) rel = 180 - rel;
+      if (rel >= 90 - 2 * DIMSTR_ANGLE_TOL && C.len >= wMin) {
+        wit.push({ t: tRef, C, past: crosses || near0 && near1 });
+      } else if (rel >= DIMSTR_TICK_ANG_LO && rel <= DIMSTR_TICK_ANG_HI && C.len >= tickMin && C.len <= tickMax && Math.abs((d0 + d1) / 2) <= attach) {
+        ticks.push({ t: tm, C, past: false });
+      } else if (++touchClutter > DIMSTR_TOUCH_CLUTTER_MAX) break;
+    }
+    if (touchClutter > DIMSTR_TOUCH_CLUTTER_MAX) {
+      reject(R, "touch-clutter");
+      continue;
+    }
+    const live = wit.filter((w) => w.past || w.t >= R.t0 + over && w.t <= R.t1 - over);
+    if (live.length < DIMSTR_MIN_JUNCTIONS) {
+      reject(R, `witnesses (raw=${wit.length} live=${live.length} ticks=${ticks.length})`);
+      continue;
+    }
+    live.sort((a, z4) => a.t - z4.t);
+    const junc = [];
+    let dense = false;
+    for (const w of live) {
+      const j = junc[junc.length - 1];
+      if (j && w.t - j.t < jMin) {
+        if (++j.n > DIMSTR_WIT_PER_JUNCTION_MAX) {
+          dense = true;
+          break;
+        }
+      } else junc.push({ t: w.t, n: 1 });
+    }
+    if (dense || junc.length < DIMSTR_MIN_JUNCTIONS) {
+      reject(R, dense ? "dense" : "junctions");
+      continue;
+    }
+    let ticked = 0;
+    const usedTicks = [];
+    for (const j of junc) {
+      const t = ticks.find((tk) => Math.abs(tk.t - j.t) <= tickAt);
+      if (t) {
+        ticked++;
+        usedTicks.push(t);
+      }
+    }
+    if (ticked < DIMSTR_MIN_TICKED || ticked < DIMSTR_TICKED_FRAC * junc.length) {
+      reject(R, `ticked (junc=${junc.length} ticked=${ticked} ticks=${ticks.length})`);
+      continue;
+    }
+    const witSet = new Set(live.map((w) => w.C)), tickSet = new Set(usedTicks.map((t) => t.C));
+    let bandClutter = 0;
+    for (const C of chains) {
+      if (C === R || witSet.has(C) || tickSet.has(C)) continue;
+      const mx = (C.p0[0] + C.p1[0]) / 2, my = (C.p0[1] + C.p1[1]) / 2;
+      if (Math.abs(mx * nx + my * ny - R.d) > band) continue;
+      const tt = mx * dx + my * dy;
+      if (tt < R.t0 || tt > R.t1) continue;
+      if (++bandClutter > DIMSTR_BAND_CLUTTER_MAX) break;
+    }
+    if (bandClutter > DIMSTR_BAND_CLUTTER_MAX) {
+      reject(R, "band-clutter");
+      continue;
+    }
+    hits.push(R);
+    for (const m of R.members) soft[m] = 1;
+    for (const t of usedTicks) for (const m of t.C.members) soft[m] = 1;
+    for (const w of live) {
+      if (w.C.len > wSoftMax) continue;
+      if (hasParallelPartner(w.C, R)) continue;
+      for (const m of w.C.members) soft[m] = 1;
+    }
+  }
+  if (dimTexts && dimTexts.length) {
+    const near = DIMTEXT_NEAR_FT * ftPx;
+    const reach = DIMTEXT_REACH_FT * ftPx;
+    const margin = DIMSTR_LINE_MARGIN_FT * ftPx;
+    for (const T of dimTexts) {
+      const ang = (T.ang % 180 + 180) % 180;
+      const th = ang * Math.PI / 180, dx = Math.cos(th), dy = Math.sin(th), nx = -dy, ny = dx;
+      const tx = T.x * ws, ty = T.y * ws;
+      const dT = tx * nx + ty * ny, tT = tx * dx + ty * dy;
+      const pieces = [];
+      let dSum = 0, wSum = 0;
+      for (const C of chains) {
+        let rel = Math.abs(C.axis - ang);
+        if (rel > 90) rel = 180 - rel;
+        if (rel > 2 * DIMSTR_ANGLE_TOL) continue;
+        const cd = (C.p0[0] + C.p1[0]) / 2 * nx + (C.p0[1] + C.p1[1]) / 2 * ny;
+        if (Math.abs(cd - dT) > near) continue;
+        const ct0 = Math.min(C.p0[0] * dx + C.p0[1] * dy, C.p1[0] * dx + C.p1[1] * dy);
+        const ct1 = Math.max(C.p0[0] * dx + C.p0[1] * dy, C.p1[0] * dx + C.p1[1] * dy);
+        if (ct1 < tT - reach || ct0 > tT + reach) continue;
+        pieces.push(C);
+        dSum += cd * C.len;
+        wSum += C.len;
+      }
+      if (!wSum) continue;
+      let t0 = Infinity, t1 = -Infinity, drawn = 0;
+      for (const C of pieces) {
+        t0 = Math.min(t0, Math.min(C.p0[0] * dx + C.p0[1] * dy, C.p1[0] * dx + C.p1[1] * dy));
+        t1 = Math.max(t1, Math.max(C.p0[0] * dx + C.p0[1] * dy, C.p1[0] * dx + C.p1[1] * dy));
+        drawn += C.len;
+      }
+      if (drawn < Math.max(runMin, DIMTEXT_MIN_LINE_X * T.wPx * ws)) continue;
+      const dLine = dSum / wSum;
+      const proxy = {
+        axis: ang,
+        d: dLine,
+        t0,
+        t1,
+        len: t1 - t0,
+        members: [],
+        p0: [t0 * dx + dLine * nx, t0 * dy + dLine * ny],
+        p1: [t1 * dx + dLine * nx, t1 * dy + dLine * ny]
+      };
+      if (hasParallelPartner(proxy, null)) continue;
+      hits.push(proxy);
+      for (const C of pieces) {
+        if (C.len > t1 - t0 + 2 * margin) continue;
+        if (hasParallelPartner(C, null)) continue;
+        for (const m of C.members) soft[m] = 1;
+      }
+      for (const C of chains) {
+        if (C.len < tickMin || C.len > DIMTEXT_STUB_MAX_FT * ftPx) continue;
+        let rel = Math.abs(C.axis - ang);
+        if (rel > 90) rel = 180 - rel;
+        if (rel < DIMSTR_TICK_ANG_LO) continue;
+        const d0 = C.p0[0] * nx + C.p0[1] * ny - dLine, d1 = C.p1[0] * nx + C.p1[1] * ny - dLine;
+        const near0 = Math.abs(d0) <= attach, near1 = Math.abs(d1) <= attach;
+        const crosses = d0 < -attach && d1 > attach || d1 < -attach && d0 > attach;
+        if (!near0 && !near1 && !crosses) continue;
+        const tm = (C.p0[0] + C.p1[0]) / 2 * dx + (C.p0[1] + C.p1[1]) / 2 * dy;
+        if (tm < t0 - margin || tm > t1 + margin) continue;
+        if (hasParallelPartner(C, null)) continue;
+        for (const m of C.members) soft[m] = 1;
+      }
+    }
+  }
+  return { soft, runs: hits };
+}
+function classifyDimensionStringSegs(segs, meta, ws, ftPx, dimTexts) {
+  return sweepDimensionStrings(segs, meta, ws, ftPx, void 0, dimTexts).soft;
+}
 var HATCH_ID_ANGLE_Q = 0.5;
 var HATCH_ID_PITCH_Q = 0.1;
 function hatchFamilies(segs, meta) {
@@ -1452,7 +1752,8 @@ function hatchFamilies(segs, meta) {
   });
 }
 var MASK_CURVE_BIT = 4;
-function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt = 0, basePxPerFt = 0, page = null, roles = null) {
+var MASK_DIMSTR_BIT = 16;
+function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt = 0, basePxPerFt = 0, page = null, roles = null, dimTexts = null) {
   if (pxPerFt instanceof Uint8Array || pxPerFt === null) {
     if (!roles) roles = pxPerFt;
     pxPerFt = 0;
@@ -1479,15 +1780,20 @@ function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt
   if (soft && annot) {
     for (let i = 0; i < soft.length; i++) if (annot[i]) soft[i] = 1;
   }
+  const dimstr = meta && mppf > 0 ? classifyDimensionStringSegs(segs, meta, ws, mppf, dimTexts) : null;
+  if (soft && dimstr) {
+    for (let i = 0; i < soft.length; i++) if (dimstr[i]) soft[i] = 1;
+  }
   const noDoor = meta ? flagNonDoorArcs(segs, meta) : null;
   let softCount = 0;
   for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
     const role = roles ? roles[si] : 0;
     if (role === 2 || role === 3 || role === 5 || role === 6) continue;
     let v = role === 1 || role === 4 ? 1 : soft && soft[si] ? 2 : 1;
+    if (v === 2 && dimstr && dimstr[si]) v |= MASK_DIMSTR_BIT;
     if (v === 1 && meta && meta[si] & SEG_CURVE) v = 1 | MASK_CURVE_BIT;
     if (v & MASK_CURVE_BIT && noDoor && noDoor[si]) v |= MASK_NODOOR_BIT;
-    if (v === 2) softCount++;
+    if (v & 2 && !(v & 1)) 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);
@@ -2190,6 +2496,112 @@ function sealAttempt(mo, ix, iy, sensitivity, radii, minPassPx = 0, given) {
   const cy = Math.max(0, Math.min(mo.mh - 1, Math.round(iy * mo.ws)));
   const cSoft = (mo.mask[cy * mo.mw + cx] & 2) !== 0;
   const cdt = (s) => cSoft ? 0 : s.dt[cy * mo.mw + cx];
+  const mergeAcrossDimStrings = (ref) => {
+    if (!mo.softCount) return null;
+    const { mw, mh, mask, ws } = mo;
+    const isDim = (i) => (mask[i] & MASK_DIMSTR_BIT) !== 0 && (mask[i] & 1) === 0;
+    const capCells = mw * mh * SEAL_MAX_SHEET_FRAC;
+    const box = boxOf(ref.region, mw, mh);
+    const region = ref.region.slice();
+    let count = ref.count, mergedPieces = 0;
+    const tried = /* @__PURE__ */ new Set();
+    let frontier = true;
+    for (let pass = 0; pass < 8 && frontier; pass++) {
+      frontier = false;
+      const b = { x0: Math.max(1, box.x0 - 2), y0: Math.max(1, box.y0 - 2), x1: Math.min(mw - 2, box.x1 + 2), y1: Math.min(mh - 2, box.y1 + 2) };
+      for (let y = b.y0; y <= b.y1; y++) for (let x = b.x0; x <= b.x1; x++) {
+        const i = y * mw + x;
+        if (!isDim(i)) continue;
+        if (!(region[i - 1] || region[i + 1] || region[i - mw] || region[i + mw])) continue;
+        for (const o of [-1, 1, -mw, mw]) {
+          let j = i + o, steps = 0;
+          while (steps++ < 3 && isDim(j)) j += o;
+          if (region[j] || mask[j] & 3 || tried.has(j)) continue;
+          tried.add(j);
+          const jx = j % mw, jy = j / mw | 0;
+          const fr = floodPass(mo, (jx + 0.5) / ws, (jy + 0.5) / ws, 3);
+          if (fr.status !== "ok") continue;
+          if (count + fr.count > capCells) continue;
+          {
+            const fb2 = boxOf(fr.region, mw, mh);
+            let bAll = 0, bDim = 0, bCurve = 0;
+            for (let yy = Math.max(1, fb2.y0); yy <= Math.min(mh - 2, fb2.y1); yy++) for (let xx = Math.max(1, fb2.x0); xx <= Math.min(mw - 2, fb2.x1); xx++) {
+              const k = yy * mw + xx;
+              if (!fr.region[k]) continue;
+              for (const oo of [-1, 1, -mw, mw]) {
+                const mk = mask[k + oo];
+                if (mk & 3 && !fr.region[k + oo]) {
+                  bAll++;
+                  if (isDim(k + oo)) bDim++;
+                  if (mk & MASK_CURVE_BIT) bCurve++;
+                }
+              }
+            }
+            if (bAll && bDim / bAll > DIMSTR_PIECE_MAX_DIMFRAC) continue;
+            if (bAll && bCurve / bAll > DIMSTR_PIECE_MAX_CURVEFRAC) continue;
+          }
+          for (let k = 0; k < region.length; k++) if (fr.region[k] && !region[k]) {
+            region[k] = 1;
+            count++;
+          }
+          const fb = boxOf(fr.region, mw, mh);
+          box.x0 = Math.min(box.x0, fb.x0);
+          box.y0 = Math.min(box.y0, fb.y0);
+          box.x1 = Math.max(box.x1, fb.x1);
+          box.y1 = Math.max(box.y1, fb.y1);
+          mergedPieces++;
+          frontier = true;
+        }
+      }
+    }
+    if (!mergedPieces) return null;
+    const final = new Uint8Array(mw * mh);
+    const cx0 = Math.max(0, Math.min(mw - 1, Math.round(ix * ws)));
+    const cy0 = Math.max(0, Math.min(mh - 1, Math.round(iy * ws)));
+    let s0 = cy0 * mw + cx0;
+    if (!region[s0]) {
+      s0 = -1;
+      for (let k = 0; k < region.length && s0 < 0; k++) if (ref.region[k]) s0 = k;
+      if (s0 < 0) return null;
+    }
+    const stack = [s0];
+    final[s0] = 1;
+    let fCount = 0;
+    const nb = { x0: mw, y0: mh, x1: 0, y1: 0 };
+    while (stack.length) {
+      const i = stack.pop();
+      fCount++;
+      const x = i % mw, y = i / mw | 0;
+      if (x < nb.x0) nb.x0 = x;
+      if (x > nb.x1) nb.x1 = x;
+      if (y < nb.y0) nb.y0 = y;
+      if (y > nb.y1) nb.y1 = y;
+      for (const o of [-1, 1, -mw, mw]) {
+        const j = i + o;
+        if (j < 0 || j >= final.length || final[j]) continue;
+        const xj = j % mw;
+        if (Math.abs(xj - x) > 1) continue;
+        if (region[j] || isDim(j)) {
+          final[j] = 1;
+          stack.push(j);
+        }
+      }
+    }
+    regionBox.set(final, nb);
+    return {
+      status: "ok",
+      region: final,
+      count: fCount,
+      mw,
+      mh,
+      ws,
+      mppf: mo.mppf,
+      hardHits: ref.hardHits,
+      softHits: ref.softHits,
+      hatchFiltered: true,
+      hatchTier: "bounded"
+    };
+  };
   if (minPassPx > 0) {
     const s = scratch();
     const dm = dilatedView(mo, minPassPx, s.dt);
@@ -2205,7 +2617,7 @@ function sealAttempt(mo, ix, iy, sensitivity, radii, minPassPx = 0, given) {
           f.minPassPx = minPassPx;
           f.minPassDelta = d;
         }
-        return f;
+        return mergeAcrossDimStrings(f) ?? f;
       }
       const vf = f.count > f.mw * f.mh * SEAL_MAX_SHEET_FRAC ? 1 : virtualBoundaryFrac(f, s.dt);
       if (vf <= SEAL_VIRTUAL_MAX) {
@@ -2218,7 +2630,7 @@ function sealAttempt(mo, ix, iy, sensitivity, radii, minPassPx = 0, given) {
     }
   }
   const base = rawFlood();
-  if (base.status === "ok") return base;
+  if (base.status === "ok") return mergeAcrossDimStrings(base) ?? base;
   const sc = scratch();
   for (const r of radii) {
     if (r <= minPassPx) continue;
@@ -3680,6 +4092,483 @@ function splitFromFamily(conds, condId) {
   });
 }
 
+// ../web/src/lib/curve.js
+function crPoint(p0, p1, p2, p3, t) {
+  const knot = (ti, a, b) => ti + Math.sqrt(Math.max(Math.hypot(b[0] - a[0], b[1] - a[1]), 1e-6));
+  const t0 = 0, t1 = knot(t0, p0, p1), t2 = knot(t1, p1, p2), t3 = knot(t2, p2, p3);
+  const u = t1 + (t2 - t1) * t;
+  const lp = (a, b, ta, tb) => {
+    const w = (u - ta) / (tb - ta || 1e-9);
+    return [a[0] + (b[0] - a[0]) * w, a[1] + (b[1] - a[1]) * w];
+  };
+  const A1 = lp(p0, p1, t0, t1), A2 = lp(p1, p2, t1, t2), A3 = lp(p2, p3, t2, t3);
+  const B1 = lp(A1, A2, t0, t2), B2 = lp(A2, A3, t1, t3);
+  return lp(B1, B2, t1, t2);
+}
+function flattenCurve(pts, opts = {}) {
+  const maxPts = opts.maxPts || 220;
+  const n = (pts || []).length;
+  if (n < 3) return (pts || []).map((p) => [p[0], p[1]]);
+  const P = [pts[0], ...pts, pts[n - 1]];
+  const want = [];
+  let total = 0;
+  for (let i = 1; i < P.length - 2; i++) {
+    const chord = Math.hypot(P[i + 1][0] - P[i][0], P[i + 1][1] - P[i][1]);
+    const steps = Math.max(6, Math.min(24, Math.round(chord / 6)));
+    want.push(steps);
+    total += steps;
+  }
+  const scale = total > maxPts ? maxPts / total : 1;
+  const out = [[pts[0][0], pts[0][1]]];
+  for (let i = 1; i < P.length - 2; i++) {
+    const steps = Math.max(2, Math.round(want[i - 1] * scale));
+    for (let j = 1; j <= steps; j++) out.push(crPoint(P[i - 1], P[i], P[i + 1], P[i + 2], j / steps));
+  }
+  return out;
+}
+
+// ../web/src/lib/dxf.ts
+var DXF_STAMP = "OpenTakeoff DXF export";
+var FT_PER_M = 1 / 0.3048;
+var CONDITION_COLORS = [5, 3, 1, 2, 4, 6, 30, 40, 90, 150, 200, 210, 32, 92, 172, 12];
+var COLOR_LABELS = 7;
+var COLOR_HOLE = 8;
+function dxfLayerName(tag, suffix) {
+  let base = String(tag ?? "").trim().replace(/[<>\/\\":;?*|,=`]+/g, "-").replace(/\s+/g, " ").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").toUpperCase();
+  if (!base) base = "UNTAGGED";
+  if (base.length > 48) base = base.slice(0, 48).replace(/-$/, "");
+  return suffix ? `OT-${base}-${suffix}` : `OT-${base}`;
+}
+var fmt = (v) => {
+  const r = Math.round(v * 1e4) / 1e4;
+  return (Object.is(r, -0) ? 0 : r).toString();
+};
+var Dxf = class {
+  out = [];
+  seed = 32;
+  handle() {
+    return (this.seed++).toString(16).toUpperCase();
+  }
+  peek() {
+    return this.seed.toString(16).toUpperCase();
+  }
+  add(code, value) {
+    this.out.push(String(code), String(value));
+  }
+  text() {
+    return this.out.join("\n") + "\n";
+  }
+};
+function polygonCentroid(pts) {
+  let a = 0, cx = 0, cy = 0;
+  const n = pts.length;
+  for (let i = 0; i < n; i++) {
+    const [x0, y0] = pts[i], [x1, y1] = pts[(i + 1) % n];
+    const cross = x0 * y1 - x1 * y0;
+    a += cross;
+    cx += (x0 + x1) * cross;
+    cy += (y0 + y1) * cross;
+  }
+  if (Math.abs(a) < 1e-12) {
+    return [pts.reduce((s, p) => s + p[0], 0) / n, pts.reduce((s, p) => s + p[1], 0) / n];
+  }
+  a *= 0.5;
+  return [cx / (6 * a), cy / (6 * a)];
+}
+function buildSheetDxf(sheet, opts = {}) {
+  const units = opts.units === "m" ? "m" : "ft";
+  const k = units === "m" ? 1 / FT_PER_M : 1;
+  const textH = opts.text_height ?? (units === "m" ? 0.3 : 1);
+  const { w, h } = sheet.dims;
+  const upp = sheet.upp;
+  if (!(w > 0) || !(h > 0)) throw new Error(`DXF: sheet ${sheet.sheet_id} has no image dimensions`);
+  if (!(upp > 0)) throw new Error(`DXF: sheet ${sheet.sheet_id} has no scale \u2014 set the scale before exporting to CAD`);
+  const toXY = ([nx, ny]) => [nx * w * upp * k, (1 - ny) * h * upp * k];
+  const toPx = ([nx, ny]) => [nx * w, ny * h];
+  const fromPx = ([px, py]) => [px * upp * k, (h - py) * upp * k];
+  const condById = new Map(sheet.conditions.map((c) => [c.id, c]));
+  const condColor = /* @__PURE__ */ new Map();
+  sheet.conditions.forEach((c, i) => condColor.set(c.id, CONDITION_COLORS[i % CONDITION_COLORS.length]));
+  const ents = [];
+  const layers = /* @__PURE__ */ new Map();
+  const useLayer = (name, color) => {
+    if (!layers.has(name)) layers.set(name, color);
+    return name;
+  };
+  const skipped = [];
+  let shapesOut = 0;
+  const ext = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+  const grow = ([x, y]) => {
+    if (x < ext.minX) ext.minX = x;
+    if (x > ext.maxX) ext.maxX = x;
+    if (y < ext.minY) ext.minY = y;
+    if (y > ext.maxY) ext.maxY = y;
+  };
+  for (const s of sheet.shapes) {
+    if (s.sheet_id !== sheet.sheet_id) continue;
+    const cond = condById.get(s.condition_id);
+    const tag = cond?.finish_tag || cond?.name || "";
+    const color = condColor.get(s.condition_id) ?? COLOR_LABELS;
+    const verts = Array.isArray(s.verts_norm) ? s.verts_norm : [];
+    const role = s.measure_role;
+    const before = ents.length;
+    if (role === "count") {
+      const c = verts[0];
+      if (!c) {
+        skipped.push({ id: s.id, reason: "count mark without a position" });
+        continue;
+      }
+      const at = toXY(c);
+      ents.push({ kind: "circle", layer: useLayer(dxfLayerName(tag, "COUNT"), color), c: at, r: 0.5 * k });
+      grow([at[0] - 0.5 * k, at[1] - 0.5 * k]);
+      grow([at[0] + 0.5 * k, at[1] + 0.5 * k]);
+    } else if (role === "surface_area" || role === "linear") {
+      if (verts.length < 2) {
+        skipped.push({ id: s.id, reason: `${role} shape with fewer than 2 vertices` });
+        continue;
+      }
+      const px = verts.map(toPx);
+      const run2 = role === "linear" && s.curved ? flattenCurve(px) : px;
+      const pts = run2.map(fromPx);
+      pts.forEach(grow);
+      ents.push({ kind: "lwpoly", layer: useLayer(dxfLayerName(tag, role === "linear" ? "LINEAR" : "WALL"), color), pts, closed: false });
+    } else if (role === "floor_area" || role === "deduct") {
+      if (role === "deduct" && s.cuts_shape_id) {
+        skipped.push({ id: s.id, reason: `deduct reconciled into ${s.cuts_shape_id} \u2014 ships as that ring's hole` });
+        continue;
+      }
+      if (verts.length < 3) {
+        skipped.push({ id: s.id, reason: `${role} ring with fewer than 3 vertices` });
+        continue;
+      }
+      const pts = verts.map(toXY);
+      pts.forEach(grow);
+      const layer = useLayer(role === "deduct" ? dxfLayerName(tag, "DEDUCT") : dxfLayerName(tag), color);
+      ents.push({ kind: "lwpoly", layer, pts, closed: true });
+      for (const ring of s.verts_norm_holes || []) {
+        if (!Array.isArray(ring) || ring.length < 3) continue;
+        const hp = ring.map(toXY);
+        hp.forEach(grow);
+        ents.push({ kind: "lwpoly", layer: useLayer(dxfLayerName(tag, "HOLE"), COLOR_HOLE), pts: hp, closed: true });
+      }
+      if (role === "floor_area" && s.label && String(s.label).trim()) {
+        ents.push({ kind: "text", layer: useLayer("OT-LABELS", COLOR_LABELS), at: polygonCentroid(pts), text: String(s.label).trim(), height: textH });
+      }
+    } else {
+      skipped.push({ id: s.id, reason: `unknown measure_role "${role}"` });
+      continue;
+    }
+    if (ents.length > before) shapesOut++;
+  }
+  const hasExt = Number.isFinite(ext.minX);
+  const extents = hasExt ? { min: [ext.minX, ext.minY], max: [ext.maxX, ext.maxY] } : null;
+  const d = new Dxf();
+  const H = {
+    vportTbl: d.handle(),
+    vportActive: d.handle(),
+    ltypeTbl: d.handle(),
+    ltByBlock: d.handle(),
+    ltByLayer: d.handle(),
+    ltCont: d.handle(),
+    layerTbl: d.handle(),
+    layer0: d.handle(),
+    styleTbl: d.handle(),
+    styleStd: d.handle(),
+    viewTbl: d.handle(),
+    ucsTbl: d.handle(),
+    appidTbl: d.handle(),
+    appidAcad: d.handle(),
+    dimTbl: d.handle(),
+    dimStd: d.handle(),
+    brTbl: d.handle(),
+    brModel: d.handle(),
+    brPaper: d.handle(),
+    blkModel: d.handle(),
+    endModel: d.handle(),
+    blkPaper: d.handle(),
+    endPaper: d.handle(),
+    rootDict: d.handle(),
+    groupDict: d.handle(),
+    plotDict: d.handle(),
+    plotPlaceholder: d.handle()
+  };
+  const layerHandles = /* @__PURE__ */ new Map();
+  for (const name of layers.keys()) layerHandles.set(name, d.handle());
+  const entHandles = ents.map(() => d.handle());
+  d.add(999, `${DXF_STAMP} \u2014 sheet ${sheet.label || sheet.sheet_id} \u2014 units ${units === "m" ? "metres" : "feet"} \u2014 origin bottom-left of sheet, Y up`);
+  d.add(0, "SECTION");
+  d.add(2, "HEADER");
+  d.add(9, "$ACADVER");
+  d.add(1, "AC1015");
+  d.add(9, "$HANDSEED");
+  d.add(5, d.peek());
+  d.add(9, "$INSUNITS");
+  d.add(70, units === "m" ? 6 : 2);
+  d.add(9, "$MEASUREMENT");
+  d.add(70, units === "m" ? 1 : 0);
+  d.add(9, "$LUNITS");
+  d.add(70, units === "m" ? 2 : 4);
+  d.add(9, "$EXTMIN");
+  d.add(10, fmt(hasExt ? ext.minX : 0));
+  d.add(20, fmt(hasExt ? ext.minY : 0));
+  d.add(30, 0);
+  d.add(9, "$EXTMAX");
+  d.add(10, fmt(hasExt ? ext.maxX : w * upp * k));
+  d.add(20, fmt(hasExt ? ext.maxY : h * upp * k));
+  d.add(30, 0);
+  d.add(9, "$LIMMIN");
+  d.add(10, 0);
+  d.add(20, 0);
+  d.add(9, "$LIMMAX");
+  d.add(10, fmt(w * upp * k));
+  d.add(20, fmt(h * upp * k));
+  d.add(9, "$CLAYER");
+  d.add(8, "0");
+  d.add(9, "$PDMODE");
+  d.add(70, 0);
+  d.add(0, "ENDSEC");
+  d.add(0, "SECTION");
+  d.add(2, "CLASSES");
+  d.add(0, "ENDSEC");
+  d.add(0, "SECTION");
+  d.add(2, "TABLES");
+  const table = (name, handle, count) => {
+    d.add(0, "TABLE");
+    d.add(2, name);
+    d.add(5, handle);
+    d.add(330, "0");
+    d.add(100, "AcDbSymbolTable");
+    d.add(70, count);
+  };
+  const record = (type, handle, owner, sub) => {
+    d.add(0, type);
+    d.add(5, handle);
+    d.add(330, owner);
+    d.add(100, "AcDbSymbolTableRecord");
+    d.add(100, sub);
+  };
+  const endtab = () => d.add(0, "ENDTAB");
+  table("VPORT", H.vportTbl, 1);
+  record("VPORT", H.vportActive, H.vportTbl, "AcDbViewportTableRecord");
+  d.add(2, "*Active");
+  d.add(70, 0);
+  d.add(10, 0);
+  d.add(20, 0);
+  d.add(11, 1);
+  d.add(21, 1);
+  const cx = hasExt ? (ext.minX + ext.maxX) / 2 : w * upp * k / 2;
+  const cy = hasExt ? (ext.minY + ext.maxY) / 2 : h * upp * k / 2;
+  const vh = hasExt ? Math.max(ext.maxY - ext.minY, (ext.maxX - ext.minX) / 1.6, 1) * 1.1 : h * upp * k;
+  d.add(12, fmt(cx));
+  d.add(22, fmt(cy));
+  d.add(13, 0);
+  d.add(23, 0);
+  d.add(14, 10);
+  d.add(24, 10);
+  d.add(15, 10);
+  d.add(25, 10);
+  d.add(16, 0);
+  d.add(26, 0);
+  d.add(36, 1);
+  d.add(17, 0);
+  d.add(27, 0);
+  d.add(37, 0);
+  d.add(40, fmt(vh));
+  d.add(41, 1.6);
+  d.add(42, 50);
+  d.add(43, 0);
+  d.add(44, 0);
+  d.add(50, 0);
+  d.add(51, 0);
+  d.add(71, 0);
+  d.add(72, 100);
+  d.add(73, 1);
+  d.add(74, 3);
+  d.add(75, 0);
+  d.add(76, 0);
+  d.add(77, 0);
+  d.add(78, 0);
+  endtab();
+  table("LTYPE", H.ltypeTbl, 3);
+  for (const [hd, name, desc] of [[H.ltByBlock, "ByBlock", ""], [H.ltByLayer, "ByLayer", ""], [H.ltCont, "Continuous", "Solid line"]]) {
+    record("LTYPE", hd, H.ltypeTbl, "AcDbLinetypeTableRecord");
+    d.add(2, name);
+    d.add(70, 0);
+    d.add(3, desc);
+    d.add(72, 65);
+    d.add(73, 0);
+    d.add(40, 0);
+  }
+  endtab();
+  table("LAYER", H.layerTbl, layers.size + 1);
+  const layerRec = (hd, name, color) => {
+    record("LAYER", hd, H.layerTbl, "AcDbLayerTableRecord");
+    d.add(2, name);
+    d.add(70, 0);
+    d.add(62, color);
+    d.add(6, "Continuous");
+    d.add(370, -3);
+    d.add(390, H.plotPlaceholder);
+  };
+  layerRec(H.layer0, "0", 7);
+  for (const [name, color] of layers) layerRec(layerHandles.get(name), name, color);
+  endtab();
+  table("STYLE", H.styleTbl, 1);
+  record("STYLE", H.styleStd, H.styleTbl, "AcDbTextStyleTableRecord");
+  d.add(2, "Standard");
+  d.add(70, 0);
+  d.add(40, 0);
+  d.add(41, 1);
+  d.add(50, 0);
+  d.add(71, 0);
+  d.add(42, 0.2);
+  d.add(3, "txt");
+  d.add(4, "");
+  endtab();
+  table("VIEW", H.viewTbl, 0);
+  endtab();
+  table("UCS", H.ucsTbl, 0);
+  endtab();
+  table("APPID", H.appidTbl, 1);
+  record("APPID", H.appidAcad, H.appidTbl, "AcDbRegAppTableRecord");
+  d.add(2, "ACAD");
+  d.add(70, 0);
+  endtab();
+  d.add(0, "TABLE");
+  d.add(2, "DIMSTYLE");
+  d.add(5, H.dimTbl);
+  d.add(330, "0");
+  d.add(100, "AcDbSymbolTable");
+  d.add(70, 1);
+  d.add(100, "AcDbDimStyleTable");
+  d.add(0, "DIMSTYLE");
+  d.add(105, H.dimStd);
+  d.add(330, H.dimTbl);
+  d.add(100, "AcDbSymbolTableRecord");
+  d.add(100, "AcDbDimStyleTableRecord");
+  d.add(2, "Standard");
+  d.add(70, 0);
+  d.add(340, H.styleStd);
+  endtab();
+  table("BLOCK_RECORD", H.brTbl, 2);
+  for (const [hd, name] of [[H.brModel, "*Model_Space"], [H.brPaper, "*Paper_Space"]]) {
+    record("BLOCK_RECORD", hd, H.brTbl, "AcDbBlockTableRecord");
+    d.add(2, name);
+    d.add(340, "0");
+  }
+  endtab();
+  d.add(0, "ENDSEC");
+  d.add(0, "SECTION");
+  d.add(2, "BLOCKS");
+  const block = (name, br, begin, end, paper) => {
+    d.add(0, "BLOCK");
+    d.add(5, begin);
+    d.add(330, br);
+    d.add(100, "AcDbEntity");
+    if (paper) d.add(67, 1);
+    d.add(8, "0");
+    d.add(100, "AcDbBlockBegin");
+    d.add(2, name);
+    d.add(70, 0);
+    d.add(10, 0);
+    d.add(20, 0);
+    d.add(30, 0);
+    d.add(3, name);
+    d.add(1, "");
+    d.add(0, "ENDBLK");
+    d.add(5, end);
+    d.add(330, br);
+    d.add(100, "AcDbEntity");
+    if (paper) d.add(67, 1);
+    d.add(8, "0");
+    d.add(100, "AcDbBlockEnd");
+  };
+  block("*Model_Space", H.brModel, H.blkModel, H.endModel, false);
+  block("*Paper_Space", H.brPaper, H.blkPaper, H.endPaper, true);
+  d.add(0, "ENDSEC");
+  d.add(0, "SECTION");
+  d.add(2, "ENTITIES");
+  ents.forEach((e, i) => {
+    const hd = entHandles[i];
+    if (e.kind === "lwpoly") {
+      d.add(0, "LWPOLYLINE");
+      d.add(5, hd);
+      d.add(330, H.brModel);
+      d.add(100, "AcDbEntity");
+      d.add(8, e.layer);
+      d.add(100, "AcDbPolyline");
+      d.add(90, e.pts.length);
+      d.add(70, e.closed ? 1 : 0);
+      d.add(43, 0);
+      for (const [x, y] of e.pts) {
+        d.add(10, fmt(x));
+        d.add(20, fmt(y));
+      }
+    } else if (e.kind === "circle") {
+      d.add(0, "CIRCLE");
+      d.add(5, hd);
+      d.add(330, H.brModel);
+      d.add(100, "AcDbEntity");
+      d.add(8, e.layer);
+      d.add(100, "AcDbCircle");
+      d.add(10, fmt(e.c[0]));
+      d.add(20, fmt(e.c[1]));
+      d.add(30, 0);
+      d.add(40, fmt(e.r));
+    } else {
+      d.add(0, "TEXT");
+      d.add(5, hd);
+      d.add(330, H.brModel);
+      d.add(100, "AcDbEntity");
+      d.add(8, e.layer);
+      d.add(100, "AcDbText");
+      d.add(10, fmt(e.at[0]));
+      d.add(20, fmt(e.at[1]));
+      d.add(30, 0);
+      d.add(40, fmt(e.height));
+      d.add(1, e.text.replace(/[\r\n]+/g, " "));
+      d.add(72, 1);
+      d.add(11, fmt(e.at[0]));
+      d.add(21, fmt(e.at[1]));
+      d.add(31, 0);
+      d.add(100, "AcDbText");
+      d.add(73, 2);
+    }
+  });
+  d.add(0, "ENDSEC");
+  d.add(0, "SECTION");
+  d.add(2, "OBJECTS");
+  d.add(0, "DICTIONARY");
+  d.add(5, H.rootDict);
+  d.add(330, "0");
+  d.add(100, "AcDbDictionary");
+  d.add(281, 1);
+  d.add(3, "ACAD_GROUP");
+  d.add(350, H.groupDict);
+  d.add(3, "ACAD_PLOTSTYLENAME");
+  d.add(350, H.plotDict);
+  d.add(0, "DICTIONARY");
+  d.add(5, H.groupDict);
+  d.add(330, H.rootDict);
+  d.add(100, "AcDbDictionary");
+  d.add(281, 1);
+  d.add(0, "ACDBDICTIONARYWDFLT");
+  d.add(5, H.plotDict);
+  d.add(330, H.rootDict);
+  d.add(100, "AcDbDictionary");
+  d.add(281, 1);
+  d.add(3, "Normal");
+  d.add(350, H.plotPlaceholder);
+  d.add(100, "AcDbDictionaryWithDefault");
+  d.add(340, H.plotPlaceholder);
+  d.add(0, "ACDBPLACEHOLDER");
+  d.add(5, H.plotPlaceholder);
+  d.add(330, H.plotDict);
+  d.add(0, "ENDSEC");
+  d.add(0, "EOF");
+  return { dxf: d.text(), layers: [...layers.keys()], entities: ents.length, shapes: shapesOut, skipped, extents };
+}
+
 // ../web/src/lib/confidence.ts
 var CONF_RASTER = 0.9;
 var CONF_HATCH = 0.95;
@@ -8844,6 +9733,37 @@ var Session = class _Session {
   }
   /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
    * store.saveAnnotations stamps) — importable by the app. */
+  /** The takeoff on ONE sheet as a DXF drawing (R2000, LWPOLYLINE per shape,
+   * OT-<TAG> layer per finish, feet by default) — the CAD-native handoff.
+   * `sheet` omitted resolves only when exactly one calibrated sheet carries
+   * shapes; otherwise the refusal names the candidates, because two floors in
+   * one model space at the same origin would be a lie. A sheet without a
+   * scale refuses too (a CAD file in pixels is worse than none). */
+  exportDxf(sheetName, units = "ft") {
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    let s;
+    if (sheetName != null && sheetName !== "") {
+      s = this.sheet(sheetName);
+    } else {
+      const withShapes = new Set(this.shapes.map((x) => x.sheet_id));
+      const cands = [...this.sheets.values()].filter((x) => withShapes.has(x.key));
+      if (cands.length === 0) throw new UserError("No sheet carries committed shapes yet \u2014 measure something before exporting to CAD.");
+      if (cands.length > 1) {
+        throw new UserError(`Several sheets carry shapes \u2014 pass sheet to pick one drawing (a DXF is one sheet, like a DWG is): ${cands.map((x) => `"${x.key}"${x.sheetNumber ? ` (${x.sheetNumber})` : ""}`).join(", ")}.`);
+      }
+      s = cands[0];
+    }
+    if (s.upp == null) throw new UserError(`Sheet "${s.key}" has no scale \u2014 call set_scale first; a CAD file in pixels is worse than none.`);
+    const build = buildSheetDxf({
+      sheet_id: s.key,
+      label: s.sheetNumber || s.key,
+      dims: { w: s.widthPx, h: s.heightPx },
+      upp: s.upp,
+      shapes: this.shapes,
+      conditions: this.conditions
+    }, { units });
+    return { sheet: s, build };
+  }
   exportPayload() {
     if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     return {
@@ -9363,6 +10283,18 @@ var takeoffSummaryOutput = {
   }).passthrough(),
   scale_unconfirmed: z.array(z.string()).optional().describe("Sheets whose scale is agent-set and no human has confirmed \u2014 these totals stand on an unverified scale; verify against a stated dimension or confirm in the canvas")
 };
+var exportDxfOutput = {
+  path: z.string().describe("The DXF written"),
+  sheet: z.string().describe("Sheet key the drawing was cut from"),
+  sheet_number: z.string().nullable(),
+  units: z.enum(["ft", "m"]),
+  layers: z.array(z.string()).describe("Layer names in table order \u2014 OT-<TAG>, plus -DEDUCT/-HOLE/-WALL/-LINEAR/-COUNT suffix layers and OT-LABELS"),
+  entities: z.number().int().describe("LWPOLYLINE + CIRCLE + TEXT entities in model space"),
+  shapes: z.number().int().describe("Committed shapes that produced geometry"),
+  skipped: z.array(z.object({ id: z.string(), reason: z.string() })).describe("Shapes on this sheet left out, each with why \u2014 never silent"),
+  extents: z.object({ min: z.tuple([z.number(), z.number()]), max: z.tuple([z.number(), z.number()]) }).nullable().describe("Model-space bounding box in output units; origin = sheet's bottom-left, Y up"),
+  bytes: z.number().int()
+};
 var exportTakeoffOutput = {
   schema: z.string(),
   project_name: z.string(),
@@ -10174,7 +11106,7 @@ function normalize(d) {
   }
   return out;
 }
-function fmt(n) {
+function fmt2(n) {
   let r = Math.round(n * 1e4) / 1e4;
   if (Object.is(r, -0)) r = 0;
   return String(r);
@@ -10202,7 +11134,7 @@ function transformPath(d, fn) {
     }
     if (bad) continue;
     let s = seg.t;
-    for (let k = 0; k < dst.length; k++) s += " " + fmt(dst[k]);
+    for (let k = 0; k < dst.length; k++) s += " " + fmt2(dst[k]);
     parts.push(s);
   }
   return parts.join(" ");
@@ -10464,6 +11396,16 @@ function boostForDark(hex2) {
 }
 
 // ../web/src/lib/markedset.js
+function authorTallyLine(shapes) {
+  const byAuthor = /* @__PURE__ */ new Map();
+  for (const s of shapes || []) {
+    const a = typeof s.author === "string" && s.author.trim() ? s.author.trim() : "";
+    byAuthor.set(a, (byAuthor.get(a) || 0) + 1);
+  }
+  if (![...byAuthor.keys()].some(Boolean)) return null;
+  const parts = [...byAuthor.entries()].sort((a, b) => a[0] === "" ? 1 : b[0] === "" ? -1 : a[0].localeCompare(b[0])).map(([a, n]) => `${a || "unattributed"} (${n})`);
+  return `Marks by: ${parts.join(" \xB7 ")}`;
+}
 var COBALT = "#1f3fc7";
 var DEDUCT_RED = "#b03a26";
 var DARK_BG = [0.055, 0.07, 0.09];
@@ -10741,6 +11683,11 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, a
       metaY -= 12;
       draw(`Approval stamps: ${apCount.estimator} estimator-approved \xB7 ${apCount.agent} agent-marked`, { x: 52, y: metaY, size: 9.5, font, color: muted });
     }
+    const authorsLine = authorTallyLine(markedShapes);
+    if (authorsLine) {
+      metaY -= 12;
+      draw(authorsLine, { 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 });
@@ -11179,6 +12126,9 @@ async function isOwnExport(outPath, kind) {
     if (kind === "json") {
       return /"schema"\s*:\s*"opentakeoff\./.test((await head(outPath, 4096)).toString("utf8"));
     }
+    if (kind === "dxf") {
+      return /^999\r?\nOpenTakeoff DXF export/.test((await head(outPath, 64)).toString("utf8"));
+    }
     if ((await head(outPath, 5)).toString("latin1") !== "%PDF-") return false;
     const { readFile: readFile4 } = await import("node:fs/promises");
     const { PDFDocument } = await import("pdf-lib");
@@ -11735,6 +12685,33 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     }
     return payload;
   }));
+  server.registerTool("export_dxf", {
+    description: `The takeoff as a CAD drawing \u2014 a DXF (R2000) AutoCAD, BricsCAD, LibreCAD and Revit import as native geometry, not a picture. ONE sheet per file, like a DWG: every committed shape on that sheet becomes an LWPOLYLINE (floor rings CLOSED, walls and linear runs open, count marks a 1-ft circle), on a layer named for its finish \u2014 OT-<TAG>, with -DEDUCT / -HOLE / -WALL / -LINEAR / -COUNT suffix layers so a CAD user isolates any bucket with one layer filter, and room labels as TEXT on OT-LABELS. Coordinates are real units in the sheet's own frame: origin at the sheet's BOTTOM-left, Y up (CAD convention), feet by default ($INSUNITS 2) or metres with units:"m"; a ring's area in CAD equals its area in export_report to rounding, so the drawing IS the audit. Requires the sheet's scale (refuses otherwise \u2014 pixels in a DXF are worse than nothing); with several sheets carrying shapes, pass sheet to choose the drawing (the refusal lists them). The reply names every shape left out and why \u2014 a reconciled deduct ships as its parent's -HOLE ring, never twice. Writes to path (required \u2014 a DXF lives on disk, next to the DWG it aligns to); pair with export_marked_pdf for the reviewed planset.`,
+    inputSchema: {
+      path: z2.string().describe("File path to write the .dxf to"),
+      sheet: z2.string().optional().describe('Sheet key ("plan.pdf", "plan.pdf#2") or title-block number ("A-101"). Optional only when exactly one calibrated sheet carries shapes'),
+      units: z2.enum(["ft", "m"]).optional().describe('Output units \u2014 "ft" (default) or "m"'),
+      overwrite: z2.boolean().optional().describe(OVERWRITE_DESC)
+    },
+    outputSchema: exportDxfOutput
+  }, run("export_dxf", async ({ path: outPath, sheet, units, overwrite }) => {
+    const { sheet: s, build } = session.exportDxf(sheet, units ?? "ft");
+    await assertWritable(outPath, "dxf", overwrite);
+    const { writeFile: writeFile2 } = await import("node:fs/promises");
+    await writeFile2(outPath, build.dxf, "utf8");
+    return {
+      path: outPath,
+      sheet: s.key,
+      sheet_number: s.sheetNumber ?? null,
+      units: units ?? "ft",
+      layers: build.layers,
+      entities: build.entities,
+      shapes: build.shapes,
+      skipped: build.skipped,
+      extents: build.extents,
+      bytes: Buffer.byteLength(build.dxf, "utf8")
+    };
+  }));
   server.registerTool("export_report", {
     description: `The computed Report document \u2014 "opentakeoff.report.v1", the same schema the canvas Report's JSON export writes. Everything a pricing consumer needs without re-implementing the app's math: per-condition quantities with waste and multiplier applied (gross and *_net), the computed materials BUY LIST per condition (order quantity = basis \xF7 coverage rate, rounded up to whole purchase units) plus the project-wide roll-up summed by (name, unit), per-sheet BASE subtotals, scale provenance per sheet, and annotations. Contrast: export_takeoff is the raw canvas payload (materials as CONFIG rows, no computed quantities) and takeoff_summary strips materials for a compact reply \u2014 when the numbers are leaving for pricing, consume this. A report alone is HALF the deliverable: pair it with export_marked_pdf, because a takeoff is reviewed on marked drawings, not on numbers. Returned inline; pass path to also write it to disk as JSON.`,
     inputSchema: {
@@ -12122,9 +13099,13 @@ var TOOL_STAGES = {
     "export_report",
     "import_takeoff",
     "apply_rules",
-    "export_marked_pdf"
+    "export_marked_pdf",
+    "export_dxf"
   ]
 };
+var TOOL_NAMES = Object.freeze(
+  Object.values(TOOL_STAGES).flat().sort()
+);
 var OPENABLE = ["measure", "revise", "handoff"];
 var openToolStageOutput = {
   stage: z3.string().describe("The stage that was opened"),
@@ -12211,7 +13192,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.63",
+  version: "0.9.65",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -12227,7 +13208,8 @@ 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/labels.test.ts test/overlap.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/staging.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
+    "check:tool-count": "node scripts/check-tool-count.mjs",
+    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/dxf.test.ts test/e2e.test.ts test/labels.test.ts test/overlap.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/staging.test.ts test/tools.test.ts test/transitions.test.ts test/twins.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.63",
+  "version": "0.9.65",
   "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,8 @@
     "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/labels.test.ts test/overlap.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/staging.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
+    "check:tool-count": "node scripts/check-tool-count.mjs",
+    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/dxf.test.ts test/e2e.test.ts test/labels.test.ts test/overlap.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/staging.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",