@floless/app 0.62.0 → 0.63.0

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.62.0" : void 0,
+    define: true ? "0.63.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.62.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.63.0" : void 0 });
 }
 
 // workflow-update.ts

package/dist/schemas/steel.takeoff.v1.schema.json

@@ -43,6 +43,24 @@
     "dims3d": { "type": "array", "items": { "$ref": "#/$defs/dim3" }, "description": "Draft-only 3D dimensions (editor annotations, model-global). World-scene mm. NOT baked into the lock / 3D scene / IFC / BOM." }
   },
   "$defs": {
+    "grid": {
+      "type": ["object", "null"],
+      "required": ["origin"],
+      "additionalProperties": true,
+      "description": "Structural grid: X/Y are RELATIVE spacing strings (Tekla syntax — \"0 3*25' 20'-6\\\"\", n*d repeats a bay; tokens accept ft-in / inches / m / bare mm), Z is ABSOLUTE elevations. X entries space lines along +X (lines vertical on the plan, auto-labels 1,2,3…); Y entries march UP the sheet (lines horizontal, auto-labels A,B,C…). web/grid-core.js is the parser/geometry source of truth.",
+      "properties": {
+        "on": { "type": "boolean", "description": "Grid visible (2D + 3D). Default true." },
+        "origin": { "$ref": "#/$defs/point2", "description": "The [1,A] corner, display space (same space as member wp)." },
+        "x": { "type": "string", "description": "Relative spacings along +X, e.g. \"0 3*25'\"." },
+        "y": { "type": "string", "description": "Relative spacings up the sheet, e.g. \"0 4*30'\"." },
+        "z": { "type": "string", "description": "Absolute level elevations, e.g. \"0 16'-6\\\"\"." },
+        "labels_x": { "type": "string", "description": "Whitespace-separated label overrides for X lines; blank = auto 1,2,3…" },
+        "labels_y": { "type": "string", "description": "Whitespace-separated label overrides for Y lines; blank = auto A,B,C…" },
+        "ext": { "type": "number", "description": "How far lines run past the outermost line, in mm. Default 5'." },
+        "ends_x": { "type": "object", "description": "Per-line extent overrides for X lines: { \"<line index>\": [lo, hi] } display px along the line (a partial line like a 5.1 insert covering one wing). null / absent element = the auto full span. Set by dragging a bubble along its line." },
+        "ends_y": { "type": "object", "description": "Per-line extent overrides for Y lines — same shape as ends_x." }
+      }
+    },
     "filter": {
       "type": "object",
       "additionalProperties": true,
@@ -111,18 +129,21 @@
         },
         "elements": {
           "type": "array",
-          "description": "Every drawing element: lines (with an SVG path `d`) and text spans (with `text`+`bbox`), each tagged layer/thickness/colour.",
+          "description": "Every drawing element: lines (with an SVG path `d`), text spans (with `text`+`bbox`) and circles (`cx`/`cy`/`r` — grid bubbles, callout balloons), each tagged layer/thickness/colour.",
           "items": {
             "type": "object",
             "additionalProperties": true,
             "properties": {
-              "kind": { "enum": ["line", "text"] },
+              "kind": { "enum": ["line", "text", "circle"] },
               "layer": { "type": "string" },
               "w": { "type": "number" },
               "color": { "type": "string" },
               "d": { "type": "string", "description": "SVG path (line elements)." },
               "text": { "type": "string", "description": "Label text (text elements)." },
               "bbox": { "type": "array", "items": { "type": "number" }, "description": "[x0,y0,x1,y1] (text elements)." },
+              "cx": { "type": "number", "description": "Circle centre X (circle elements)." },
+              "cy": { "type": "number", "description": "Circle centre Y (circle elements)." },
+              "r": { "type": "number", "description": "Circle radius (circle elements)." },
               "dashed": { "type": "boolean" }
             }
           }
@@ -150,18 +171,21 @@
         "steelBbox": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] of this sheet's steel linework, for Zoom-to-steel." },
         "elements": {
           "type": "array",
-          "description": "This sheet's drawing elements: lines (SVG path `d`) and text spans (`text`+`bbox`), each tagged layer/thickness/colour.",
+          "description": "This sheet's drawing elements: lines (SVG path `d`), text spans (`text`+`bbox`) and circles (`cx`/`cy`/`r` — grid bubbles feed the editor's grid-from-drawing detector), each tagged layer/thickness/colour.",
           "items": {
             "type": "object",
             "additionalProperties": true,
             "properties": {
-              "kind": { "enum": ["line", "text"] },
+              "kind": { "enum": ["line", "text", "circle"] },
               "layer": { "type": "string" },
               "w": { "type": "number" },
               "color": { "type": "string" },
               "d": { "type": "string" },
               "text": { "type": "string" },
               "bbox": { "type": "array", "items": { "type": "number" } },
+              "cx": { "type": "number" },
+              "cy": { "type": "number" },
+              "r": { "type": "number" },
               "dashed": { "type": "boolean" }
             }
           }
@@ -236,7 +260,8 @@
         "tos_callouts": { "type": "array", "items": { "$ref": "#/$defs/tos_callout" } },
         "members": { "type": "array", "items": { "$ref": "#/$defs/member" } },
         "dims": { "type": "array", "items": { "$ref": "#/$defs/dim" }, "description": "Draft-only on-drawing dimensions (editor annotations). NOT baked into the lock / 3D / IFC / BOM." },
-        "frame": { "$ref": "#/$defs/frame" }
+        "frame": { "$ref": "#/$defs/frame" },
+        "grid": { "$ref": "#/$defs/grid", "description": "Structural grid lines (Tekla-style). PER-PLAN — its origin/spacings live in this sheet's display space (like frame/dims). A plan REFERENCE the editor renders in 2D + 3D and snaps to — it never constrains members and is NOT baked into the lock / IFC / BOM." }
       }
     },
     "segment": {

package/dist/skills/floless-app-steel-takeoff/SKILL.md

@@ -2,7 +2,7 @@
 name: floless-app-steel-takeoff
 description: Read a structural steel drawing into an editable steel.takeoff/v1 contract in floless.app — the "Steel Takeoff" reader. Triggers on a pending floless `rebake` request for the `steel-model` app (queued from its "Re-read & re-bake ▸" button), or asks like "read this framing plan into a takeoff", "turn this structural drawing into a takeoff", "bake my drawing into steel-model", "extract members from this PDF". Teaches the host AI to READ a steel drawing (PDF/image) with its own vision at COMPOSE time, build a steel.takeoff/v1 contract (members + profiles + elevations + weights from AISC lookup), write it to the contract store, and hand control to the editor — no model in the run path, no API key.
 metadata:
-  version: 0.3.0
+  version: 0.4.0
 ---
 
 # Steel Takeoff — read a drawing into a steel.takeoff/v1 contract
@@ -80,6 +80,11 @@ native/display coords):
    pt>, color:<#rrggbb stroke>, d:<SVG path>, dashed:<bool> }`.
 2. **Text** — `page.get_text("dict")`: per span keep `{ kind:"text", layer:<OCG>, w:0, color:<#hex>,
    text:<string>, bbox:[x0,y0,x1,y1] }`.
