opentakeoff-mcp 0.9.93 → 0.9.96

package/dist/server-core.js

@@ -3466,6 +3466,32 @@ function finishSectionOf(text) {
   return WORDS.has(clean[0]) ? clean[0] : null;
 }
 
+// ../web/src/lib/notUsed.ts
+function normalizeTail(text) {
+  let t = text.toUpperCase().trim().replace(/^[-–—:,\s]+/, "");
+  t = t.replace(/\.$/, "");
+  if (t.startsWith("(") && closingParen(t) === t.length - 1) t = t.slice(1, -1);
+  t = t.replace(/\.$/, "");
+  t = t.replace(/\bN\.?\s*I\.?\s*C\b\.?/g, "NIC");
+  return t.replace(/\s+/g, " ").trim();
+}
+function closingParen(t) {
+  let depth = 0;
+  for (let i = 0; i < t.length; i++) {
+    if (t[i] === "(") depth++;
+    else if (t[i] === ")" && --depth === 0) return i;
+  }
+  return -1;
+}
+function normalizeNotUsed(text) {
+  const t = normalizeTail(text);
+  return t === "NOT USED" || t === "NOT IN CONTRACT" || t === "NIC" ? t : null;
+}
+
+// ../web/src/lib/finishCode.ts
+var CODE_RE = /^[A-Z]{1,4}(-?[A-Z0-9]{1,4})?$/;
+var finishCodeOk = (p) => !/^[A-Z]{4,}$/.test(p) && CODE_RE.test(p);
+
 // ../web/src/lib/sheetgraph.ts
 var bboxOf = (s) => [s.x, s.y, s.x + (s.w || 0), s.y + (s.h || 0)];
 var merge = (a, b) => [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.max(a[2], b[2]), Math.max(a[3], b[3])];
@@ -3624,6 +3650,7 @@ var rowY = (r) => r.reduce((s, t) => s + t.y, 0) / r.length;
 var SURFACE_WORDS = /* @__PURE__ */ new Set(["FLOOR", "BASE", "WALL", "WALLS", "CEILING", "NORTH", "SOUTH", "EAST", "WEST", "WAINSCOT"]);
 var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "MARK", "LOCATION", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT", "HEIGHT", "FINISH", "MAT", "MATERIAL", "COMMENTS", "CASEWORK", "CABINET", "COUNTER", "COUNTERTOP", "BLDG", "BUILDING"];
 var FINISH_HEADERS = ["CODE", "MARK", "SYMBOL", "TAG", "MATERIAL", "MANUFACTURER", "PRODUCT", "STYLE", "COLOR", "SIZE", "REMARKS", "DESCRIPTION", "PATTERN", "COMMENTS"];
+var FOREIGN_HDR = /* @__PURE__ */ new Set(["QTY", "QUANTITY", "MESSAGE", "WIDTH", "HEIGHT", "HARDWARE", "CFM", "VOLTS", "VOLTAGE", "WATTS", "LAMP", "LAMPS", "CATALOG", "FIXTURE", "FRAME", "GLAZING", "THICKNESS", "RATING", "LOUVER"]);
 var EQUIPMENT_HEADERS = [
   // identity + the shared columns
   "ID",
@@ -3995,8 +4022,6 @@ function bandLimits(anchors) {
   const rightMargin = WIDE_LAST.has(last.label) ? Math.max(300, medGap * 3) : Math.max(120, medGap);
   return { x0: anchors[0].x - Math.max(80, medGap / 2), x1: last.x + rightMargin, medGap };
 }
-var CODE_RE = /^[A-Z]{1,4}(-?[A-Z0-9]{1,4})?$/;
-var finishCodeOk = (p) => !/^[A-Z]{4,}$/.test(p) && CODE_RE.test(p);
 var ROW_KEY_RE = /^\d{1,3}[A-Z]{0,2}$/;
 var QUALIFIED_KEY_RE = /^([A-Z]{1,2})-(\d{1,3}[A-Z]{0,2})$/;
 var CORRIDOR_KEY_RE = /^[A-Z]{1,3}(?:\d{1,3}-\d{1,3}|\d{3})[A-Z]?$/;
@@ -4025,6 +4050,24 @@ function rowKeyOf(raw, kind, buildings, typeKeyed = false) {
   if (q && buildings?.has(q[1])) return { key, building: q[1] };
   return null;
 }
+var SPLIT_DENY = /* @__PURE__ */ new Set(["SEE", "NOTE", "NOTES", "NOT", "USED", "BY", "OWNER", "NIC", "TBD", "ALL", "THRU", "TO", "AND", "OR"]);
+var ALT_WORDS = /* @__PURE__ */ new Set(["ALT", "OPT", "OPTION", "ADD", "DEDUCT"]);
+function splitKeyCell(raw) {
+  const r = raw.trim();
+  const sp = r.search(/\s/);
+  const w1 = (sp < 0 ? r : r.slice(0, sp)).toUpperCase().replace(/[:,;]+$/, "");
+  if (!finishCodeOk(w1) || !/\d/.test(w1)) return null;
+  const after = sp < 0 ? "" : r.slice(sp).replace(/^[-–—:,\s]+/, "");
+  const tail = normalizeTail(after);
+  if (tail === "NOT USED" || tail === "NOT IN CONTRACT" || tail === "NIC") return { key: w1, notUsed: true, notUsedText: after };
+  const words = tail ? tail.split(" ") : [];
+  if (words.length < 1 || words.length > 2) return null;
+  if (!words.every((w) => /^[A-Z]{2,8}$/.test(w) || /^\([A-Z]{1,8}\)$/.test(w))) return null;
+  const bare = words.map((w) => w.replace(/[()]/g, ""));
+  if (bare.some((w) => SPLIT_DENY.has(w)) || bare.join("").length < 3) return null;
+  return { key: w1, qualifier: after };
+}
+var isAltQualifier = (q) => ALT_WORDS.has(q.toUpperCase().replace(/[()]/g, "").trim());
 var rowKeyAnswersFor = (key, want) => {
   const c = norm(key).replace(/\s+/g, "");
   const w = norm(want).replace(/\s+/g, "");
@@ -4195,6 +4238,58 @@ function columnStarts(rows, anchors, cfg, x0, x1, kind) {
   if (!center) return left;
   return center.score > left.score + 0.05 ? center : left;
 }
+var KEY_FIRST = /* @__PURE__ */ new Set(["CODE", "MARK", "SYMBOL", "TAG"]);
+var LETTERS_RE = /^[A-Z]{4,5}$/;
+var OTHER_FAMILY_WORDS = ["DOOR", "WINDOW", "PARTITION", "EQUIPMENT", "HARDWARE", "LOUVER", "SIGNAGE", "LIGHTING", "LUMINAIRE", "PLUMBING", "MECHANICAL", "ELECTRICAL", "STOREFRONT", "GLAZING", "CASEWORK", "MILLWORK", "APPLIANCE"];
+var LETTERS_STOP = /* @__PURE__ */ new Set([
+  ...FINISH_HEADERS,
+  ...EQUIPMENT_HEADERS,
+  ...ROOM_HEADERS,
+  ...FINISH_SECTION_HEADINGS.filter((h) => !h.includes(" ")),
+  ...OTHER_FAMILY_WORDS.flatMap((w) => [w, w + "S"]),
+  "LEGEND",
+  "NOTE",
+  "NOTES",
+  "TYPE",
+  "ITEM",
+  "ROOM",
+  "LEVEL",
+  "AREA",
+  "FIELD",
+  "WHERE",
+  "PATCH",
+  "MATCH",
+  "REFER",
+  "STAIR",
+  "ABOVE",
+  "APPLY",
+  "CAULK",
+  "COVE",
+  "COVED",
+  "MFG",
+  "MFR",
+  "SPEC",
+  "PAINT",
+  "TILE",
+  "STONE",
+  "VINYL",
+  "WOOD",
+  "GLASS",
+  "METAL",
+  "EPOXY",
+  "STAIN",
+  "GROUT",
+  // sheens and formats: a key-column wrap under a code (PT-1 / SATIN)
+  "SATIN",
+  "GLOSS",
+  "MATTE",
+  "FLAT",
+  "HONED",
+  "PLANK"
+]);
+var HEADER_WORDS_STRONG = /* @__PURE__ */ new Set([...FINISH_HEADERS, ...EQUIPMENT_HEADERS, ...FOREIGN_HDR, "MFG", "MFR", "SPEC", "SPECIFICATION", "NOTES"]);
+var HEADER_WORDS = /* @__PURE__ */ new Set([...HEADER_WORDS_STRONG, ...ROOM_HEADERS]);
+var SPEC_SECTION_RE = /^\d{2} ?\d{2}[ .]?\d{2}\b/;
 function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
   const { x0, x1, medGap } = bandLimits(anchors);
   const typeKeyed = kind === "equipment" && (anchors[0]?.label === "TYPE" || anchors[0]?.label === "FIXTURE");
@@ -4212,13 +4307,12 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
     const a = atOf(t);
     return a >= Math.min(x0, keyLo - colTol) && a < keyHi;
   };
-  let tLeft = 0, tRight = 0, medPitch = 0;
-  let prevBandY = null;
+  let tLeft = 0, tRight = 0, medPitch = 0, medPitchLo = 0;
   if (finish) {
     let ys = rows.slice(Math.max(cfg.fromIdx, 0)).filter((r) => r.some(inBand)).map(rowY);
     const med = (v) => {
-      const d = v.slice(1).map((y, k) => y - v[k]).sort((p, q) => p - q);
-      return d.length ? d[d.length >> 1] : 0;
+      const d2 = v.slice(1).map((y, k) => y - v[k]).sort((p, q) => p - q);
+      return d2.length ? d2[d2.length >> 1] : 0;
     };
     const p0 = med(ys);
     const cut = p0 > 0 ? ys.findIndex((y, k) => k > 0 && y - ys[k - 1] > 8 * p0) : -1;
@@ -4226,9 +4320,9 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
     const lastTableY = ys.length ? ys[ys.length - 1] : Infinity;
     if (cols) {
       const cs = cols.cols;
-      const pitch2 = cs.length > 1 ? cs.slice(1).map((c, k) => c.start - cs[k].start).sort((p, q) => p - q)[cs.length - 1 >> 1] : medGap;
+      const pitch = cs.length > 1 ? cs.slice(1).map((c, k) => c.start - cs[k].start).sort((p, q) => p - q)[cs.length - 1 >> 1] : medGap;
       tLeft = cs[0].start;
-      tRight = cs[cs.length - 1].start + pitch2;
+      tRight = cs[cs.length - 1].start + pitch;
     } else {
       tLeft = Infinity;
       tRight = -Infinity;
@@ -4239,19 +4333,10 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
       }
     }
     medPitch = med(ys);
+    const d = ys.slice(1).map((y, k) => y - ys[k]).filter((g) => g > 0).sort((p, q) => p - q);
+    medPitchLo = d.length ? d[d.length - 1 >> 1] : 0;
   }
