@floless/app 0.61.0 → 0.63.0

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 };
+}

package/dist/web/steel-3d-core.js

@@ -98,8 +98,9 @@ export function elevationLevels(members, ptPerFt, defaultTosMm, excludeId) {
   return [...set].sort((a, b) => a - b);
 }
 
-// Lower wins when two candidates are both within tolerance.
-const PRECEDENCE = { vertex: 0, intersection: 1, midpoint: 2, centerline: 3, 'vertical-axis': 4, 'grid-line': 5, level: 1 };
+// Lower wins when two candidates are both within tolerance. Grid intersections rank with member
+// intersections (columns land on them); grid lines below member centerlines.
+const PRECEDENCE = { vertex: 0, intersection: 1, 'grid-int': 1, midpoint: 2, centerline: 3, 'vertical-axis': 4, 'grid-line': 5, level: 1 };
 
 function closestOnSeg(p, a, b) {
   const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
@@ -113,7 +114,9 @@ function closestOnSeg(p, a, b) {
 function candidatePoint(c, dragged) {
   if (c.type === 'vertex' || c.type === 'intersection' || c.type === 'midpoint' || c.type === 'level') return c.p; // fixed points
   if (c.type === 'vertical-axis') return [c.p[0], c.p[1], dragged[2]]; // lock plan X/Y to the axis, keep dragged Z
-  return closestOnSeg(dragged, c.a, c.b);                              // centerline / grid-line
+  if (c.type === 'grid-int') return [c.p[0], c.p[1], dragged[2]];      // grid steers PLAN only — never yanks the elevation
+  if (c.type === 'grid-line') { const q = closestOnSeg(dragged, c.a, c.b); return [q[0], q[1], dragged[2]]; }
+  return closestOnSeg(dragged, c.a, c.b);                              // centerline
 }
 
 /**
@@ -136,6 +139,49 @@ export function snapPoint(dragged, candidates, toScreen, tolPx) {
   return best ? { snapped: bestPt, candidate: best } : { snapped: dragged, candidate: null };
 }
 
+// ---- working-plane math (CAD copy/move epic §6) — pure vector helpers, scene-mm space ----
+const _dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const _cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const _norm = (a) => { const L = Math.hypot(a[0], a[1], a[2]); return L > 1e-12 ? [a[0] / L, a[1] / L, a[2] / L] : null; };
+
+/**
+ * Orthonormal in-plane basis {u,v} for a plane normal. xHint (default world-X) projects onto the
+ * plane as U; when the hint is ~parallel to the normal it falls back to world-Y so U never
+ * degenerates. v = n × u keeps the frame right-handed (u × v = n).
+ */
+export function planeBasis(normal, xHint) {
+  const n = _norm(normal) || [0, 0, 1];
+  let u = null;
+  for (const hint of [xHint, [1, 0, 0], [0, 1, 0]]) {
+    if (!hint) continue;
+    const d = _dot(hint, n);
+    u = _norm([hint[0] - d * n[0], hint[1] - d * n[1], hint[2] - d * n[2]]);
+    if (u) break;
+  }
+  return { u, v: _cross(n, u) };
+}
+
+/** Project p onto the plane (origin,normal): p − ((p−o)·n̂)n̂ — the nearest on-plane point. */
+export function projectToPlane(p, origin, normal) {
+  const n = _norm(normal) || [0, 0, 1];
+  const d = (p[0] - origin[0]) * n[0] + (p[1] - origin[1]) * n[1] + (p[2] - origin[2]) * n[2];
+  return [p[0] - d * n[0], p[1] - d * n[1], p[2] - d * n[2]];
+}
+
+/** Plane from 3 picked points (Tekla flow): origin=a, xAxis toward b, normal = x̂ × (c−a). null when degenerate. */
+export function planeFrom3Points(a, b, c) {
+  const xAxis = _norm([b[0] - a[0], b[1] - a[1], b[2] - a[2]]);
+  if (!xAxis) return null;
+  const normal = _norm(_cross(xAxis, [c[0] - a[0], c[1] - a[1], c[2] - a[2]]));
+  if (!normal) return null;
+  return { origin: [a[0], a[1], a[2]], xAxis, normal };
+}
+
+/** World vector → components along the plane basis: {du,dv,dn}. Reconstruct via du·u+dv·v+dn·n. */
+export function vecToPlane(vec, u, v, n) {
+  return { du: _dot(vec, u), dv: _dot(vec, v), dn: _dot(vec, n) };
+}
+
 /**
  * 3D dimension geometry (pure). a,b are scene mm [x,y,z]. axis ∈ free|x|y|z.
  * free → the straight segment a→b (valueMm = full 3D distance); x|y|z →