+2b. **Circles** — a closed bezier path whose bbox is round (width ≈ height, ≥ ~8 pt across) becomes
+   `{ kind:"circle", cx:<centre x>, cy:<centre y>, r:<radius> }` in display space. These are the grid
+   bubbles and callout balloons; the editor's **grid-from-drawing** detector (`web/grid-core.js`
+   `gridFromDrawing`) anchors grid lines to them, so skipping circles silently disables the Grid
+   panel's "From drawing" button.
 3. **Per-sheet entry** — push `{ sheet:<number>, title:<name?>, page:{ w, h, bg_b64, rect }, steelBbox,
    elements:[…] }` onto `filter.sheets`. `bg_b64` is a dimmed raster of THIS sheet's framing area
    (**title block excluded** — CONFIDENTIAL, machine-local, never committed). **`page.rect` = the exact
@@ -96,6 +101,29 @@ native/display coords):
 5. Set `filter.mode: "layer"`, `filter.active: 0`. **PUT** the contract
    (`PUT /api/contract/steel-model`). On a re-read, preserve any existing per-facet `on` flags.
 
+### 1c. Grid lines — read the printed grid (quick, per sheet)
+
+With the filter elements in hand, populate each plan's **`plan.grid`** (Tekla-style grid lines the
+editor renders in 2D + 3D and snaps to). The geometry is deterministic — the editor's Grid panel has
+a "From drawing" button running the same detector (`web/grid-core.js` `gridFromDrawing`: grid lines
+are the long dash-dot line fields that AIM at a bubble circle's centre and STOP at its edge; bubbles
+line up in a row along one sheet edge and columns along the sides). What the detector usually can't
+get is the **labels** — CAD sets outline their text, so bubble marks like `5.1` / `K.1` aren't in the
+text layer. You CAN read them: you already have vision on the sheet. So:
+
+1. Derive the line positions (or let the user press "From drawing" later — same result).
+2. **Vision-read each bubble's mark** from the sheet render, in line order.
+3. Write `plan.grid = { on:true, origin:[x,y], x:"0 3*25' …", y:"…", z:"0", labels_x:"K J H …",
+   labels_y:"0.5 1 1.1 …", ext:<mm> }` — origin = the left-most × bottom-most line crossing,
+   spacings are RELATIVE ft-in tokens (`n*d` repeats a bay), labels are whitespace-separated
+   overrides in line order (X: left→right; Y: bottom→up). Sanity-check a bay or two against the
+   printed dimension strings between grid lines — a mismatch means the sheet scale (`pt_per_ft`) is
+   wrong, which corrupts the whole takeoff, not just the grid. **Then PUT the contract again** —
+   the 1b PUT already happened, and the user's next Filter-node Save writes back the contract *it
+   loaded*; an un-PUT grid (and its vision-read labels) would be silently dropped.
+
+Skip silently only when the sheet genuinely has no grid bubbles (rare for framing plans); say so.
+
 **Then STOP and hand off — checkpoint before the member read.** Tell the user to open the **Filter**
 node, flip through the sheets, narrow to the steel, and **Save**. The saved `on` flags + `mode` are
 what step 2 reads — **per sheet** (each sheet's elements passing `mode` + the global `on` flags). Only

package/dist/web/grid-core.js

@@ -0,0 +1,441 @@
+/*
+ * grid-core.js — PURE, framework-free structural-grid core (no DOM, no Three.js). Unit-tested in
+ * node (server/grid-core.test.ts) AND loaded by the steel editor's 2D plan mode + 3D view.
+ *
+ * The grid is Tekla-style but friendlier: X/Y spacings are RELATIVE coordinate strings
+ * ("0 3*25' 20'-6\"" — each entry is the distance from the previous line, n*d repeats a bay),
+ * Z levels are ABSOLUTE elevations. Tokens accept ft-in (25'-6"), bare inches (6"), metres (7.5m)
+ * and bare numbers as mm — mixed freely. Everything parses to canonical mm.
+ *
+ * Contract shape (PER-PLAN, plan.grid — origin/spacings live in that sheet's display space, like
+ * member wp / frame / dims, so it rides the per-plan undo stack safely):
+ *   { on, origin:[x,y] px, x:"0 3*25'", y:"0 4*20'", z:"0", labels_x:"", labels_y:"", ext: mm }
+ * X entries position lines ALONG +X (the lines run vertically on the plan), labelled 1,2,3… ;
+ * Y entries march UP the sheet (display -Y == scene +Y), lines horizontal, labelled A,B,C… .
+ */
+
+export const IN_MM = 25.4;
+export const FT_MM = 304.8;
+
+/** mm per display px for a plan scale (matches steel-3d-core kOf). */
+export const mmPerPx = (ptPerFt) => FT_MM / (ptPerFt > 0 ? ptPerFt : 1);
+
+/** One length token → mm, or NaN. Accepts 25' | 25'-6" | 25'6" | 6" | 7.5m | 6096 (mm) | 6096mm; leading '-' negates. */
+export function parseLen(tok) {
+  let s = String(tok == null ? '' : tok).trim();
+  if (!s) return NaN;
+  let sign = 1;
+  if (s[0] === '-') { sign = -1; s = s.slice(1); }
+  else if (s[0] === '+') s = s.slice(1);
+  let m;
+  if ((m = /^(\d+(?:\.\d+)?)'(?:-?(\d+(?:\.\d+)?)")?$/.exec(s))) return sign * (+m[1] * FT_MM + (m[2] ? +m[2] * IN_MM : 0));
+  if ((m = /^(\d+(?:\.\d+)?)"$/.exec(s))) return sign * +m[1] * IN_MM;
+  if ((m = /^(\d+(?:\.\d+)?)m$/.exec(s))) return sign * +m[1] * 1000;
+  if ((m = /^(\d+(?:\.\d+)?)(?:mm)?$/.exec(s))) return sign * +m[1];
+  return NaN;
+}
+
+/** mm → a clean display token: ft-in when it lands on a 1/16", else integer mm. Round-trips through parseLen. */
+export function fmtLen(mm) {
+  if (Math.abs(mm) < 0.05) return '0';
+  const neg = mm < 0, a = Math.abs(mm);
+  const sixteenths = Math.round(a / (IN_MM / 16));
+  if (sixteenths > 0 && Math.abs(a - sixteenths * (IN_MM / 16)) < 0.05) { // lands on a 1/16" → ft-in reads native for US drawings
+    const inches = sixteenths / 16;
+    const ft = Math.floor(inches / 12);
+    const rest = inches - ft * 12; // may be fractional — decimal inches, since tokens can't contain spaces
+    const restStr = String(Math.round(rest * 16) / 16) + '"';
+    const body = ft > 0 ? (ft + "'" + (rest > 0 ? '-' + restStr : '')) : restStr;
+    return (neg ? '-' : '') + body;
+  }
+  return (neg ? '-' : '') + Math.round(a);
+}
+
+/**
+ * A relative spacing string → cumulative offsets (mm, from the grid origin).
+ * "0 3*25' 20'" → [0, 7620, 15240, 22860, 28956]. Separators: whitespace / commas; repeat: n*d or nxd.
+ * The first entry is the first line's offset (any sign); later entries must be > 0.
+ * Returns { offsets, err } — err is a human-readable reason (offsets = [] then).
+ */
+export function parseSpacings(str) {
+  const toks = String(str == null ? '' : str).trim().split(/[\s,]+/).filter(Boolean);
+  if (!toks.length) return { offsets: [], err: null }; // empty = a valid axis-less grid (X-only / Y-only)
+  const offsets = [];
+  let at = 0;
+  for (let i = 0; i < toks.length; i++) {
+    const rep = /^(\d+)[*xX](.+)$/.exec(toks[i]);
+    const n = rep ? +rep[1] : 1;
+    const d = parseLen(rep ? rep[2] : toks[i]);
+    if (!isFinite(d) || (rep && n < 1)) return { offsets: [], err: 'can’t read “' + toks[i] + '”' };
+    const isFirstOffset = (i === 0 && !rep); // only the first plain entry may be ≤ 0 (the origin offset)
+    if (!isFirstOffset && d <= 0) return { offsets: [], err: 'spacing “' + toks[i] + '” must be > 0' };
+    for (let r = 0; r < n; r++) { at += d; offsets.push(at); }
+  }
+  return { offsets, err: null };
+}
+
+/** Cumulative offsets (mm) → a compact relative string ("0 3*25' 20'"): equal runs compress to n*d. */
+export function formatSpacings(offsets) {
+  if (!offsets || !offsets.length) return '';
+  const diffs = offsets.map((v, i) => v - (i ? offsets[i - 1] : 0));
+  const out = [];
+  for (let i = 0; i < diffs.length;) {
+    let j = i + 1;
+    while (j < diffs.length && Math.abs(diffs[j] - diffs[i]) < 0.5) j++;
+    const n = j - i, tok = fmtLen(diffs[i]);
+    out.push(n > 1 ? n + '*' + tok : tok);
+    i = j;
+  }
+  return out.join(' ');
+}
+
+/** Auto labels: style 'num' → 1,2,3… ; 'alpha' → A…Z, AA, AB… */
+export function autoLabels(style, n) {
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    if (style === 'num') { out.push(String(i + 1)); continue; }
+    let s = '', k = i;
+    do { s = String.fromCharCode(65 + (k % 26)) + s; k = Math.floor(k / 26) - 1; } while (k >= 0);
+    out.push(s);
+  }
+  return out;
+}
+
+/** n labels for an axis: whitespace-separated overrides first, auto-continue past them. */
+export function labelsFor(override, style, n) {
+  const own = String(override || '').trim().split(/\s+/).filter(Boolean);
+  const auto = autoLabels(style, n);
+  return auto.map((a, i) => own[i] != null ? own[i] : a);
+}
+
+/** A fresh default grid (display-space origin px). 4×4 30' bays, ground level only. */
+export function defaultGrid(origin) {
+  return { on: true, origin: (origin || [0, 0]).slice(0, 2), x: "0 3*30'", y: "0 3*30'", z: '0', labels_x: '', labels_y: '', ext: 5 * FT_MM };
+}
+
+/** True when g is structurally usable (parseable origin — the spacing strings report their own errors). */
+export function sane(g) {
+  return !!(g && Array.isArray(g.origin) && g.origin.length >= 2 && isFinite(g.origin[0]) && isFinite(g.origin[1]));
+}
+
+/**
+ * The grid resolved to display-space plan geometry.
+ * v = vertical lines (spaced along +X, labels 1,2,3…): { x, label }
+ * h = horizontal lines (spaced UP the sheet = -Y, labels A,B,C…): { y, label }
+ * zs = levels: { mm, label } (sorted, deduped). ext/extents are display px.
+ * errX/errY/errZ carry per-axis parse errors; lines of a failed axis are [].
+ */
+export function gridGeometry(g, ptPerFt) {
+  const k = mmPerPx(ptPerFt);
+  const px = (mm) => mm / k;
+  const X = parseSpacings(g && g.x), Y = parseSpacings(g && g.y);
+  const ok = sane(g);
+  const ox = ok ? g.origin[0] : 0, oy = ok ? g.origin[1] : 0;
+  const lx = labelsFor(g && g.labels_x, 'num', X.offsets.length);
+  const ly = labelsFor(g && g.labels_y, 'alpha', Y.offsets.length);
+  const v = X.offsets.map((off, i) => ({ x: ox + px(off), label: lx[i] }));
+  const h = Y.offsets.map((off, i) => ({ y: oy - px(off), label: ly[i] })); // up the sheet = -Y (scene +Y)
+  // Z levels: absolute tokens, sorted + deduped, labelled by elevation (or overridden order-preserving)
+  const ztoks = String((g && g.z) == null ? '' : g.z).trim().split(/[\s,]+/).filter(Boolean);
+  let errZ = null;
+  const zmm = [];
+  for (const t of ztoks) {
+    const val = parseLen(t);
+    if (!isFinite(val)) { errZ = 'can’t read “' + t + '”'; break; }
+    if (!zmm.some((z) => Math.abs(z - val) < 0.5)) zmm.push(val);
+  }
+  zmm.sort((a, b) => a - b);
+  const zs = errZ ? [] : zmm.map((mm) => ({ mm, label: fmtLen(mm) }));
+  const ext = px((g && isFinite(g.ext)) ? g.ext : 5 * FT_MM);
+  const xs = v.map((l) => l.x), ys = h.map((l) => l.y);
+  const geo = {
+    v, h, zs,
+    errX: X.err, errY: Y.err, errZ,
+    ext,
+    x0: (xs.length ? Math.min(...xs) : ox) - ext, x1: (xs.length ? Math.max(...xs) : ox) + ext,
+    y0: (ys.length ? Math.min(...ys) : oy) - ext, y1: (ys.length ? Math.max(...ys) : oy) + ext,
+  };
+  // per-line extent overrides (g.ends_x / g.ends_y: { "<index>": [lo|null, hi|null] } display px along
+  // the line — a real sheet has partial lines like a 5.1 covering one wing). null / absent = the auto
+  // full span. Every consumer (2D render, snapping, 3D) reads l.lo / l.hi.
+  for (const [i, l] of v.entries()) {
+    const o = (g && g.ends_x && g.ends_x[i]) || [];
+    l.lo = o[0] != null && isFinite(o[0]) ? +o[0] : geo.y0;
+    l.hi = o[1] != null && isFinite(o[1]) ? +o[1] : geo.y1;
+  }
+  for (const [i, l] of h.entries()) {
+    const o = (g && g.ends_y && g.ends_y[i]) || [];
+    l.lo = o[0] != null && isFinite(o[0]) ? +o[0] : geo.x0;
+    l.hi = o[1] != null && isFinite(o[1]) ? +o[1] : geo.x1;
+  }
+  return geo;
+}
+
+/**
+ * Drag one END of a grid line along its axis (extend/shorten — the bubbles are the grips).
+ * end 0 = the lo end (top of a v-line / left of an h-line), 1 = hi. Clamps to a 12" minimum line and
+ * snaps BACK TO AUTO when released within ~6px of the full-span extent (the override is deleted, so
+ * the end keeps following the grid when lines are added later). Mutates g; returns the applied
+ * position, or null when there's no such line.
+ * ponytail: overrides are keyed by line INDEX — editing the spacing string re-maps them positionally.
+ */
+export function moveGridLineEnd(g, ptPerFt, axis, i, end, np) {
+  const geo = gridGeometry(g, ptPerFt);
+  const line = (axis === 'v' ? geo.v : geo.h)[i];
+  if (!line) return null;
+  const auto = axis === 'v' ? [geo.y0, geo.y1] : [geo.x0, geo.x1];
+  const k = mmPerPx(ptPerFt);
+  const MINLEN = 12 * IN_MM / k; // 12" minimum line length in px
+  const other = end === 0 ? line.hi : line.lo;
+  np = end === 0 ? Math.min(np, other - MINLEN) : Math.max(np, other + MINLEN);
+  const key = axis === 'v' ? 'ends_x' : 'ends_y';
+  if (!g[key]) g[key] = {};
+  const cur = g[key][i] || [null, null];
+  const backToAuto = Math.abs(np - auto[end]) < 6; // magnetic default: near the full span → drop the override
+  cur[end] = backToAuto ? null : np;
+  if (cur[0] == null && cur[1] == null) { delete g[key][i]; if (!Object.keys(g[key]).length) delete g[key]; }
+  else g[key][i] = cur;
+  return backToAuto ? auto[end] : np;
+}
+
+/** 2D snap fodder from resolved geometry: every grid line as a segment (its OWN span) + every
+ *  real intersection (both lines actually reach the crossing) as a point. */
+export function gridSnapGeom(geo) {
+  const segs = [], pts = [];
+  for (const l of geo.v) segs.push([[l.x, l.lo], [l.x, l.hi]]);
+  for (const l of geo.h) segs.push([[l.lo, l.y], [l.hi, l.y]]);
+  for (const a of geo.v) for (const b of geo.h) {
+    if (b.y >= a.lo && b.y <= a.hi && a.x >= b.lo && a.x <= b.hi) pts.push([a.x, b.y]);
+  }
+  return { segs, pts };
+}
+
+/**
+ * 3D snap candidates (scene mm, Z-up — same map as steel-3d-core dispToMm: mmX = x·k, mmY = -y·k).
+ * Emitted PLAN-ONLY on purpose: 'grid-line' / 'grid-int' snap X/Y and keep the dragged Z, so a grid
+ * can never yank a member off its elevation (candidatePoint in steel-3d-core honors that).
+ */
+export function gridCandidates3d(g, ptPerFt) {
+  if (!g || !g.on) return [];
+  const geo = gridGeometry(g, ptPerFt);
+  const k = mmPerPx(ptPerFt);
+  const out = [];
+  for (const l of geo.v) out.push({ type: 'grid-line', a: [l.x * k, -l.hi * k, 0], b: [l.x * k, -l.lo * k, 0], fromId: 'grid-' + l.label });
+  for (const l of geo.h) out.push({ type: 'grid-line', a: [l.lo * k, -l.y * k, 0], b: [l.hi * k, -l.y * k, 0], fromId: 'grid-' + l.label });
+  for (const a of geo.v) for (const b of geo.h) {
+    if (b.y >= a.lo && b.y <= a.hi && a.x >= b.lo && a.x <= b.hi) out.push({ type: 'grid-int', p: [a.x * k, -b.y * k, 0], fromId: 'grid-' + a.label + '/' + b.label });
+  }
+  return out;
+}
+
+/**
+ * Slide one grid line to a new display position (the editor's direct-manipulation drag).
+ * axis 'v' = a vertical line (position = display x), 'h' = horizontal (display y). Mutates g:
+ * clamps between neighbours (1" minimum bay — a drag can never reorder lines or scramble labels),
+ * rebases the origin when the FIRST line moves (the other lines keep their world positions), and
+ * rewrites the spacing string with offsets snapped to 1/16". Returns the clamped position (px),
+ * or null when the grid/axis has no such line.
+ * `base` (optional) = the axis's line positions captured at DRAG START — pass it on every move of
+ * one continuous drag so the string is quantized ONCE from the originals; re-deriving from the
+ * just-written string each mousemove lets 1/16" rounding creep onto lines that never moved.
+ */
+export function moveGridLine(g, ptPerFt, axis, i, np, base) {
+  const geo = gridGeometry(g, ptPerFt);
+  const k = mmPerPx(ptPerFt);
+  const snap16 = (mm) => Math.round(mm / (IN_MM / 16)) * (IN_MM / 16);
+  const MIN = IN_MM / k; // 1" in display px
+  if (axis === 'v') {
+    if (!geo.v[i] && !(base && base[i] != null)) return null;
+    const xs = base ? base.slice() : geo.v.map((l) => l.x); // ascending
+    np = Math.max(i > 0 ? xs[i - 1] + MIN : -Infinity, Math.min(i < xs.length - 1 ? xs[i + 1] - MIN : Infinity, np));
+    xs[i] = np;
+    g.origin[0] = xs[0];
+    g.x = formatSpacings(xs.map((x) => snap16((x - xs[0]) * k)));
+  } else {
+    if (!geo.h[i] && !(base && base[i] != null)) return null;
+    const ys = base ? base.slice() : geo.h.map((l) => l.y); // bottom→up: DESCENDING display y (h[0] = the origin line)
+    np = Math.max(i < ys.length - 1 ? ys[i + 1] + MIN : -Infinity, Math.min(i > 0 ? ys[i - 1] - MIN : Infinity, np));
+    ys[i] = np;
+    g.origin[1] = ys[0];
+    g.y = formatSpacings(ys.map((y) => snap16((ys[0] - y) * k)));
+  }
+  return np;
+}
+
+// ---- grid detection from the DRAWING itself (the steel filter's per-sheet elements) ----
+// CAD PDFs draw each dash of a dash-dot grid line as its own tiny segment, and the bubble labels are
+// usually outlined text (not machine-readable). So detection is structural: bucket collinear
+// axis-aligned segments into long "line fields", then ANCHOR each candidate to a grid bubble — a
+// circle at the line's end (kind 'circle', emitted by the reader's PDF pass) or a short label-like
+// text span there. Anchoring is what separates grid lines from borders/leaders/hatch. When a text
+// layer exists the bubble labels come through verbatim (incl. 5.1 / K.1 style inserts).
+
+const _seg = (e) => {
+  const s = e.x1 != null
+    ? [+e.x1, +e.y1, +e.x2, +e.y2]
+    : (() => { const m = /M\s*(-?[\d.]+)[\s,]+(-?[\d.]+)\s*L\s*(-?[\d.]+)[\s,]+(-?[\d.]+)/.exec(e.d || ''); return m ? [+m[1], +m[2], +m[3], +m[4]] : null; })();
+  return s && s.every(isFinite) ? s : null; // a half-formed element must not poison the bbox with NaN
+};
+
+/** Looks like a grid label: "1", "12", "5.1", "A", "AB", "K.1", "F.2". */
+export function gridLabelLike(t) {
+  return /^([A-Z]{1,2}|\d{1,3})(\.\d)?$/.test(String(t == null ? '' : t).trim());
+}
+
+/**
+ * Detect the structural grid in a sheet's drawing elements (display space).
+ * elements: filter-style [{kind:'line', d|x1..y2}, {kind:'circle', cx,cy,r}, {kind:'text', text,bbox}].
+ * Returns { grid, info:{ v, h, anchored:'circles'|'text'|'geometry', labeled } } or null.
+ */
+export function gridFromDrawing(elements, ptPerFt) {
+  const k = mmPerPx(ptPerFt);
+  const circles = [], texts = [];
+  const vb = new Map(), hb = new Map(); // rounded pos -> { lo, hi, ink, n, sum }
+  let bx0 = Infinity, by0 = Infinity, bx1 = -Infinity, by1 = -Infinity;
+  const bucket = (map, pos, lo, hi) => {
+    const key = Math.round(pos / 2) * 2; // 2px cells; near-misses merge below
+    let b = map.get(key);
+    if (!b) map.set(key, b = { lo, hi, ink: 0, n: 0, sum: 0 });
+    b.lo = Math.min(b.lo, lo); b.hi = Math.max(b.hi, hi);
+    b.ink += hi - lo; b.n++; b.sum += pos;
+  };
+  for (const e of elements || []) {
+    if (e.kind === 'circle' && e.r > 3) { circles.push(e); continue; }
+    if (e.kind === 'text' && gridLabelLike(e.text) && Array.isArray(e.bbox)) { texts.push(e); continue; }
+    if (e.kind !== 'line') continue;
+    const s = _seg(e);
+    if (!s) continue;
+    const [x1, y1, x2, y2] = s;
+    bx0 = Math.min(bx0, x1, x2); bx1 = Math.max(bx1, x1, x2);
+    by0 = Math.min(by0, y1, y2); by1 = Math.max(by1, y1, y2);
+    const dx = Math.abs(x2 - x1), dy = Math.abs(y2 - y1);
+    if (dx <= 1.2 && dy > 0.4) bucket(vb, (x1 + x2) / 2, Math.min(y1, y2), Math.max(y1, y2));
+    else if (dy <= 1.2 && dx > 0.4) bucket(hb, (y1 + y2) / 2, Math.min(x1, x2), Math.max(x1, x2));
+  }
+  if (!isFinite(bx0)) return null;
+  const W = bx1 - bx0, H = by1 - by0;
+  // Grid bubbles line up: the labels of one direction share a row (v-lines) or a column (h-lines)
+  // along the sheet edge. Scattered same-size circles (section/detail callouts) don't. So anchors
+  // are only circles/texts belonging to a COLLINEAR cluster of ≥3 — that's the discriminator that
+  // makes the detector precise on real sheets.
+  const clusterBy = (items, coord) => { // collinear runs of ≥3, kept as separate clusters
+    const sorted = items.map((it) => ({ it, c: coord(it) })).sort((a, b) => a.c - b.c);
+    const out = [];
+    let run = [];
+    const flush = () => { if (run.length >= 3) out.push(run.map((r) => r.it)); run = []; };
+    for (const s of sorted) {
+      if (run.length && s.c - run[run.length - 1].c > 8) flush();
+      run.push(s);
+    }
+    flush();
+    return out;
+  };
+  const textC = (t) => ({ cx: (t.bbox[0] + t.bbox[2]) / 2, cy: (t.bbox[1] + t.bbox[3]) / 2, r: Math.max(t.bbox[2] - t.bbox[0], t.bbox[3] - t.bbox[1]) * 0.9, text: t.text.trim() });
+  const vClusters = [...clusterBy(circles, (c) => c.cy), ...clusterBy(texts.map(textC), (c) => c.cy)]; // bubble ROW → anchors vertical lines
+  const hClusters = [...clusterBy(circles, (c) => c.cx), ...clusterBy(texts.map(textC), (c) => c.cx)]; // bubble COLUMN → anchors horizontal lines
+  const labelIn = (c) => {
+    if (c.text) return c.text;
+    for (const t of texts) {
+      const tc = textC(t);
+      if (Math.hypot(tc.cx - c.cx, tc.cy - c.cy) < c.r) return tc.text;
+    }
+    return '';
+  };
+  // Binding rule (measured on a real sheet): a grid line AIMS at its bubble's centre (across-offset
+  // ≈ 0, impostor parallels sit ≥4px off) and STOPS at the bubble's edge (end-gap ≈ r; impostors
+  // 1.3r–2r). One line per bubble, best aim wins. A cluster of circles only counts as a bubble
+  // row/column when most of its members bind — scattered callout circles that happen to share a
+  // coordinate bind almost nothing and drop out wholesale.
+  const harvest = (map, vertical) => {
+    const clusters = vertical ? vClusters : hClusters;
+    if (!clusters.length) return [];
+    // permissive floor: partial grid lines (an insert like 5.1 covering one wing) are real; the
+    // edge-contact binding below is strict enough that short leaders don't survive it
+    const minSpan = (vertical ? H : W) * 0.15;
+    const fields = [];
+    for (const [, b] of map) {
+      if (b.hi - b.lo >= minSpan) fields.push({ pos: b.sum / b.n, lo: b.lo, hi: b.hi });
+    }
+    const cands = [];
+    for (const cluster of clusters) {
+      const bound = [];
+      for (const c of cluster) {
+        const across = vertical ? c.cx : c.cy, along = vertical ? c.cy : c.cx;
+        let best = null, bestD = c.r * 0.35;
+        for (const f of fields) {
+          const gap = Math.min(Math.abs(along - f.lo), Math.abs(along - f.hi));
+          if (gap < c.r * 0.4 || gap > c.r * 1.6) continue; // the line stops AT the bubble edge (~r), not inside/far away
+          const d = Math.abs(f.pos - across);
+          if (d < bestD) { bestD = d; best = f; }
+        }
+        if (best) bound.push({ pos: best.pos, lo: best.lo, hi: best.hi, label: labelIn(c) });
+      }
+      if (bound.length >= 3 && bound.length >= cluster.length * 0.5) cands.push(...bound);
+    }
+    cands.sort((p, q) => p.pos - q.pos);
+    // the same physical line anchored from both ends lands in the same 2px bucket → merge only
+    // near-identical positions (3px). A wider window would swallow genuinely close insert lines
+    // (a 5.1/5.2-style pair can sit a few px apart on a small-scale sheet).
+    const merged = [];
+    for (const c of cands) {
+      const last = merged[merged.length - 1];
+      if (last && c.pos - last.pos < 3) { if (!last.label && c.label) last.label = c.label; }
+      else merged.push({ ...c });
+    }
+    return merged;
+  };
+  const v = harvest(vb, true), h = harvest(hb, false);
+  if ((v.length < 2 && h.length < 2) || v.length > 40 || h.length > 40) return null; // nothing grid-like, or garbage-in
+  const snap16 = (mm) => Math.round(mm / (IN_MM / 16)) * (IN_MM / 16);
+  const origin = [v.length ? v[0].pos : bx0, h.length ? h[h.length - 1].pos : by1]; // left-most × bottom-most
+  const xOff = v.map((l) => snap16((l.pos - origin[0]) * k));
+  const yOff = h.map((l) => snap16((origin[1] - l.pos) * k)).reverse(); // up the sheet, ascending
+  const labeled = [...v, ...h].length > 0 && [...v, ...h].every((l) => l.label);
+  const grid = {
+    on: true, origin,
+    x: formatSpacings(xOff), y: formatSpacings(yOff), z: '0',
+    labels_x: labeled ? v.map((l) => l.label).join(' ') : '',
+    labels_y: labeled ? h.map((l) => l.label).reverse().join(' ') : '',
+    ext: 5 * FT_MM,
+  };
+  // extension: how far lines overhang the perpendicular family (to reach their bubbles)
+  const overhang = [];
+  if (v.length && h.length) {
+    const hTop = Math.min(...h.map((l) => l.pos)), hBot = Math.max(...h.map((l) => l.pos));
+    for (const l of v) { overhang.push(Math.max(0, hTop - l.lo)); overhang.push(Math.max(0, l.hi - hBot)); }
+  }
+  const ov = overhang.filter((o) => o > 0).sort((a, b) => a - b);
+  if (ov.length) grid.ext = Math.min(Math.max(snap16(ov[Math.floor(ov.length / 2)] * k), 2 * FT_MM), 20 * FT_MM);
+  return { grid, info: { v: v.length, h: h.length, anchored: circles.length ? 'circles' : (texts.length ? 'text' : 'geometry'), labeled } };
+}
+
+/**
+ * Propose a grid from the columns on a plan (display space): cluster distinct column Xs and Ys
+ * (150 mm tolerance), origin = the bottom-left intersection, spacings snapped to the nearest 1/2"
+ * so the strings read clean. Falls back to null when there are no columns (caller uses defaultGrid).
+ */
+export function inferGrid(members, ptPerFt) {
+  const k = mmPerPx(ptPerFt), tolPx = 150 / k;
+  const xs = [], ys = [];
+  for (const m of members || []) {
+    if (!m || m.role !== 'column' || !Array.isArray(m.wp) || !m.wp[0]) continue;
+    xs.push(m.wp[0][0]); ys.push(m.wp[0][1]);
+  }
+  if (!xs.length) return null;
+  const cluster = (vals) => {
+    const sorted = [...vals].sort((a, b) => a - b), out = [];
+    let bucket = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+      if (sorted[i] - bucket[bucket.length - 1] <= tolPx) bucket.push(sorted[i]);
+      else { out.push(bucket.reduce((s, v) => s + v, 0) / bucket.length); bucket = [sorted[i]]; }
+    }
+    out.push(bucket.reduce((s, v) => s + v, 0) / bucket.length);
+    return out;
+  };
+  const snapHalfIn = (mm) => Math.round(mm / (IN_MM / 2)) * (IN_MM / 2);
+  const cx = cluster(xs), cy = cluster(ys);
+  const origin = [cx[0], cy[cy.length - 1]]; // left-most line × bottom-most (display y-down) line
+  const xOff = cx.map((x) => snapHalfIn((x - origin[0]) * k));
+  const yOff = cy.map((y) => snapHalfIn((origin[1] - y) * k)).reverse(); // up the sheet, ascending
+  return { on: true, origin, x: formatSpacings(xOff), y: formatSpacings(yOff), z: '0', labels_x: '', labels_y: '', ext: 5 * FT_MM };
+}