-  const headings = [];
-  const headLines = [];
-  const consumeHeading = (banded, y) => {
-    let hb = null;
-    for (const t of banded) hb = hb ? merge(hb, bboxOf(t)) : bboxOf(t);
-    headings.push({ bbox: hb, y });
-  };
   const keyTol = cols && cols.cols.length > 1 ? Math.max(8, (cols.cols[1].start - cols.cols[0].start) * 0.5) : 40;
-  const out = [];
-  const outY = [];
-  const everRows = [];
-  let region = null;
   const columnOf = (t) => {
     if (!cols) return nearestAnchor(centerX(t), anchors);
     const at = cols.coord === "left" ? t.x : centerX(t);
@@ -4281,147 +4366,549 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
       const text = t.str.trim();
       if (!row.cells[label]) row.cells[label] = { text, bbox: bboxOf(t) };
       else row.cells[label] = { text: `${row.cells[label].text} ${text}`, bbox: merge(row.cells[label].bbox, bboxOf(t)) };
-      region = region ? merge(region, bboxOf(t)) : bboxOf(t);
     }
   };
-  const orphans = [];
-  const markers = [];
-  for (let i = Math.max(cfg.fromIdx, 0); i < rows.length; i++) {
-    if (rowY(rows[i]) <= cfg.belowY) continue;
-    const banded = [];
-    for (const t of rows[i]) {
-      const tri = cfg.deltas?.get(t);
-      const rev = tri ? norm(t.str) : revisionOf(t.str);
-      if (rev != null) {
-        if (centerX(t) >= x0 - 2.5 * medGap && centerX(t) <= x1 + medGap) markers.push({ rev, span: t, ...tri ? { drawn: true, tri } : {} });
-        continue;
+  const scan = (over2, gone, breaks) => {
+    const S = { out: [], outY: [], outI: [], outToks: [], everRows: [], everI: [], orphans: [], markers: [], headings: [], headLines: [], lines: [], outEpoch: [], outLine: [] };
+    let curSection2;
+    let prevBandY = null;
+    const consumeHeading = (banded, y, section) => {
+      let hb = null;
+      for (const t of banded) hb = hb ? merge(hb, bboxOf(t)) : bboxOf(t);
+      S.headings.push({ bbox: hb, y, section });
+    };
+    const keyOf = (raw, i) => over2?.get(i) ?? rowKeyOf(raw, kind, buildings, typeKeyed);
+    let epoch = 0, line = -1;
+    for (let i = Math.max(cfg.fromIdx, 0); i < rows.length; i++) {
+      if (rowY(rows[i]) <= cfg.belowY) continue;
+      const banded = [];
+      for (const t of rows[i]) {
+        const tri = cfg.deltas?.get(t);
+        const rev = tri ? norm(t.str) : revisionOf(t.str);
+        if (rev != null) {
+          if (centerX(t) >= x0 - 2.5 * medGap && centerX(t) <= x1 + medGap) S.markers.push({ rev, span: t, i, ...tri ? { drawn: true, tri } : {} });
+          continue;
+        }
+        if (inBand(t)) banded.push(t);
+      }
+      if (!banded.length) continue;
+      line++;
+      const bandYBefore = prevBandY;
+      prevBandY = rowY(rows[i]);
+      S.lines.push({ i, y: rowY(rows[i]), toks: banded });
+      if (finish) {
+        const h = finishSectionOf(banded[0].str);
+        const joinedLen = banded.map((t) => t.str.trim()).join(" ").length;
+        const inKeyColumn = inKey(banded[0]) && banded.every((t) => t.x + (t.w || 0) <= keyHi);
+        const one = banded.length === 1 ? banded[0] : null;
+        const straddles = !!one && !!cols && cols.cols.slice(1).some((c) => one.x < c.start - colTol && one.x + (one.w || 0) > c.start + colTol);
+        const hugs = bandYBefore != null && rowY(rows[i]) - bandYBefore < 0.6 * medPitch;
+        const tMid = (tLeft + tRight) / 2;
+        const centered = !!one && !hugs && (Math.abs(centerX(one) - tMid) <= Math.max(0.1 * (tRight - tLeft), 3 * (one.h || 8)) || straddles);
+        if (h && (inKeyColumn || centered) && joinedLen < 24) {
+          curSection2 = h;
+          epoch++;
+          consumeHeading(banded, rowY(rows[i]), h);
+          continue;
+        }
+        if (h && !hugs) S.headLines.push(rowY(rows[i]));
+        if (banded.length <= 2 && inKey(banded[0]) && /^\d{2} ?\d{2} ?\d{2}(\.\d+)?\b/.test(norm(banded[0].str)) && !rowKeyOf(banded[0].str, kind, buildings, typeKeyed)) {
+          curSection2 = void 0;
+          epoch++;
+          consumeHeading(banded, rowY(rows[i]), null);
+          continue;
+        }
+        if (one && inKey(one) && (breaks?.has(i) || !keyOf(one.str, i))) {
+          curSection2 = void 0;
+          epoch++;
+          if (!hugs && joinedLen < 24 && !/\d/.test(one.str)) continue;
+        }
+      }
+      if (kind === "equipment" && S.out.length) {
+        if (rows[i].some((t) => /SCHEDULE/.test(norm(t.str)) && !EQUIP_KEY_RE.test(norm(t.str).replace(/[^A-Z0-9-]/g, "")))) break;
+        const hh = headerHits(rows[i], EQUIPMENT_HEADERS);
+        if (hh.length >= 3 && hh.some((h) => EQUIPMENT_KEY_HEADERS.includes(h.label))) break;
       }
-      if (inBand(t)) banded.push(t);
-    }
-    if (!banded.length) continue;
-    const bandYBefore = prevBandY;
-    prevBandY = rowY(rows[i]);
-    if (finish) {
-      const h = finishSectionOf(banded[0].str);
-      const joinedLen = banded.map((t) => t.str.trim()).join(" ").length;
-      const inKeyColumn = inKey(banded[0]) && banded.every((t) => t.x + (t.w || 0) <= keyHi);
-      const one = banded.length === 1 ? banded[0] : null;
-      const straddles = !!one && !!cols && cols.cols.slice(1).some((c) => one.x < c.start - colTol && one.x + (one.w || 0) > c.start + colTol);
-      const hugs = bandYBefore != null && rowY(rows[i]) - bandYBefore < 0.6 * medPitch;
-      const tMid = (tLeft + tRight) / 2;
-      const centered = !!one && !hugs && (Math.abs(centerX(one) - tMid) <= Math.max(0.1 * (tRight - tLeft), 3 * (one.h || 8)) || straddles);
-      if (h && (inKeyColumn || centered) && joinedLen < 24) {
-        curSection = h;
-        consumeHeading(banded, rowY(rows[i]));
+      const keyed = keyOf(banded[0].str, i);
+      if (!keyed) {
+        if (!gone?.has(i)) S.orphans.push({ toks: banded, y: rowY(rows[i]), i });
         continue;
       }
-      if (h && !hugs) headLines.push(rowY(rows[i]));
-      if (banded.length <= 2 && inKey(banded[0]) && /^\d{2} ?\d{2} ?\d{2}(\.\d+)?\b/.test(norm(banded[0].str)) && !rowKeyOf(banded[0].str, kind, buildings, typeKeyed)) {
-        curSection = void 0;
-        consumeHeading(banded, rowY(rows[i]));
+      if (/\d{3}/.test(keyed.key) && cfg.sheetNumbers?.has(keyed.key.replace(/[^A-Z0-9]/g, ""))) {
+        S.orphans.push({ toks: banded, y: rowY(rows[i]), i });
         continue;
       }
-      if (one && inKey(one) && !rowKeyOf(one.str, kind, buildings, typeKeyed)) {
-        curSection = void 0;
-        if (!hugs && joinedLen < 24 && !/\d/.test(one.str)) continue;
+      if (cols && Math.abs((cols.coord === "left" ? banded[0].x : centerX(banded[0])) - cols.cols[0].start) > keyTol) continue;
+      if (cfg.keyAlign && Math.abs(centerX(banded[0]) - cfg.keyAlign.x) > cfg.keyAlign.tol) continue;
+      const row = { key: keyed.key, sheet: sheetKey, cells: {} };
+      if (keyed.building) row.building = keyed.building;
+      if (curSection2) row.section = curSection2;
+      if (keyed.qualifier) row.qualifier = keyed.qualifier;
+      if (keyed.notUsed) {
+        row.notUsed = true;
+        row.notUsedText = keyed.notUsedText;
       }
-    }
-    if (kind === "equipment" && out.length) {
-      if (rows[i].some((t) => /SCHEDULE/.test(norm(t.str)) && !EQUIP_KEY_RE.test(norm(t.str).replace(/[^A-Z0-9-]/g, "")))) break;
-      const hh = headerHits(rows[i], EQUIPMENT_HEADERS);
-      if (hh.length >= 3 && hh.some((h) => EQUIPMENT_KEY_HEADERS.includes(h.label))) break;
-    }
-    const keyed = rowKeyOf(banded[0].str, kind, buildings, typeKeyed);
-    if (!keyed) {
-      orphans.push({ toks: banded, y: rowY(rows[i]) });
-      continue;
-    }
-    if (/\d{3}/.test(keyed.key) && cfg.sheetNumbers?.has(keyed.key.replace(/[^A-Z0-9]/g, ""))) {
-      orphans.push({ toks: banded, y: rowY(rows[i]) });
-      continue;
-    }
-    if (cols && Math.abs((cols.coord === "left" ? banded[0].x : centerX(banded[0])) - cols.cols[0].start) > keyTol) continue;
-    if (cfg.keyAlign && Math.abs(centerX(banded[0]) - cfg.keyAlign.x) > cfg.keyAlign.tol) continue;
-    const row = { key: keyed.key, sheet: sheetKey, cells: {} };
-    if (keyed.building) row.building = keyed.building;
-    if (curSection) row.section = curSection;
-    add(row, banded);
-    out.push(row);
-    outY.push(rowY(rows[i]));
-    everRows.push(row);
-  }
-  if (out.length > 2 && !(finish && cfg.marquee)) {
-    const d = outY.slice(1).map((y, i) => y - outY[i]).filter((g) => g > 0).sort((a, b) => a - b);
-    const pitch0 = d.length ? d[d.length >> 1] : 0;
-    if (pitch0 > 0) {
-      let end = out.length;
-      for (let i = 1; i < outY.length; i++) if (outY[i] - outY[i - 1] > pitch0 * 8) {
-        end = i;
-        break;
-      }
-      if (end < out.length) {
-        out.length = end;
-        outY.length = end;
+      add(row, banded);
+      S.out.push(row);
+      S.outY.push(rowY(rows[i]));
+      S.outI.push(i);
+      S.outToks.push(banded);
+      S.outEpoch.push(epoch);
+      S.outLine.push(line);
+      S.everRows.push(row);
+      S.everI.push(i);
+    }
+    return S;
+  };
+  const dropRowAt = (S, k) => {
+    S.out.splice(k, 1);
+    S.outY.splice(k, 1);
+    S.outI.splice(k, 1);
+    S.outToks.splice(k, 1);
+  };
+  const blankBandResets = (S) => {
+    if (!finish || !cfg.resetAtBlankBand) return [];
+    const { out, outY, outEpoch, outLine } = S;
+    const clear = /* @__PURE__ */ new Set();
+    const prefixOf = (k) => /^[A-Z]*/.exec(k)[0];
+    const plain = [];
+    for (let i = 1; i < out.length; i++) if (outEpoch[i] === outEpoch[i - 1] && outLine[i] === outLine[i - 1] + 1) plain.push(i);
+    const byEpoch = /* @__PURE__ */ new Map();
+    for (const i of plain) {
+      const g = outY[i] - outY[i - 1];
+      if (g > 0) byEpoch.set(outEpoch[i], [...byEpoch.get(outEpoch[i]) ?? [], g]);
+    }
+    for (const i of plain) {
+      const gaps = (byEpoch.get(outEpoch[i]) ?? []).slice().sort((a, b) => a - b);
+      if (gaps.length < 4) continue;
+      const pitch = gaps[gaps.length - 1 >> 1];
+      if (outY[i] - outY[i - 1] <= 1.6 * pitch || prefixOf(out[i].key) === prefixOf(out[i - 1].key)) continue;
+      for (let j = i; j < out.length && outEpoch[j] === outEpoch[i]; j++) clear.add(out[j]);
+    }
+    return [...clear];
+  };
+  const resetSections = (rs) => {
+    for (const r of rs) delete r.section;
+  };
+  const endCut = (S) => {
+    if (S.out.length > 2 && !(finish && cfg.marquee)) {
+      const d = S.outY.slice(1).map((y, i) => y - S.outY[i]).filter((g) => g > 0).sort((a, b) => a - b);
+      const pitch0 = d.length ? d[d.length >> 1] : 0;
+      if (pitch0 > 0) {
+        let end = S.out.length;
+        for (let i = 1; i < S.outY.length; i++) if (S.outY[i] - S.outY[i - 1] > pitch0 * 8) {
+          end = i;
+          break;
+        }
+        if (end < S.out.length) {
+          S.out.length = end;
+          S.outY.length = end;
+          S.outI.length = end;
+          S.outToks.length = end;
+        }
       }
     }
-  }
-  const headY = [...headings.map((h) => h.y), ...headLines];
-  const ly2 = outY.length > 1 ? [...outY, ...headY].filter((y) => y <= outY[outY.length - 1]).sort((a, b) => a - b) : [];
-  const gaps = ly2.slice(1).map((y, i) => y - ly2[i]).filter((d) => d > 0).sort((a, b) => a - b);
-  const pitch = gaps.length ? gaps[gaps.length >> 1] : 0;
-  const nearest = (y) => {
-    let bi = -1, bd = Infinity;
-    outY.forEach((ry, i) => {
-      const d = Math.abs(y - ry);
-      if (d < bd) {
-        bd = d;
-        bi = i;
-      }
+  };
+  const attachPlan = (S) => {
+    const outY = S.outY;
+    const headY = [...S.headings.map((h) => h.y), ...S.headLines];
+    const ly2 = outY.length > 1 ? [...outY, ...headY].filter((y) => y <= outY[outY.length - 1]).sort((a, b) => a - b) : [];
+    const gaps = ly2.slice(1).map((y, i) => y - ly2[i]).filter((d) => d > 0).sort((a, b) => a - b);
+    const pitch = gaps.length ? gaps[gaps.length >> 1] : 0;
+    const nearestIn = (ys, y) => {
+      let bi = -1, bd = Infinity;
+      ys.forEach((ry, i) => {
+        const d = Math.abs(y - ry);
+        if (d < bd) {
+          bd = d;
+          bi = i;
+        }
+      });
+      return { i: bi, d: bd };
+    };
+    const radius = (h) => pitch ? pitch * 0.6 : Math.max(h, 8) * 1.6;
+    const headYs = [...headY].sort((p, q) => p - q);
+    const byHeading = (y, d, rowAt) => headYs.some((hy) => hy !== y && (Math.abs(y - hy) < d || Math.abs(y - hy) === d && hy < rowAt));
+    const orphanT = S.orphans.map((o) => {
+      const { i, d } = nearestIn(outY, o.y);
+      if (i < 0 || d > radius(Math.max(...o.toks.map((t) => t.h || 8)))) return -1;
+      return byHeading(o.y, d, outY[i]) ? -1 : i;
+    });
+    const taken = /* @__PURE__ */ new Set();
+    const markerT = S.markers.map((m) => {
+      const { i, d } = nearestIn(outY, m.span.y);
+      if (i < 0 || d > radius(m.span.h || 8) || taken.has(i)) return -1;
+      taken.add(i);
+      return i;
     });
-    return { i: bi, d: bd };
+    return { radius, nearestIn, byHeading, orphanT, markerT };
   };
-  const radius = (h) => pitch ? pitch * 0.6 : Math.max(h, 8) * 1.6;
-  const headYs = [...headY].sort((p, q) => p - q);
-  for (const o of orphans) {
-    const { i, d } = nearest(o.y);
-    if (i < 0 || d > radius(Math.max(...o.toks.map((t) => t.h || 8)))) continue;
-    if (headYs.some((hy) => hy !== o.y && (Math.abs(o.y - hy) < d || Math.abs(o.y - hy) === d && hy < outY[i]))) continue;
-    add(out[i], o.toks);
-  }
-  for (const m of markers) {
-    const { i, d } = nearest(m.span.y);
-    if (i < 0 || d > radius(m.span.h || 8) || out[i].revision) continue;
-    const ebox = m.tri ? merge(bboxOf(m.span), m.tri) : bboxOf(m.span);
-    out[i].revision = { rev: m.rev, source: { sheet: sheetKey, text: m.span.str.trim(), bbox: ebox }, ...m.drawn ? { drawn: true } : {} };
-  }
-  if (kind === "finish") {
-    const keyCol = cols ? cols.cols[0].label : anchors[0].label;
+  const applyAttach = (S, orphanT, markerT) => {
+    S.orphans.forEach((o, k) => {
+      if (orphanT[k] >= 0) add(S.out[orphanT[k]], o.toks);
+    });
+    S.markers.forEach((m, k) => {
+      const i = markerT[k];
+      if (i < 0 || S.out[i].revision) return;
+      const ebox = m.tri ? merge(bboxOf(m.span), m.tri) : bboxOf(m.span);
+      S.out[i].revision = { rev: m.rev, source: { sheet: sheetKey, text: m.span.str.trim(), bbox: ebox }, ...m.drawn ? { drawn: true } : {} };
+    });
+  };
+  const keyCol = cols ? cols.cols[0].label : anchors[0].label;
+  const printed = (r) => {
+    const keyRest = norm(r.cells[keyCol]?.text ?? r.key).replace(/[^A-Z0-9 ]/g, "").trim().replace(new RegExp("^" + r.key + "\\b"), "").trim();
+    return [...keyRest ? [keyRest] : [], ...Object.entries(r.cells).filter(([k]) => k !== keyCol).map(([, c]) => norm(c.text))];
+  };
+  const prefixes = (label, n) => n.key.startsWith(label + "-") || new RegExp("^" + label + "\\d").test(n.key);
+  const dropGroupLabels = (S) => {
     const dropped = /* @__PURE__ */ new Set();
-    for (let i = out.length - 1; i >= 0; i--) {
-      const r = out[i];
+    for (let i = S.out.length - 1; i >= 0; i--) {
+      const r = S.out[i];
       if (!/^[A-Z]{1,3}$/.test(r.key)) continue;
-      const keyRest = norm(r.cells[keyCol]?.text ?? r.key).replace(/[^A-Z0-9 ]/g, "").trim().replace(new RegExp("^" + r.key + "\\b"), "").trim();
-      const texts = [...keyRest ? [keyRest] : [], ...Object.entries(r.cells).filter(([k]) => k !== keyCol).map(([, c]) => norm(c.text))];
+      const texts = printed(r);
       if (texts.length && !texts.some((x) => /^\d{2} ?\d{2}[ .]?\d{2}\b/.test(x))) continue;
-      if (out.slice(i + 1, i + 4).some((n) => n.key.startsWith(r.key + "-") || new RegExp("^" + r.key + "\\d").test(n.key))) {
+      if (S.out.slice(i + 1, i + 4).some((n) => prefixes(r.key, n))) {
         dropped.add(r);
-        out.splice(i, 1);
-        outY.splice(i, 1);
+        dropRowAt(S, i);
       }
     }
-    if (dropped.size) {
-      region = null;
-      for (const r of everRows) if (!dropped.has(r)) for (const c of Object.values(r.cells)) region = region ? merge(region, c.bbox) : c.bbox;
+    return dropped;
+  };
+  const setBuildings = (out) => {
+    for (const row of out) {
+      if (row.building) continue;
+      const cellB = norm(row.cells.BLDG?.text || row.cells.BUILDING?.text || "");
+      if (DESIGNATOR_RE.test(cellB)) row.building = cellB;
+    }
+  };
+  const regionOf = (S, dropped) => {
+    let region = null;
+    for (const r of S.everRows) if (!dropped.has(r)) for (const c of Object.values(r.cells)) region = region ? merge(region, c.bbox) : c.bbox;
+    const lastY = S.outY.length ? S.outY[S.outY.length - 1] : -Infinity;
+    for (const hd of S.headings) if (hd.y <= lastY) region = region ? merge(region, hd.bbox) : hd.bbox;
+    return region;
+  };
+  const markWordSplitNotUsed = (S, keyFirst2) => {
+    if (!keyFirst2) return;
+    S.out.forEach((r, k) => {
+      if (r.notUsed) return;
+      const rest = S.outToks[k].slice(1).filter((t) => columnOf(t) === keyCol).map((t) => t.str.trim()).join(" ");
+      if (!rest || !normalizeNotUsed(rest)) return;
+      r.notUsed = true;
+      r.notUsedText = rest.replace(/^[-–—:,\s]+/, "");
+    });
+  };
+  const P1 = scan();
+  const reset1 = blankBandResets(P1);
+  endCut(P1);
+  const plan1 = attachPlan(P1);
+  const orphanLine1 = new Map(P1.orphans.map((o, k) => [o.i, plan1.orphanT[k] >= 0 ? P1.outI[plan1.orphanT[k]] : -1]));
+  const markerLine1 = plan1.markerT.map((t) => t >= 0 ? P1.outI[t] : -1);
+  const keyedY1 = new Map(P1.outI.map((i, k) => [i, P1.outY[k]]));
+  const everLine1 = new Map(P1.everRows.map((r, k) => [r, P1.everI[k]]));
+  const keyByLine1 = new Map(P1.everRows.map((r, k) => [P1.everI[k], r.key]));
+  applyAttach(P1, plan1.orphanT, plan1.markerT);
+  const dropped1 = finish ? dropGroupLabels(P1) : /* @__PURE__ */ new Set();
+  setBuildings(P1.out);
+  const region1 = regionOf(P1, dropped1);
+  const mq = finish && !!cfg.marqueeRules && cfg.headerY != null;
+  if (!mq) {
+    resetSections(reset1);
+    return { out: P1.out, region: region1 };
+  }
+  const headerY = cfg.headerY;
+  const keyFirst = KEY_FIRST.has(anchors[0]?.label);
+  const p1Lines = new Set(P1.outI);
+  const lowerMedianGap = (ys) => {
+    const d = ys.slice(1).map((y, k) => y - ys[k]).filter((g) => g > 0).sort((p, q) => p - q);
+    return d.length ? d[d.length - 1 >> 1] : 0;
+  };
+  const lastP1Y = P1.outY.length ? P1.outY[P1.outY.length - 1] : -Infinity;
+  const lineYs = [headerY, ...P1.lines.map((l) => l.y)].sort((p, q) => p - q);
+  const linePitch = lowerMedianGap(lineYs.filter((y) => y <= lastP1Y));
+  const keyXs = P1.outToks.map((t) => t[0].x).sort((p, q) => p - q);
+  const keyHdr = cfg.hdrSpans?.find((t) => t.x - 0.5 <= anchors[0].x && anchors[0].x <= t.x + (t.w || 0) + 0.5);
+  const keyRefX = keyXs.length ? keyXs[keyXs.length - 1 >> 1] : keyHdr ? keyHdr.x : anchors[0].x;
+  const textH = (toks) => {
+    const hs = toks.map((t) => t.h || 8).sort((p, q) => p - q);
+    return hs[hs.length >> 1];
+  };
+  const aligned = (t, h) => inKey(t) && (cols ? Math.abs(atOf(t) - cols.cols[0].start) <= keyTol : Math.abs(t.x - keyRefX) <= Math.max(8, 0.5 * h));
+  const gapAbove = (y) => {
+    let above = -Infinity;
+    for (const ly of lineYs) if (ly < y && ly > above) above = ly;
+    return y - above;
+  };
+  const eligible = [];
+  const ocr = !!cfg.ocr;
+  if (keyFirst) {
+    for (const o of P1.orphans) {
+      const h = textH(o.toks);
+      if (!aligned(o.toks[0], h)) continue;
+      const att = orphanLine1.get(o.i) ?? -1, gap = gapAbove(o.y);
+      if (att < 0 || !ocr && gap >= Math.max(1.6 * h, 0.75 * linePitch)) eligible.push({ i: o.i, y: o.y, toks: o.toks, att, gap });
     }
   }
-  for (const row of out) {
-    if (row.building) continue;
-    const cellB = norm(row.cells.BLDG?.text || row.cells.BUILDING?.text || "");
-    if (DESIGNATOR_RE.test(cellB)) row.building = cellB;
+  const newRule = [];
+  const cands = [];
+  const hdrLines = [];
+  const cellsOfLine = (toks) => {
+    const by = /* @__PURE__ */ new Map();
+    for (const t of toks.slice(1)) {
+      const l = columnOf(t);
+      if (l !== keyCol) by.set(l, by.has(l) ? `${by.get(l)} ${t.str.trim()}` : t.str.trim());
+    }
+    return by;
+  };
+  const wordsOfTok = (t) => norm(t.str).split(/[\s/]+/).map((w) => w.replace(/^[^A-Z0-9]+|[^A-Z0-9]+$/g, "")).filter(Boolean);
+  const allHeaderWords = (t) => {
+    const w = wordsOfTok(t);
+    return w.length > 0 && /[A-Z]/.test(norm(t.str)) && w.every((x) => !/\d/.test(x) && HEADER_WORDS.has(x));
+  };
+  const headerLine = (toks) => toks.length > 2 && toks.slice(1).every(allHeaderWords) && toks.slice(1).some((t) => wordsOfTok(t).some((x) => HEADER_WORDS_STRONG.has(x)));
+  const codeShaped = (x) => {
+    const c = norm(x);
+    return CODE_RE.test(c) && /\d/.test(c);
+  };
+  for (const e of eligible) {
+    const s = splitKeyCell(e.toks[0].str);
+    if (s) {
+      newRule.push({ e, s });
+      continue;
+    }
+    const word = norm(e.toks[0].str).replace(/^[^A-Z0-9]+|[^A-Z0-9]+$/g, "");
+    if (LETTERS_RE.test(word) && !e.toks.slice(1).some(inKey)) {
+      if (ocr) continue;
+      if (LETTERS_STOP.has(word)) continue;
+      if (headerLine(e.toks)) {
+        hdrLines.push(e);
+        continue;
+      }
+      const cells = cellsOfLine(e.toks);
+      if ([...cells.values()].filter(codeShaped).length >= 2) continue;
+      cands.push({ e, word, cells });
+      continue;
+    }
+    if (allHeaderWords(e.toks[0]) && headerLine(e.toks)) hdrLines.push(e);
+  }
+  if (cands.length) {
+    const decidedLines = /* @__PURE__ */ new Set([...newRule.map((n) => n.e.i), ...cands.map((c) => c.e.i), ...hdrLines.map((e) => e.i)]);
+    const wraps = [];
+    for (const o of P1.orphans) {
+      const t1 = orphanLine1.get(o.i) ?? -1;
+      const rowY1 = keyedY1.get(t1);
+      if (t1 < 0 || rowY1 == null || decidedLines.has(o.i) || o.y <= rowY1) continue;
+      wraps.push({ row: t1, off: o.y - rowY1 });
+    }
+    const rowAbove = (y) => {
+      let best = null;
+      P1.outY.forEach((ry, k) => {
+        if (ry < y && (!best || ry > best.y)) best = { row: P1.outI[k], y: ry, cells: P1.outToks[k].slice(1).some((t) => columnOf(t) !== keyCol) };
+      });
+      return best;
+    };
+    for (let k = cands.length - 1; k >= 0; k--) {
+      const c = cands[k], up = rowAbove(c.e.y);
+      if (!up || !up.cells) continue;
+      const off = c.e.y - up.y, tol = Math.max(1, 0.1 * textH(c.e.toks));
+      if (wraps.some((w) => w.row !== up.row && Math.abs(w.off - off) <= tol)) cands.splice(k, 1);
+    }
+  }
+  const rowGap = lowerMedianGap(P1.outY);
+  const runPitch = P1.outY.length > 1 ? rowGap : medPitchLo;
+  const walk = [
+    ...P1.outY.map((y, k) => ({ y, kind: "row", at: k })),
+    ...P1.headings.map((h, k) => ({ y: h.y, kind: "head", at: k })),
+    ...newRule.map((n, k) => ({ y: n.e.y, kind: "new", at: k })),
+    ...cands.map((c, k) => ({ y: c.e.y, kind: "cand", at: k }))
+  ].sort((p, q) => p.y - q.y);
+  const reachedDown = /* @__PURE__ */ new Set(), reached = /* @__PURE__ */ new Set();
+  let prev = headerY;
+  for (const w of walk) {
+    if (w.y - prev <= (w.kind === "row" ? 8 : 2.5) * runPitch) {
+      reachedDown.add(w);
+      reached.add(w);
+      prev = w.y;
+    }
+  }
+  let next = Infinity;
+  for (let k = walk.length - 1; k >= 0; k--) {
+    const w = walk[k];
+    if (w.kind === "row") {
+      next = reachedDown.has(w) ? w.y : Infinity;
+      continue;
+    }
+    if (w.kind === "head") continue;
+    if (next - w.y <= 2.5 * runPitch) {
+      reached.add(w);
+      next = w.y;
+    } else next = Infinity;
+  }
+  const runHasSection = walk.some((w) => w.kind === "head" && reachedDown.has(w) && P1.headings[w.at].section != null);
+  const newReached = new Set(walk.filter((w) => w.kind === "new" && reached.has(w)).map((w) => w.at));
+  const surviving = newRule.filter((_n, k) => newReached.has(k));
+  const rekey = /* @__PURE__ */ new Map();
+  if (keyFirst) {
+    const p1Split = P1.out.map((r, k) => ({ i: P1.outI[k], key: r.key, s: splitKeyCell(P1.outToks[k][0].str) }));
+    for (const h of p1Split) if (h.s?.notUsed) rekey.set(h.i, { key: h.s.key, notUsed: true, notUsedText: h.s.notUsedText });
+    const finalKeys = [...p1Split.map((h) => ({ i: h.i, key: h.s?.notUsed ? h.s.key : h.key })), ...surviving.map((n) => ({ i: n.e.i, key: n.s.key }))];
+    const splitters = p1Split.filter((h) => h.s?.qualifier != null && !isAltQualifier(h.s.qualifier));
+    for (const h of splitters) {
+      const clash = finalKeys.some((f) => f.i !== h.i && f.key === h.s.key);
+      const twin = splitters.some((o) => o !== h && o.s.key === h.s.key);
+      if (!clash && !twin) rekey.set(h.i, { key: h.s.key, qualifier: h.s.qualifier });
+    }
+  }
+  const fate = /* @__PURE__ */ new Map();
+  const keyedRows = [...P1.out.map((r, k) => ({ key: r.key, y: P1.outY[k] })), ...surviving.map((n) => ({ key: n.s.key, y: n.e.y }))].sort((p, q) => p.y - q.y);
+  const numberedYs = keyedRows.filter((r) => /\d/.test(r.key)).map((r) => r.y);
+  for (let k = 0; k < walk.length; k++) {
+    const w = walk[k];
+    if (w.kind !== "cand") continue;
+    const c = cands[w.at];
+    if (!reached.has(w)) {
+      fate.set(w.at, "out");
+      continue;
+    }
+    const prefixed = keyedRows.filter((r) => r.y > c.e.y).slice(0, 3).some((r) => r.key.startsWith(c.word + "-") || new RegExp("^" + c.word + "\\d").test(r.key));
+    if (prefixed && c.cells.size <= 2 && [...c.cells.values()].some((x) => SPEC_SECTION_RE.test(norm(x)))) {
+      fate.set(w.at, "s");
+      continue;
+    }
+    if (prefixed && c.cells.size === 1) {
+      fate.set(w.at, "g");
+      continue;
+    }
+    let above = null;
+    for (let j = k - 1; j >= 0 && !above; j--) {
+      const l = walk[j];
+      if (l.kind === "head") continue;
+      if (l.kind === "cand" && fate.get(l.at) !== "row") continue;
+      if (l.kind === "new" && !newReached.has(l.at)) continue;
+      above = l;
+    }
+    const aboveOk = !above || above.kind === "row" || above.kind === "new" || above.kind === "cand" && fate.get(above.at) === "row";
+    fate.set(w.at, aboveOk && numberedYs.some((y) => y > c.e.y) && c.cells.size >= 2 ? "row" : "skipped");
+  }
+  const letterRows = cands.filter((_c, k) => fate.get(k) === "row");
+  const drops = [
+    ...hdrLines.map((e) => ({ e, reason: "h" })),
+    ...cands.flatMap((c, k) => {
+      const f = fate.get(k);
+      return f === "s" || f === "g" || f === "skipped" ? [{ e: c.e, reason: f, word: c.word }] : [];
+    })
+  ].sort((p, q) => p.e.y - q.e.y);
+  const skipped = drops.filter((d) => d.reason === "skipped").map((d) => d.word);
+  const diagOf = (e, kind2) => ({ y: e.y, kind: kind2, gapAbove: e.gap, linePitch, runPitch });
+  const diag = [
+    ...surviving.map((n) => diagOf(n.e, "new")),
+    ...letterRows.map((c) => diagOf(c.e, "new")),
+    ...drops.map((d) => diagOf(d.e, d.reason === "skipped" ? "skipped" : "consumed"))
+  ].sort((p, q) => p.y - q.y);
+  const ownerOf = (line) => line >= 0 ? keyByLine1.get(line) ?? null : null;
+  const textOf = (toks) => toks.map((t) => t.str.trim()).join(" ");
+  const consumed = drops.map((d) => ({ text: textOf(d.e.toks), y: d.e.y, reason: d.reason, owner: ownerOf(d.e.att) }));
+  const guard = { pass1Region: region1, pass1Rows: P1.out.length, pass1HasSection: P1.out.some((r) => !!r.section), runHasSection };
+  const meta = /* @__PURE__ */ new Map();
+  if (!surviving.length && !rekey.size && !letterRows.length && !drops.length) {
+    for (let k = 0; k < P1.out.length; k++) meta.set(P1.out[k], { y: P1.outY[k], pass1: true });
+    markWordSplitNotUsed(P1, keyFirst);
+    resetSections(reset1);
+    return { out: P1.out, region: region1, marquee: { ...guard, meta, consumed, diag, skipped } };
+  }
+  const over = new Map(rekey);
+  for (const n of surviving) over.set(n.e.i, { key: n.s.key, qualifier: n.s.qualifier, notUsed: n.s.notUsed, notUsedText: n.s.notUsedText });
+  for (const c of letterRows) over.set(c.e.i, { key: c.word });
+  const dropLines = new Set(drops.map((d) => d.e.i));
+  const P2 = scan(over, dropLines, ocr ? new Set(surviving.map((n) => n.e.i)) : void 0);
+  const reset2 = blankBandResets(P2);
+  endCut(P2);
+  const lettersLines = new Set(letterRows.map((c) => c.e.i));
+  const newLines = /* @__PURE__ */ new Set([...surviving.map((n) => n.e.i), ...lettersLines]);
+  const at2 = new Map(P2.outI.map((i, k) => [i, k]));
+  const p1Ys = [...keyedY1.entries()].sort((p, q) => p[1] - q[1]);
+  const moved = /* @__PURE__ */ new Map();
+  const dropCont = /* @__PURE__ */ new Set();
+  const ungluedFrom = /* @__PURE__ */ new Map();
+  const decided = [...surviving.map((n) => ({ e: n.e, drop: false })), ...letterRows.map((c) => ({ e: c.e, drop: false })), ...drops.map((d) => ({ e: d.e, drop: true }))].sort((p, q) => p.e.y - q.e.y);
+  for (const d of decided) {
+    const tookFrom = d.e.toks.map((t) => ({ from: ownerOf(d.e.att), text: t.str.trim() }));
+    const nextKeyed = Math.min(...P2.outY.filter((y) => y > d.e.y), ...decided.map((x) => x.e.y).filter((y) => y > d.e.y), Infinity);
+    const nextP1 = p1Ys.find(([, y]) => y > d.e.y);
+    let lastY = d.e.y;
+    for (const o of P2.orphans.filter((q) => q.y > d.e.y && q.y < nextKeyed).sort((p, q) => p.y - q.y)) {
+      const t1 = orphanLine1.get(o.i) ?? -1;
+      if (o.y - lastY > plan1.radius(Math.max(...o.toks.map((t) => t.h || 8)))) break;
+      const take = t1 < 0 || t1 === d.e.att || !!nextP1 && t1 === nextP1[0] && o.y - lastY < nextP1[1] - o.y;
+      if (!take) break;
+      if (d.drop) {
+        dropCont.add(o.i);
+        consumed.push({ text: textOf(o.toks), y: o.y, reason: "continuation", owner: ownerOf(t1) });
+      } else {
+        moved.set(o.i, d.e.i);
+        for (const t of o.toks) tookFrom.push({ from: ownerOf(t1), text: t.str.trim() });
+      }
+      lastY = o.y;
+    }
+    if (!d.drop) ungluedFrom.set(d.e.i, tookFrom);
   }
-  const lastY = outY.length ? outY[outY.length - 1] : -Infinity;
-  for (const hd of headings) if (hd.y <= lastY) region = region ? merge(region, hd.bbox) : hd.bbox;
-  return { out, region };
+  consumed.sort((p, q) => p.y - q.y);
+  const toNewRow = (y, h) => {
+    const { i, d } = plan1.nearestIn(P2.outY, y);
+    if (i < 0 || d > plan1.radius(h) || plan1.byHeading(y, d, P2.outY[i])) return -1;
+    return newLines.has(P2.outI[i]) ? i : -1;
+  };
+  const orphanT2 = P2.orphans.map((o) => {
+    if (dropCont.has(o.i)) return -1;
+    const to = moved.get(o.i);
+    if (to != null) return at2.get(to) ?? -1;
+    const t1 = orphanLine1.get(o.i) ?? -1;
+    if (t1 >= 0) return at2.get(t1) ?? -1;
+    return toNewRow(o.y, Math.max(...o.toks.map((t) => t.h || 8)));
+  });
+  const markerT2 = P2.markers.map((m, k) => {
+    if (dropLines.has(m.i)) return -1;
+    if (newLines.has(m.i)) return at2.get(m.i) ?? -1;
+    const t1 = markerLine1[k];
+    if (t1 >= 0) return at2.get(t1) ?? -1;
+    return toNewRow(m.span.y, m.span.h || 8);
+  });
+  applyAttach(P2, orphanT2, markerT2);
+  const droppedLines1 = new Set([...dropped1].map((r) => everLine1.get(r)));
+  const emptied = /* @__PURE__ */ new Set();
+  for (const o of P1.orphans) {
+    const t1 = orphanLine1.get(o.i) ?? -1;
+    if (t1 >= 0 && (newLines.has(o.i) || moved.has(o.i) || dropLines.has(o.i) || dropCont.has(o.i))) emptied.add(t1);
+  }
+  const dropped2 = /* @__PURE__ */ new Set();
+  for (let k = P2.out.length - 1; k >= 0; k--) if (droppedLines1.has(P2.outI[k])) {
+    dropped2.add(P2.out[k]);
+    dropRowAt(P2, k);
+  }
+  for (let k = P2.out.length - 1; k >= 0; k--) {
+    const r = P2.out[k];
+    if (!emptied.has(P2.outI[k]) || !/^[A-Z]{1,3}$/.test(r.key) || printed(r).length) continue;
+    if (P2.out.slice(k + 1, k + 4).some((n) => prefixes(r.key, n))) {
+      dropped2.add(r);
+      dropRowAt(P2, k);
+    }
+  }
+  setBuildings(P2.out);
+  const region2 = regionOf(P2, dropped2);
+  for (let k = 0; k < P2.out.length; k++) {
+    const i = P2.outI[k], r = P2.out[k];
+    const m = { y: P2.outY[k], pass1: p1Lines.has(i) };
+    if (newLines.has(i)) {
+      m.newRule = true;
+      m.ungluedFrom = ungluedFrom.get(i);
+    }
+    if (lettersLines.has(i)) m.lettersKey = true;
+    if (rekey.has(i)) m.pass1Key = keyByLine1.get(i);
+    meta.set(r, m);
+  }
+  markWordSplitNotUsed(P2, keyFirst);
+  resetSections(reset2);
+  return { out: P2.out, region: region2, marquee: { ...guard, meta, consumed, diag, skipped } };
 }
 function extractTable(sheet, kind, opts = {}) {
   const r = extractTableCore(sheet, kind, opts);
@@ -4453,7 +4940,7 @@ function extractTables(sheet, kind, opts = {}) {
   }
   return out;
 }
-function extractTableCore(sheet, kind, opts = {}) {
+function extractTableCore(sheet, kind, opts = {}, core = {}) {
   const horiz = sheet.spans.filter((s) => !isVertical(s));
   const vert = sheet.spans.filter(isVertical);
   const rows = clusterRows(horiz);
@@ -4467,6 +4954,7 @@ function extractTableCore(sheet, kind, opts = {}) {
   let dataBelowY = -Infinity;
   let titleFrom;
   let rotated = false;
+  let headerY;
   const flat = findHeaderRow(rows, vocab, required, minHits);
   if (flat) {
     anchors = flat.anchors;
@@ -4481,6 +4969,7 @@ function extractTableCore(sheet, kind, opts = {}) {
     hdrBlock = [...band].flatMap((k) => rows[k]);
     dataFrom = flat.rowIndex + 1;
     titleFrom = flat.rowIndex - 1;
+    headerY = hy;
   } else {
     const rot = findRotatedHeader(vert, vocab, required, minHits);
     if (!rot) return null;
@@ -4488,6 +4977,7 @@ function extractTableCore(sheet, kind, opts = {}) {
     anchors = rot.anchors;
     headerSpans = rot.spans;
     dataBelowY = rot.bottom - 2;
+    headerY = rot.bottom;
     dataFrom = 0;
     titleFrom = rows.findIndex((r) => rowY(r) >= rot.top) - 1;
     if (titleFrom < -1) titleFrom = rows.length - 1;
@@ -4503,23 +4993,38 @@ function extractTableCore(sheet, kind, opts = {}) {
     if (centerX(t) < hdrBand.x0 || centerX(t) > hdrBand.x1) continue;
     region = region ? merge(region, bboxOf(t)) : bboxOf(t);
   }
-  const banded = bandDataRows(rows, anchors, kind, sheet.key, opts.buildings, { fromIdx: dataFrom, belowY: dataBelowY, deltas: opts.deltas, sheetNumbers: opts.sheetNumbers, hdrSpans: headerSpans, hdrBand: hdrBlock, marquee: opts.marquee });
+  const marqueeRules = kind === "finish" && !!core.marqueeRules;
+  const headerRegion = region;
+  const banded = bandDataRows(rows, anchors, kind, sheet.key, opts.buildings, { fromIdx: dataFrom, belowY: dataBelowY, deltas: opts.deltas, sheetNumbers: opts.sheetNumbers, hdrSpans: headerSpans, hdrBand: hdrBlock, marquee: opts.marquee, resetAtBlankBand: opts.resetAtBlankBand, ...marqueeRules ? { marqueeRules, headerY, ...core.ocr ? { ocr: true } : {} } : {} });
   const out = banded.out;
   if (banded.region) region = region ? merge(region, banded.region) : banded.region;
+  const { x0, x1 } = bandLimits(anchors);
+  const findTitle = () => {
+    let title2 = null;
+    for (let i = titleFrom; i >= 0 && i >= titleFrom - 5 && !title2; i--) {
+      const hit = rows[i].find((t) => /SCHEDULE/.test(norm(t.str)) && t.x >= x0 && t.x <= x1);
+      if (hit) title2 = { sheet: sheet.key, text: hit.str.trim(), bbox: bboxOf(hit) };
+    }
+    return title2;
+  };
+  const wordsOf = () => headerSpans.flatMap((t) => t.str.toUpperCase().split(/[^A-Z]+/)).filter(Boolean);
   if (!out.length) {
     if (kind === "equipment" && region) return { skip: region };
+    if (marqueeRules && headerRegion) {
+      const mb2 = banded.marquee;
+      return { headerOnly: { title: findTitle(), headers: anchors.map((a) => a.label), headerWords: wordsOf(), hasSection: mb2.runHasSection, region: headerRegion, skipped: mb2.skipped, trace: { meta: mb2.meta, consumed: mb2.consumed, diag: mb2.diag } } };
+    }
     return null;
   }
-  const { x0, x1 } = bandLimits(anchors);
-  let title = null;
-  for (let i = titleFrom; i >= 0 && i >= titleFrom - 5 && !title; i--) {
-    const hit = rows[i].find((t) => /SCHEDULE/.test(norm(t.str)) && t.x >= x0 && t.x <= x1);
-    if (hit) title = { sheet: sheet.key, text: hit.str.trim(), bbox: bboxOf(hit) };
-  }
+  const title = findTitle();
   const table = { kind, sheet: sheet.key, title, headers: anchors.map((a) => a.label), rows: out, region, anchors };
   if (rotated) table.rotated_headers = true;
-  const headerWords = headerSpans.flatMap((t) => t.str.toUpperCase().split(/[^A-Z]+/)).filter(Boolean);
-  return { table, headerWords };
+  const headerWords = wordsOf();
+  if (!marqueeRules) return { table, headerWords };
+  const mb = banded.marquee;
+  const guardRegion = mb.pass1Rows ? headerRegion && mb.pass1Region ? merge(headerRegion, mb.pass1Region) : headerRegion ?? mb.pass1Region : headerRegion ?? region;
+  const hasSection = mb.pass1Rows ? mb.pass1HasSection : mb.runHasSection;
+  return { table, headerWords, guard: { guardRegion, hasSection, skipped: mb.skipped, trace: { meta: mb.meta, consumed: mb.consumed, diag: mb.diag } } };
 }
 var CONT_TAIL_RE = /[\s\-–—:.,(]*(?:CONTINUATION|CONTINUED|CONT['’]?D?)[\s.)]*$/;
 var isContinuationTitle = (text) => {
@@ -9192,7 +9697,7 @@ var Session = class _Session {
     if (assign) {
       if (s.upp == null) throw new UserError(this.scaleGate(s));
       graph = await this.ensureGraph();
-      if (!graph.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, not empty.");
+      if (!graph.available) throw new UserError("This set has no text layer (a raster image) \u2014 the sheet graph is unavailable, not empty.");
       if (!graph.tables.some((t) => t.kind === "room-finish")) {
         throw new UserError("No room-finish schedule in the working set \u2014 load_plan the schedule sheet with merge: true, or pass condition to commit every room under one tag.");
       }
@@ -16062,7 +16567,7 @@ No review gate: the pencil-not-ink rule exists to stop an agent inventing geomet
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/wiki.generated.ts
-var WIKI_VERSION = "0.9.93";
+var WIKI_VERSION = "0.9.96";
 var WIKI_PAGES = [
   {
     "key": "index",
@@ -16077,8 +16582,8 @@ var WIKI_PAGES = [
     "uri": "takeoff://wiki/status",
     "title": "Capability status",
     "source": "docs/wiki/status.md",
-    "source_sha256": "2db64b41c4510a679a5d589efc4546e4b74a9b7d31f34c9a8d13512d6bb5955b",
-    "text": "# Capability status\n\nThis page describes implementation support, not a promise that every plan can\nbe measured automatically. Follow its source links before changing behavior.\n\n| Capability | Current boundary | Evidence |\n|---|---|---|\n| Human and agent measurements | Shared geometry/quantity modules; source interpretation still requires inspection | [Geometry workflow](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md) |\n| Original machine geometry after human correction | Outer vertices preserved, including manual agent traces; missing historical originals cannot be recovered | [Compatibility](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/COMPATIBILITY.md) |\n| Human stitching | Browser gallery and alignment; editable browser archive preserves composites | [Workflow](takeoff://wiki/workflows) |\n| MCP stitched documents | No stitch tool; current import/export omits stitch records | [Field inventory](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/INVENTORY.md) |\n| One-Click | Temporarily gated in the default browser/MCP builds | [Gate](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/design/ONE_CLICK_GATE.md) |\n| Browser/MCP room boundaries | Shared quantity modules do not prove identical detector boundaries; the open [#385](https://github.com/Kentucky-ai/opentakeoff/issues/385) report remains unresolved | [Architecture](takeoff://wiki/architecture), [geometry evidence](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md) |\n| Toolbar command and voice | Gated in the default build; use normal controls and keyboard shortcuts | [User guide](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/USER_GUIDE.md#17-voice-and-the-command-box) |\n| TakeoffDocument v1 | Draft schemas, preflight and opt-in repository adapters for a bounded profile; legacy writer format remains | [Protocol](takeoff://wiki/protocol) |\n| Annotation cleanup | Text-only MCP edit with undo; RFI-linked notes refuse | [MCP routing](takeoff://wiki/mcp) |\n| Agent knowledge | Packaged wiki resources and source-generated tool/schema references | [Index](takeoff://wiki) |\n| Academy interoperability | Incompatibilities inventoried; no adapter or certification bridge claimed | [Academy report](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/ACADEMY_COMPATIBILITY.md) |\n| Shared work review | Personal layouts/shared review proposal is not merged; do not describe [PR #388](https://github.com/Kentucky-ai/opentakeoff/pull/388) as shipped | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Microsoft 365 annotation sync | Unproven across machines; the live validation remains open in [#315](https://github.com/Kentucky-ai/opentakeoff/issues/315) | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Learned floor-model bridge | Not on `main`; no model-generated geometry integration is advertised | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Independent geometry benchmark | Reference-assisted and synthetic checks are not independently reviewed ground truth | [Geometry evidence](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md#reusable-evidence-from-a-project-test) |\n\nNext protocol work connects the tested contracts to focused MCP workflows and\nmeasures tool-selection/completion results. Broader adapter profiles remain\nbounded by preservation tests. Package extraction, verified identity/signatures, Academy credentials\nand optional anchoring come later. Rendering optimization is separate from\nthis protocol and knowledge work.\n"
+    "source_sha256": "af701c08166b85f012db03053e7adecf0634ac6a8145f24e8d4c9dca02d314a2",
+    "text": "# Capability status\n\nThis page describes implementation support, not a promise that every plan can\nbe measured automatically. Follow its source links before changing behavior.\n\n| Capability | Current boundary | Evidence |\n|---|---|---|\n| Human and agent measurements | Shared geometry/quantity modules; source interpretation still requires inspection | [Geometry workflow](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md) |\n| Original machine geometry after human correction | Outer vertices preserved, including manual agent traces; missing historical originals cannot be recovered | [Compatibility](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/COMPATIBILITY.md) |\n| Human stitching | Browser gallery and alignment; editable browser archive preserves composites | [Workflow](takeoff://wiki/workflows) |\n| MCP stitched documents | No stitch tool; current import/export omits stitch records | [Field inventory](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/INVENTORY.md) |\n| One-Click | Temporarily gated in the default browser/MCP builds | [Gate](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/design/ONE_CLICK_GATE.md) |\n| Browser/MCP room boundaries | Shared quantity modules do not prove identical detector boundaries; the open [#385](https://github.com/Kentucky-ai/opentakeoff/issues/385) report remains unresolved | [Architecture](takeoff://wiki/architecture), [geometry evidence](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md) |\n| Plan-set search, Copy text, on-device page reads | Browser gallery and canvas; MCP text tools read the text layer only, no OCR. OCR reads scanned pages after a download notice and is labelled OCR; Copy text works on single sheets, not stitched surfaces. Import from schedule reads a raster schedule box on-device after the same notice; the in-canvas agent's `read_schedule` reads the text layer only. Kept OCR reads stay in this browser after sign-out, kept by the PDF's content hash | [User guide](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/USER_GUIDE.md#copy-text) |\n| Import from schedule\u2014extra forms | Drawn box only: codes followed by a word (FTB-01 CUT) read as the code; NOT USED / N.I.C. rows start unticked; on a text-layer box, a four- or five-letter code with no number is read when the header or a read row is above it, it fills two or more other columns, and a numbered code comes after it, else listed as not read (the on-device raster read neither reads nor lists them, and there a NOT USED or word-after code line in a short table can stay part of the row above); the sheet graph's whole-sheet index reads them as before | [User guide](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/USER_GUIDE.md#import-from-schedule) |\n| Toolbar command and voice | Gated in the default build; use normal controls and keyboard shortcuts | [User guide](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/USER_GUIDE.md#17-voice-and-the-command-box) |\n| TakeoffDocument v1 | Draft schemas, preflight and opt-in repository adapters for a bounded profile; legacy writer format remains | [Protocol](takeoff://wiki/protocol) |\n| Annotation cleanup | Text-only MCP edit with undo; RFI-linked notes refuse | [MCP routing](takeoff://wiki/mcp) |\n| Agent knowledge | Packaged wiki resources and source-generated tool/schema references | [Index](takeoff://wiki) |\n| Academy interoperability | Incompatibilities inventoried; no adapter or certification bridge claimed | [Academy report](https://github.com/Kentucky-ai/opentakeoff/blob/main/protocol/ACADEMY_COMPATIBILITY.md) |\n| Shared work review | Personal layouts/shared review proposal is not merged; do not describe [PR #388](https://github.com/Kentucky-ai/opentakeoff/pull/388) as shipped | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Microsoft 365 annotation sync | Unproven across machines; the live validation remains open in [#315](https://github.com/Kentucky-ai/opentakeoff/issues/315) | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Learned floor-model bridge | Not on `main`; no model-generated geometry integration is advertised | [Roadmap](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/ROADMAP.md) |\n| Independent geometry benchmark | Reference-assisted and synthetic checks are not independently reviewed ground truth | [Geometry evidence](https://github.com/Kentucky-ai/opentakeoff/blob/main/docs/GEOMETRY_WORKFLOW.md#reusable-evidence-from-a-project-test) |\n\nNext protocol work connects the tested contracts to focused MCP workflows and\nmeasures tool-selection/completion results. Broader adapter profiles remain\nbounded by preservation tests. Package extraction, verified identity/signatures, Academy credentials\nand optional anchoring come later. Rendering optimization is separate from\nthis protocol and knowledge work.\n"
   },
   {
     "key": "architecture",
@@ -16673,7 +17178,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.93",
+  version: "0.9.96",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.93",
+  "version": "0.9.96",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",