@floless/app 0.44.0 → 0.45.1

package/dist/floless-server.cjs

@@ -52856,7 +52856,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.44.0" : void 0,
+    define: true ? "0.45.1" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -52866,7 +52866,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.44.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.45.1" : void 0 });
 }
 
 // workflow-update.ts
@@ -53850,6 +53850,7 @@ function bakeContractIntoApp(sourcePath, contract) {
   if (idx < 0) throw new Error("no contract-emitting node to bake the contract into");
   doc2.setIn(["nodes", idx, "config", "contract"], contract.type);
   const baked = { ...contract };
+  delete baked.dims3d;
   if (Array.isArray(contract.plans)) {
     baked.plans = contract.plans.map((p) => {
       if (p && typeof p === "object") {

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

@@ -37,7 +37,8 @@
       "additionalProperties": false
     },
     "plans": { "type": "array", "items": { "$ref": "#/$defs/plan" } },
-    "filter": { "$ref": "#/$defs/filter", "description": "Layer/thickness/colour filter pre-stage dataset from one compose-time PyMuPDF pass. The saved selection (per-facet `on` flags + `mode`) scopes which lines the reader binds profile labels to; replaces the length heuristic, fallback when absent. CONFIDENTIAL: `page.bg_b64` is machine-local, never committed." }
+    "filter": { "$ref": "#/$defs/filter", "description": "Layer/thickness/colour filter pre-stage dataset from one compose-time PyMuPDF pass. The saved selection (per-facet `on` flags + `mode`) scopes which lines the reader binds profile labels to; replaces the length heuristic, fallback when absent. CONFIDENTIAL: `page.bg_b64` is machine-local, never committed." },
+    "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": {
     "filter": {
@@ -126,6 +127,13 @@
       "maxItems": 2,
       "description": "An [x,y] pair in display space (or [fx,fy] normalized for bubbles)."
     },
+    "point3": {
+      "type": "array",
+      "items": { "type": "number" },
+      "minItems": 3,
+      "maxItems": 3,
+      "description": "An [x,y,z] point in world-scene mm (Z-up), matching contract-to-scene output."
+    },
     "plan": {
       "type": "object",
       "required": ["sheet", "members"],
@@ -176,6 +184,17 @@
         "rot": { "type": "number", "description": "Local-frame bearing (radians) baked at creation; 0 = global axes. x/y measure along this rotated frame so resetting the plan frame never moves placed dims." }
       }
     },
+    "dim3": {
+      "type": "object",
+      "required": ["id", "a", "b", "axis"],
+      "additionalProperties": true,
+      "properties": {
+        "id": { "type": "string" },
+        "a": { "$ref": "#/$defs/point3", "description": "First snapped anchor, world-scene mm." },
+        "b": { "$ref": "#/$defs/point3", "description": "Second snapped anchor, world-scene mm." },
+        "axis": { "enum": ["free", "x", "y", "z"], "description": "free = 3D distance ‖b-a‖; x|y|z = the component along that world axis. The dim line is drawn axis-aligned for x|y|z." }
+      }
+    },
     "frame": {
       "type": ["object", "null"],
       "description": "Optional per-plan local coordinate frame for skewed framing. null/absent = global axes. Affects only editor ortho-snapping + X/Y dimensions; NOT baked into the lock / 3D / IFC / BOM.",

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

@@ -135,3 +135,22 @@ export function snapPoint(dragged, candidates, toScreen, tolPx) {
   }
   return best ? { snapped: bestPt, candidate: best } : { snapped: dragged, candidate: null };
 }
+
+/**
+ * 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 →
+ * axis-aligned from a, advancing only that one world component to b
+ * (valueMm = that component's length). Returns the drawn endpoints, the
+ * midpoint (where the label sits), and the measured length in mm.
+ */
+export function dim3dGeom(a, b, axis) {
+  const p1 = [a[0], a[1], a[2]];
+  let p2;
+  if (axis === 'x') p2 = [b[0], a[1], a[2]];
+  else if (axis === 'y') p2 = [a[0], b[1], a[2]];
+  else if (axis === 'z') p2 = [a[0], a[1], b[2]];
+  else p2 = [b[0], b[1], b[2]];                       // free (default for any unrecognised axis)
+  const valueMm = Math.hypot(p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]);
+  const mid = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2, (p1[2] + p2[2]) / 2];
+  return { p1, p2, mid, valueMm };
+}

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

@@ -16,7 +16,7 @@
  */
 import * as THREE from 'three';
 import { OrbitControls } from 'three/addons/OrbitControls.js';
-import { snapCandidates, snapPoint, planPointToWp, memberGeometry, elevationLevels } from './steel-3d-core.js';
+import { snapCandidates, snapPoint, planPointToWp, memberGeometry, elevationLevels, dim3dGeom } from './steel-3d-core.js';
 
 let renderer, scene, perspCam, orthoCam, camera, controls, root, api, canvasEl, ro, rafId, grid, raycaster, downXY, lastPick = '(none)';
 let pending = null, dragging = null, marker = null, readout = null; // pending = member gesture; readout = drag dimension overlay
@@ -44,6 +44,18 @@ const SELECT_EMISSIVE = 0x3b82f6;     // --brand: selected members glow blue
 const EP_START = 0xfacc15;            // start endpoint (end 1) — yellow
 const EP_END = 0xf472b6;             // end endpoint (end 2) — magenta
 
+// ---- 3D dimension tool ----
+let dimMode3d = false;            // tool armed
+let dimAxis3d = 'free';           // sticky axis: free | x | y | z
+let dims3dVisibleFlag = true;     // show/hide placed dims
+let dimDraft3d = null;            // { a:[x,y,z] } once the first point is placed (awaiting the 2nd)
+let dimLastAlt = false;           // last-seen Alt state (the hover rAF rebuilds a synthetic event)
+let dims3dGroup = null;           // THREE.Group of placed-dim lines (+ the live preview line)
+let dimPreviewLine = null;        // reused preview line (point 1 → cursor)
+let dimLabelHost = null;          // fixed-position container for label overlays
+const dimLabelPool = [];          // reused <div> labels, one per placed dim, positioned in the loop
+let dimCandidates3d = null;       // snap candidates cached for the active placement gesture
+
 function init(canvas, theApi) {
   if (renderer) return;               // once
   canvasEl = canvas; api = theApi;
@@ -91,6 +103,14 @@ function init(canvas, theApi) {
   readout._type = document.createElement('span'); readout._type.style.color = 'var(--mut,#94a3b8)';
   readout.append(readout._dist, readout._type);
   document.body.appendChild(readout);
+  // 3D dimension tool: a group of placed-dim lines (over the steel) + a live preview line + an HTML
+  // overlay host for the midpoint labels (positioned each frame so they face the camera as screen text).
+  dims3dGroup = new THREE.Group(); scene.add(dims3dGroup);
+  dimPreviewLine = new THREE.Line(new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]), new THREE.LineBasicMaterial({ color: 0x22d3ee }));
+  dimPreviewLine.material.depthTest = false; dimPreviewLine.renderOrder = 997; dimPreviewLine.visible = false; scene.add(dimPreviewLine);
+  dimLabelHost = document.createElement('div');
+  dimLabelHost.style.cssText = 'position:fixed;left:0;top:0;pointer-events:none;z-index:57';
+  document.body.appendChild(dimLabelHost);
   // persistent hover/selection status chip, bottom-centre of the canvas (mirrors the viewer's readout)
   hoverChip = document.createElement('div');
   hoverChip.style.cssText = 'position:fixed;display:none;pointer-events:none;z-index:55;background:var(--panel,#0f172a);color:var(--mut,#94a3b8);border:1px solid var(--line,#334155);border-radius:6px;padding:5px 12px;font:12px system-ui;white-space:nowrap;max-width:60vw;overflow:hidden;text-overflow:ellipsis;box-shadow:0 2px 8px rgba(0,0,0,.45)';
@@ -130,6 +150,7 @@ function loop() {
   rafId = requestAnimationFrame(loop);
   controls.update();
   sizeEndpoints();
+  positionDimLabels();
   renderer.render(scene, camera);
   if (cube) { syncCube(); cube.renderer.render(cube.scene, cube.cam); }
 }
@@ -328,6 +349,7 @@ async function rebuild(fit = false) {
   const sc = await api.fetchScene();   // editor POSTs the current contract to /scene
   if (seq !== rebuildSeq) return;      // a newer rebuild superseded this one → drop the stale scene (no out-of-order apply)
   if (sc) buildFromScene(sc);
+  refreshDims();                       // persisted dims appear + survive edit-rebuilds (re-coloured for the current selection)
 }
 
 // ---- Persp/Ortho + Solid/Wire/X-ray + group visibility (parity with the AWARE viewer) ----
@@ -406,12 +428,40 @@ function onKey(e) {
   if (!renderer || !canvasEl || canvasEl.style.display === 'none') return;     // only when 3D is active
   const ae = document.activeElement; if (ae && /^(INPUT|SELECT|TEXTAREA)$/.test(ae.tagName)) return;
   if ((e.key === ' ' && e.shiftKey) || ((e.key === 'z' || e.key === 'Z') && e.altKey)) { e.preventDefault(); frameSelection(); return; } // zoom-selected (Tekla Shift+Space / viewer Alt+Z)
+  const k = e.key.toLowerCase();
+  // Don't touch the dim tool while a member gesture (drag / box-select) owns the shared marker/readout —
+  // toggling would clear them mid-gesture. The gesture finishes on pointerup; the key is a no-op until then.
+  const midGesture = pending || dragging || boxSel;
+  if (k === 'd' && !e.ctrlKey && !e.metaKey && !e.altKey && !midGesture) { e.preventDefault(); toggleDimTool(); return; } // D arms/disarms the dimension tool
+  if (dimMode3d && !midGesture) {
+    if (k === 'escape') { e.preventDefault(); if (dimDraft3d) { dimDraft3d = null; dimPreviewLine.visible = false; readout.style.display = 'none'; } else toggleDimTool(); return; } // Esc: cancel the in-progress dim, else exit the tool
+    if (k === 'f' || k === 'x' || k === 'y' || k === 'z') { e.preventDefault(); setDimAxis(k === 'f' ? 'free' : k); reflectDimAxisBar(); return; } // sticky axis: Free / X / Y / Z
+  }
   const a = ARROWS[e.key]; if (!a) return;
   const [hx, hy] = a;
   if (e.ctrlKey || e.metaKey) { e.preventDefault(); rotateView(-hx * Math.PI / 12, hy * Math.PI / 12); }  // 15°
   else if (e.shiftKey) { e.preventDefault(); rotateView(-hx * Math.PI / 36, hy * Math.PI / 36); }          // 5°
   else { e.preventDefault(); panView(hx, hy); }                                                            // pan
 }
+// ---- 3D dimension tool controls (driven from the toolbar + the keyboard) ----
+function toggleDimTool() {
+  dimMode3d = !dimMode3d;
+  if (!dimMode3d) { dimDraft3d = null; dimCandidates3d = null; dimPreviewLine.visible = false; marker.visible = false; readout.style.display = 'none'; canvasEl.style.cursor = 'default'; }
+  else { controls.enabled = true; canvasEl.style.cursor = 'crosshair'; }  // show the crosshair on arm, before the first mousemove
+  reflectDimBar();
+  return dimMode3d;
+}
+function setDimAxis(a) { if (['free', 'x', 'y', 'z'].includes(a)) dimAxis3d = a; }
+function dimAxis() { return dimAxis3d; }
+function setDims3dVisible(on) { dims3dVisibleFlag = !!on; refreshDims(); }
+function dims3dVisible() { return dims3dVisibleFlag; }
+function reflectDimBar() {
+  const b = document.getElementById('m3dDim'); if (b) b.classList.toggle('on', dimMode3d);
+  const ax = document.getElementById('m3dDimAxis'); if (ax) ax.style.display = dimMode3d ? 'flex' : 'none';
+  const sh = document.getElementById('m3dDimShow'); if (sh) sh.style.display = dimMode3d ? 'inline-block' : 'none';
+  reflectDimAxisBar();
+}
+function reflectDimAxisBar() { document.querySelectorAll('#m3dDimAxis button').forEach((x) => x.classList.toggle('on', x.dataset.d3axis === dimAxis3d)); }
 // Tekla "set view point": double-click a member → make that point the orbit/zoom pivot.
 function onDblClick(e) {
   camera.updateMatrixWorld(); root.updateMatrixWorld(true);
@@ -479,6 +529,65 @@ function sizeEndpoints() {
   }
 }
 
+// ---- placed 3D dimensions ----
+// Rebuild the placed-dim lines from the editor's dims3d (the single source of truth). Lines render
+// depthTest:false so they're never buried; the selected dim draws amber. Labels are HTML overlays
+// (pool below), so only the line geometry is rebuilt here.
+function refreshDims() {
+  if (!dims3dGroup || !api || !api.getDims3d) return;
+  dimCandidates3d = null;               // a rebuild may follow a member edit → don't keep stale snap targets for the next click
+  for (const c of [...dims3dGroup.children]) { dims3dGroup.remove(c); c.geometry.dispose(); c.material.dispose(); }
+  const dims = api.getDims3d() || [];
+  const sel = api.selDim3d ? api.selDim3d() : null;
+  if (dims3dVisibleFlag) {
+    for (const d of dims) {
+      const g = dim3dGeom(d.a, d.b, d.axis);
+      const col = d.id === sel ? 0xf59e0b : 0x67e8f9;                 // amber (#f59e0b) when selected, else muted cyan-300 — a quieter tint of the 0x22d3ee preview/2D-dim cyan (intentional, not a stray value)
+      const line = new THREE.Line(new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(...g.p1), new THREE.Vector3(...g.p2)]), new THREE.LineBasicMaterial({ color: col }));
+      line.material.depthTest = false; line.renderOrder = 996; line.userData.dimId = d.id;
+      dims3dGroup.add(line);
+    }
+  }
+  syncDimLabels(dims);
+}
+// Keep one themed label div per placed dim (reused across rebuilds). Click selects the dim.
+function syncDimLabels(dims) {
+  while (dimLabelPool.length < dims.length) {
+    const el = document.createElement('div');
+    el.style.cssText = 'position:absolute;transform:translate(-50%,-50%);pointer-events:auto;cursor:pointer;background:var(--panel,#0f172a);color:var(--text,#f8fafc);border:1px solid var(--line,#1e293b);border-radius:4px;padding:2px 6px;font:12px system-ui;white-space:nowrap;box-shadow:0 2px 8px rgba(0,0,0,.5)';
+    el.addEventListener('pointerdown', (e) => { e.stopPropagation(); const id = el._dimId; if (api && api.onSelectDim3d) { api.onSelectDim3d(id); refreshDims(); } });
+    dimLabelHost.appendChild(el); dimLabelPool.push(el);
+  }
+  for (let i = 0; i < dimLabelPool.length; i++) {
+    const el = dimLabelPool[i], d = dims[i];
+    if (!d || !dims3dVisibleFlag) { el.style.display = 'none'; el._dimId = null; el._mid = null; continue; }
+    el._dimId = d.id;
+    const g = dim3dGeom(d.a, d.b, d.axis);
+    el.textContent = api.fmtLen ? api.fmtLen(g.valueMm) : (g.valueMm / 304.8).toFixed(2) + ' ft';
+    el.style.borderColor = d.id === (api.selDim3d && api.selDim3d()) ? '#f59e0b' : 'var(--line,#1e293b)';
+    el.style.display = 'block'; el._mid = g.mid;
+  }
+}
+// project each visible label's 3D midpoint → screen px (called from the render loop). Hidden when the
+// midpoint is behind the camera (project z>1).
+function positionDimLabels() {
+  if (!dimLabelHost || canvasEl.style.display === 'none') { if (dimLabelHost) dimLabelHost.style.display = 'none'; return; }
+  dimLabelHost.style.display = 'block';
+  for (const el of dimLabelPool) {
+    if (el.style.display === 'none' || !el._mid) continue;
+    const [mx, my, mz] = el._mid;
+    const v = new THREE.Vector3(mx, my, mz).project(camera);
+    // hide when the midpoint is behind the camera (z>1) OR outside the canvas frustum (|x|,|y|>1):
+    // the labels are pointer-events:auto, so an off-canvas one would float over and intercept the
+    // surrounding editor UI (the inspector panel / toolbar).
+    if (v.z > 1 || v.x < -1 || v.x > 1 || v.y < -1 || v.y > 1) { el.style.visibility = 'hidden'; continue; }
+    const rect = canvasEl.getBoundingClientRect();
+    el.style.left = (rect.left + (v.x * 0.5 + 0.5) * rect.width) + 'px';
+    el.style.top = (rect.top + (-v.y * 0.5 + 0.5) * rect.height) + 'px';
+    el.style.visibility = 'visible';
+  }
+}
+
 // ---- ViewCube (parity with AWARE viewer-3d) — a small labelled cube; a face click snaps the view ----
 const CUBE_FACES = [
   { label: 'RIGHT', view: 'right' }, { label: 'LEFT', view: 'left' },   // +X, -X
@@ -593,8 +702,40 @@ function pxToWorldAt(px, pos) {
 }
 const markerSize = () => pxToWorldAt(8, marker && marker.position); // snap marker ~8px at its own depth
 
+// The snapped 3D point under the cursor for the dim tool. `anchor` (point 1) is set during the 2nd
+// pick: with Alt held the result is locked to the anchor's plan X/Y (a pure vertical / Z measurement,
+// the elevation-drag feel). Returns { p:[x,y,z], type } (type = the snap label, or null).
+function dimPointAt(e, anchor) {
+  if (anchor && e.altKey) {
+    const hit = rayToVerticalPlane(e.clientX, e.clientY, anchor); if (!hit) return null;
+    return { p: [anchor[0], anchor[1], hit[2]], type: 'vertical' };
+  }
+  let id = null; try { id = pickAt(e.clientX, e.clientY); } catch { id = null; }
+  let planeZ = sceneBox.isEmpty() ? 0 : sceneBox.min.z;
+  if (id) { const m = members().find((x) => x.id === id); if (m) { const g = memberGeometry(m, api.ptPerFt(), api.defaultTosMm()); planeZ = (g.line[0][2] + g.line[1][2]) / 2; } }
+  const hit = rayToPlane(e.clientX, e.clientY, planeZ); if (!hit) return null;
+  if (!dimCandidates3d) dimCandidates3d = snapCandidates(members(), api.ptPerFt(), api.defaultTosMm());
+  const r = snapPoint([hit[0], hit[1], hit[2]], dimCandidates3d, toScreen, SNAP_TOL_PX);
+  return { p: r.candidate ? r.snapped : hit, type: r.candidate ? r.candidate.type : null };
+}
+// The axis to measure on: Alt held during the 2nd pick forces a pure-vertical (Z) measurement,
+// overriding the sticky axis (else a sticky X/Y would collapse the Alt-locked point to zero length).
+function dimEffectiveAxis(alt) { return alt && dimDraft3d ? 'z' : dimAxis3d; }
+
 function onDown(e) {
   if (e.button !== 0) return;                 // RIGHT/MIDDLE → OrbitControls (orbit/pan)
+  if (dimMode3d) {                            // 2-click dimension placement (not a drag): pick A, then B → place
+    e.stopPropagation(); controls.enabled = true;
+    const r = dimPointAt(e, dimDraft3d && dimDraft3d.a); if (!r) return;
+    if (!dimDraft3d) { dimDraft3d = { a: r.p }; dimCandidates3d = null; }
+    else {
+      const a = dimDraft3d.a, b = r.p, axis = dimEffectiveAxis(e.altKey);
+      const g = dim3dGeom(a, b, axis);
+      dimDraft3d = null; dimPreviewLine.visible = false; marker.visible = false; readout.style.display = 'none'; dimCandidates3d = null;
+      if (g.valueMm > 1 && api && api.onAddDim3d) api.onAddDim3d({ id: api.newDim3dId(), a, b, axis });
+    }
+    return;
+  }
   downXY = [e.clientX, e.clientY];
   let id = null; try { id = pickAt(e.clientX, e.clientY); } catch { id = null; }
   // Geometry-edit mode (Trim/Extend or Split armed in the inspector): a click does the edit, no drag.
@@ -780,10 +921,25 @@ function closestOnSeg3(p, a, b) {
 // ---- hover: cursor + readout chip (no drag in progress) ----
 function onHoverMove(e) {
   lastHoverXY = [e.clientX, e.clientY];
+  dimLastAlt = e.altKey;                       // remembered so the rAF body can rebuild a synthetic event
   if (hoverRAF || pending || dragging || boxSel) return;
   hoverRAF = requestAnimationFrame(() => {
     hoverRAF = 0;
     if (!lastHoverXY || pending || dragging || boxSel) return;
+    if (dimMode3d) {                           // dim tool: snap marker + live preview line + readout (no member hover)
+      canvasEl.style.cursor = 'crosshair';
+      const ev = { clientX: lastHoverXY[0], clientY: lastHoverXY[1], altKey: dimLastAlt };
+      const r = dimPointAt(ev, dimDraft3d && dimDraft3d.a);
+      if (r) { marker.position.set(...r.p); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+      if (dimDraft3d && r) {
+        const g = dim3dGeom(dimDraft3d.a, r.p, dimEffectiveAxis(dimLastAlt));
+        dimPreviewLine.geometry.setFromPoints([new THREE.Vector3(...g.p1), new THREE.Vector3(...g.p2)]); dimPreviewLine.visible = true;
+        readout._dist.textContent = api.fmtLen ? api.fmtLen(g.valueMm) : (g.valueMm / 304.8).toFixed(2) + ' ft';
+        readout._type.textContent = r.type ? ' · ' + r.type : (dimLastAlt ? ' ↕' : '');
+        readout.style.left = (lastHoverXY[0] + 14) + 'px'; readout.style.top = (lastHoverXY[1] + 14) + 'px'; readout.style.display = 'block';
+      } else { dimPreviewLine.visible = false; if (!dimDraft3d) readout.style.display = 'none'; }
+      return;
+    }
     let ep = null; try { ep = pickEndpoint(lastHoverXY[0], lastHoverXY[1]); } catch { ep = null; }
     if (ep) { // over an end node → ring + move cursor; keep its member's dots shown
       hoverEp = ep; canvasEl.style.cursor = 'move';
@@ -810,8 +966,12 @@ function updateStatusChip() {
   hoverChip.style.display = canvasEl.style.display === 'none' ? 'none' : 'block';
 }
 
-function show() { if (controls) controls.enabled = true; if (canvasEl) { canvasEl.style.display = 'block'; resize(); } if (!rafId) loop(); updateStatusChip(); } // resume the render loop (reset orbit in case a gesture was stranded by a mid-drag hide)
-function hide() { if (canvasEl) canvasEl.style.display = 'none'; if (hoverChip) hoverChip.style.display = 'none'; if (rafId) { cancelAnimationFrame(rafId); rafId = null; } }
+function show() { if (controls) controls.enabled = true; if (canvasEl) { canvasEl.style.display = 'block'; resize(); } if (!rafId) loop(); updateStatusChip(); refreshDims(); } // resume the render loop (reset orbit in case a gesture was stranded by a mid-drag hide)
+function hide() {
+  if (dimMode3d) toggleDimTool();              // disarm the dim tool + sync its toolbar (no stale draft/armed state on return)
+  if (dimLabelHost) dimLabelHost.style.display = 'none'; // the loop that hides labels is about to stop — hide synchronously so none are stranded
+  if (canvasEl) canvasEl.style.display = 'none'; if (hoverChip) hoverChip.style.display = 'none'; if (rafId) { cancelAnimationFrame(rafId); rafId = null; }
+}
 function isReady() { return built; }
 
 function dispose() {
@@ -822,14 +982,18 @@ function dispose() {
   window.removeEventListener('pointermove', onMove);
   window.removeEventListener('pointerup', onUp);
   window.removeEventListener('keydown', onKey);
-  for (const ovl of [readout, hoverChip, rubber]) if (ovl && ovl.parentNode) ovl.parentNode.removeChild(ovl);
+  for (const ovl of [readout, hoverChip, rubber, dimLabelHost]) if (ovl && ovl.parentNode) ovl.parentNode.removeChild(ovl);
+  dimLabelHost = null; dimLabelPool.length = 0;
   if (cube) {
     cube.scene.traverse((o) => { if (o.geometry) o.geometry.dispose(); const mm = Array.isArray(o.material) ? o.material : (o.material ? [o.material] : []); for (const m of mm) { if (m.map) m.map.dispose(); m.dispose(); } });
     cube.renderer.dispose(); if (cube.renderer.domElement.parentNode) cube.renderer.domElement.parentNode.removeChild(cube.renderer.domElement); cube = null;
   }
   if (epGeom) epGeom.dispose(); if (epMatStart) epMatStart.dispose(); if (epMatEnd) epMatEnd.dispose();
-  for (const o of [epRing, epPreview, refGroup]) if (o) { if (o.geometry) o.geometry.dispose(); if (o.material) o.material.dispose(); }
+  if (dims3dGroup) { if (scene) scene.remove(dims3dGroup); for (const c of dims3dGroup.children) { c.geometry.dispose(); c.material.dispose(); } } // placed-dim lines
+  if (dimPreviewLine && scene) scene.remove(dimPreviewLine);
+  for (const o of [epRing, epPreview, refGroup, dimPreviewLine]) if (o) { if (o.geometry) o.geometry.dispose(); if (o.material) o.material.dispose(); }
   epGeom = epMatStart = epMatEnd = epRing = epPreview = refGroup = null;
+  dims3dGroup = dimPreviewLine = null;
   clearRoot();
   if (renderer) renderer.dispose();
   renderer = scene = camera = perspCam = orthoCam = controls = root = api = canvasEl = ro = null; built = false;
@@ -879,5 +1043,8 @@ window.Steel3DView = {
   setProjection, projection, setDisplayMode, mode: () => displayMode, frameAll, frameSelection, applyView,
   setRefLine, refLine: () => refLineOn,
   toggleGroup, soloToggle, showAllGroups, groupState, getGroups,
+  toggleDimTool, setDimAxis, dimAxis, setDims3dVisible, dims3dVisible, refreshDims,
+  dims3dCount: () => (api && api.getDims3d ? (api.getDims3d() || []).length : 0),
+  dim3dLabelOf: (i) => { const el = dimLabelPool[i]; if (!el || el.style.display === 'none') return null; const r = el.getBoundingClientRect(); return { x: r.left + r.width / 2, y: r.top + r.height / 2, text: el.textContent }; },
   debug, probe, screenOf, centerOf,
 };

package/dist/web/steel-editor.html

@@ -242,6 +242,9 @@
    <div class=seg-group id=m3dMode title="Display mode"><button data-mode=solid class=on>Solid</button><button data-mode=wire>Wire</button><button data-mode=xray>X-ray</button></div>
    <button id=m3dFit title="Fit all to view">Fit</button>
    <button id=m3dRef title="Show the reference line (work-line between the end points) for every member">Ref line</button>
+   <button id=m3dDim title="3D Dimension tool (D) — click two snapped points to measure. Free (3D), or X/Y/Z to lock an axis; hold Alt for a vertical (Z) measurement.">⊢ Dimension</button>
+   <div class=seg-group id=m3dDimAxis title="Measurement axis" style="display:none"><button data-d3axis=free class=on title="Free 3D measurement (F)">Free</button><button data-d3axis=x title="Lock to the X axis (X)">X</button><button data-d3axis=y title="Lock to the Y axis (Y)">Y</button><button data-d3axis=z title="Lock to the Z / vertical axis (Z); hold Alt while picking for a quick vertical">Z</button></div>
+   <button id=m3dDimShow title="Toggle visibility of placed 3D dimensions" style="display:none">Hide dims</button>
   </div>
   <div id=m3dLegend></div>
   <div id=m3dCube title="Click a face for that view · drag the scene with the right button to orbit"></div>
@@ -345,6 +348,7 @@ async function boot() {
   PAL = (Array.isArray(C.palette) && C.palette.length) ? C.palette : DEFAULT_PAL; WT = C.weights || {};
   C.custom_details = C.custom_details || {};
   C.profile_colors = C.profile_colors || {};
+  if(!Array.isArray(C.dims3d))C.dims3d=[];   // model-global draft-only 3D dimensions
   main();
   // SSE: listen for external contract writebacks (e.g. the terminal AI PUT a revision).
   // We open our own EventSource to the same /api/events endpoint as the main app.
@@ -426,6 +430,7 @@ let dimMode=false, dimDraft=null, dimAxis='free', selDimIds=new Set(), dimsVisib
 let csaxisMode=false, csDraft=null;   // Local coordinate system "set axes" tool: armed flag + in-progress origin [x,y] (null until click 1). P.frame={o,u} holds the committed local frame (null = global).
 let dimChain=false, dimChainPrev=null, dimSeq=0;   // chained "continuous" dimensioning: toggle, the running {point,axis,off,rot}, and a counter for unique ids on rapid clicks
 let dimSplitMode=false;   // "add split point" mode on a selected dim — each click inserts a point and splits the dim segment under it into two
+let sel3dDimId=null;   // the currently-selected 3D dimension id (model-global; 3D view highlights it, Delete removes it)
 let selIds=new Set();
 let undo=[], redo=[];
 const byId=id=>P.members.find(m=>m.id===id);
@@ -477,14 +482,16 @@ function syncDefaults(){for(const m of P.members){ensureMeta(m);
  else for(const en of m.ends)if(en.tosDef!==false&&defaultTOS!=null)en.tos=defaultTOS;}}
 const autofillTOS=syncDefaults;
 // profs is per-plan — computed in setPlan()
-function snapshot(){return JSON.stringify({members:P.members,dims:P.dims||[],frame:P.frame||null});}
+function snapshot(){return JSON.stringify({members:P.members,dims:P.dims||[],frame:P.frame||null});}  // per-plan; dims3d is model-global and rides its OWN persistence (NOT this plan-scoped snapshot — see refreshDims3d)
+function refreshDims3d(){if(window.Steel3DView&&window.Steel3DView.refreshDims)window.Steel3DView.refreshDims();}  // repaint the 3D dim lines/labels from C.dims3d
 function pushUndo(prev){undo.push(prev);if(undo.length>200)undo.shift();redo.length=0;scheduleSave();}
 function apply(json){const d=JSON.parse(json);
  if(Array.isArray(d))P.members=d;                                  // legacy member-only snapshot (e.g. the auto-dedupe push in setPlan)
- else{P.members=d.members||[];if(Array.isArray(d.dims))P.dims=d.dims;if('frame' in d)P.frame=d.frame||null;}  // 'frame' present → restore (incl. null = global); absent (legacy snapshot) leaves it alone
+ else{P.members=d.members||[];if(Array.isArray(d.dims))P.dims=d.dims;if('frame' in d)P.frame=d.frame||null;}  // 'frame' present → restore (incl. null = global); absent (legacy snapshot) leaves it alone. dims3d is NOT restored here — it's model-global and undo is per-plan.
  updCS();
  selIds=new Set([...selIds].filter(id=>byId(id)));
  selDimIds.forEach(id=>{if(!(P.dims||[]).some(x=>x.id===id))selDimIds.delete(id);});  // drop any dim selection the undo removed
+ if(sel3dDimId&&!(C.dims3d||[]).some(x=>x.id===sel3dDimId))sel3dDimId=null;  // drop a stale 3D-dim selection
  dimDraft=null;dimChainPrev=null;dimPrevClear();   // undo/redo changed geometry under the tool → abandon any in-progress dim placement / chain (else the chain head points at a removed segment)
  scheduleSave();render();sync3D();}
 function doUndo(){if(!undo.length)return;redo.push(snapshot());apply(undo.pop());}
@@ -500,7 +507,7 @@ function setSaved(state,msg){const el=document.getElementById('saveStat');if(!el
  else if(state==='err'){el.classList.add('err');el.textContent='Save failed';}
  else el.textContent=msg||'Auto-save on';}
 function persist(){try{localStorage.setItem(LSKEY,JSON.stringify({sig:dataSig(),ts:Date.now(),active:C.active,
-   custom_details:C.custom_details, profile_colors:C.profile_colors, target_confidence:C.target_confidence,
+   custom_details:C.custom_details, profile_colors:C.profile_colors, target_confidence:C.target_confidence, dims3d:C.dims3d,
    plans:C.plans.map(p=>({sheet:p.sheet,members:p.members,default_tos:p.default_tos,details:p.details,dims:p.dims,frame:p.frame||null}))}));setSaved('ok');}catch(e){setSaved('err');console.error('local autosave failed',e);}}
 // --- server-side draft save: PUT the FULL contract C — this is the copy Approve bakes.
 // localStorage (persist) stays the instant per-browser draft cache; this is the durable one.
@@ -531,6 +538,7 @@ function restoreSaved(){try{const raw=localStorage.getItem(LSKEY);if(!raw)return
    if(d.profile_colors)C.profile_colors=d.profile_colors;
    if(d.target_confidence!=null)C.target_confidence=d.target_confidence;
    C.plans.forEach(p=>{const s=by[p.sheet];if(s){if(Array.isArray(s.members))p.members=s.members;if(s.default_tos!=null)p.default_tos=s.default_tos;if(Array.isArray(s.details))p.details=s.details;if(Array.isArray(s.dims))p.dims=s.dims;if('frame' in s)p.frame=s.frame||null;p.autofilled=true;}});
+   if(Array.isArray(d.dims3d))C.dims3d=d.dims3d;   // restore model-global 3D dims from the local draft
    if(d.active!=null)C.active=d.active;return true;}catch(e){console.warn('discarding corrupt local draft',e);return false;}}
 function updUR(){document.getElementById('undoB').disabled=!undo.length;document.getElementById('redoB').disabled=!redo.length;}
 function colorFor(p){if(C.profile_colors[p])return C.profile_colors[p];let i=profs.indexOf(p);return PAL[((i%PAL.length)+PAL.length)%PAL.length];}
@@ -1242,10 +1250,11 @@ addEventListener('keydown',e=>{
  if(e.key==='Escape'&&dimMode){if(dimChainPrev){dimChainPrev=null;dimPrevClear();}else if(dimDraft){dimDraft=null;dimPrevClear();}else{dimMode=false;setDimMode();}render();return;}  // Esc: end the chain → drop the in-progress dim → exit the tool
  if(e.key==='Escape'&&selDimIds.size){if(dimSplitMode){dimSplitMode=false;snapClear();render();}else{selDimIds.clear();render();}return;}  // Esc on a selected dim: end split mode → else deselect
  if(e.key==='Escape'){if(geoMode){geoMode=null;setGeo();render();return;}if(mode==='add'){mode='sel';setMode();}picking=false;pickKind='profile';pickEnd=null;selIds.clear();render();return;}
+ if((e.key==='Delete'||e.key==='Backspace')&&view3d&&sel3dDimId&&!selIds.size&&!inForm){e.preventDefault();view3dApi.onDeleteDim3d(sel3dDimId);return;}  // 3D: Delete removes the selected 3D dim — only when no member is selected (selection is exclusive, so a stale dim id never shadows a member delete)
  if((e.key==='Delete'||e.key==='Backspace')&&(selDimIds.size||selIds.size)&&!inForm){e.preventDefault();edit(()=>{   // deletes everything selected — dims and/or members (a marquee can hold both)
    if(selDimIds.size){P.dims=P.dims.filter(d=>!selDimIds.has(d.id));selDimIds.clear();}
    if(selIds.size){P.members=P.members.filter(m=>!selIds.has(m.id));selIds.clear();}});return;}
- if(!inForm&&!e.ctrlKey&&!e.metaKey&&!e.altKey&&e.key.toLowerCase()==='d'){e.preventDefault();dimMode=!dimMode;setDimMode();render();return;}  // D — toggle the Dimension tool
+ if(!inForm&&!e.ctrlKey&&!e.metaKey&&!e.altKey&&e.key.toLowerCase()==='d'&&!view3d){e.preventDefault();dimMode=!dimMode;setDimMode();render();return;}  // D — toggle the Dimension tool
  if(dimMode&&!inForm&&!e.ctrlKey&&!e.metaKey&&!e.altKey){const dk=e.key.toLowerCase();
    if(dk==='x'||dk==='y'||dk==='f'){e.preventDefault();dimSetAxis(dk==='f'?'free':dk);dimDraft&&svg.querySelector('#dimPrevG')&&dimRefreshPrev();return;}
    if(dk==='c'){e.preventDefault();toggleDimChain();return;}}   // C — toggle chained (continuous) dimensioning
@@ -1277,8 +1286,8 @@ moreMenu.addEventListener('click',e=>{if(e.target.closest('button'))closeMore();
 const view3dApi={
  // POST the in-progress contract so the model reflects unsaved edits; throws on a bad contract.
  fetchScene:async()=>{const r=await fetch('/api/contract/'+encodeURIComponent(APP_ID)+'/scene',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({contract:C})});const j=await r.json();if(!j.ok)throw new Error(j.error||'scene render failed');return j.scene;},  // endpoint shape: {ok, scene, skipped}
- onSelect:(id,additive)=>{selDimIds.clear();if(!id){selIds=new Set();}else if(additive){selIds.has(id)?selIds.delete(id):selIds.add(id);}else{selIds=new Set([id]);}render();},  // 3D pick → shared selection (clears any 2D dim selection)
- onSelectMany:(ids)=>{selDimIds.clear();selIds=new Set(ids||[]);if(mode==='add'){mode='sel';setMode();}render();},  // 3D box-select → shared selection
+ onSelect:(id,additive)=>{selDimIds.clear();sel3dDimId=null;if(!id){selIds=new Set();}else if(additive){selIds.has(id)?selIds.delete(id):selIds.add(id);}else{selIds=new Set([id]);}render();if(window.Steel3DView&&window.Steel3DView.refreshDims)window.Steel3DView.refreshDims();},  // 3D pick → shared selection (clears 2D + 3D dim selection so Delete is unambiguous)
+ onSelectMany:(ids)=>{selDimIds.clear();sel3dDimId=null;selIds=new Set(ids||[]);if(mode==='add'){mode='sel';setMode();}render();if(window.Steel3DView&&window.Steel3DView.refreshDims)window.Steel3DView.refreshDims();},  // 3D box-select → shared selection
  getMembers:()=>P.members,                                   // raw members (wp) for snap geometry
  ptPerFt:()=>(P&&P.pt_per_ft>0?P.pt_per_ft:1),
  defaultTosMm:()=>(defaultTOS!=null?defaultTOS*25.4:0),      // editor stores default T.O.S in inches
@@ -1290,6 +1299,14 @@ const view3dApi={
    else m.ends.forEach(e=>{e.tos=(e.tos!=null?e.tos:defaultTOS)+dIn;e.tosDef=false;});});},
  onTrimExtend:(targetId)=>{const tm=byId(targetId);if(tm){geoMode=null;setGeo();snapEndMulti(selArr(),tm.wp[0],tm.wp[1]);}},  // 3D Trim/Extend → every selected member's nearest end to the target line
  onSplit:(id,wp)=>{const m=byId(id);if(m){doSplit(m,wp);sync3D();}},  // 3D Split → cut at the clicked point on the member
+ getDims3d:()=>C.dims3d||[],
+ // dims3d is model-global: mutate + persist directly. NOT via edit() — a plan-scoped undo snapshot would corrupt dims3d across plans (undo on plan A could wipe dims added on plan B), and edit()'s sync3D would needlessly re-extrude every member mesh for a pure annotation. boot() guarantees C.dims3d is an array.
+ onAddDim3d:(dim)=>{C.dims3d.push(dim);scheduleSave();refreshDims3d();},
+ onDeleteDim3d:(id)=>{C.dims3d=(C.dims3d||[]).filter(x=>x.id!==id);if(sel3dDimId===id)sel3dDimId=null;scheduleSave();refreshDims3d();},
+ onSelectDim3d:(id)=>{sel3dDimId=id||null;if(id){selIds=new Set();selDimIds.clear();}render();},  // selecting a 3D dim is exclusive: clears member + 2D-dim selection (and updates the 3D member highlight via render)
+ selDim3d:()=>sel3dDimId,
+ newDim3dId:()=>'d3'+Date.now()+'_'+(dimSeq++),   // same scheme as 2D dim ids (Date.now + dimSeq tie-breaker)
+ fmtLen:(mm)=>fmtFtIn(mm/304.8*12),
 };
 // Re-extrude the 3D model after a structural edit (keeps the camera where it is). Selection-only
 // changes go through render()'s setSelection — only geometry mutations need a rebuild.
@@ -1316,7 +1333,11 @@ function wire3DBar(){if(bar3dWired||!window.Steel3DView)return;bar3dWired=true;
  document.querySelectorAll('#m3dProj button').forEach(b=>b.onclick=()=>{window.Steel3DView.setProjection(b.dataset.proj);seg3dActive('#m3dProj','data-proj',b.dataset.proj);});
  document.querySelectorAll('#m3dMode button').forEach(b=>b.onclick=()=>{window.Steel3DView.setDisplayMode(b.dataset.mode);seg3dActive('#m3dMode','data-mode',b.dataset.mode);});
  document.getElementById('m3dFit').onclick=()=>window.Steel3DView.frameAll();
- document.getElementById('m3dRef').onclick=()=>{const on=!window.Steel3DView.refLine();window.Steel3DView.setRefLine(on);document.getElementById('m3dRef').classList.toggle('on',on);};}
+ document.getElementById('m3dRef').onclick=()=>{const on=!window.Steel3DView.refLine();window.Steel3DView.setRefLine(on);document.getElementById('m3dRef').classList.toggle('on',on);};
+ const d3=window.Steel3DView;
+ document.getElementById('m3dDim').onclick=()=>d3.toggleDimTool();  // toggleDimTool()'s reflectDimBar() owns the button .on class + axis/show visibility (single source, no duplicate DOM toggles)
+ document.querySelectorAll('#m3dDimAxis button').forEach(b=>b.onclick=()=>{d3.setDimAxis(b.dataset.d3axis);seg3dActive('#m3dDimAxis','data-d3axis',b.dataset.d3axis);});
+ document.getElementById('m3dDimShow').onclick=()=>{const on=!d3.dims3dVisible();d3.setDims3dVisible(on);document.getElementById('m3dDimShow').textContent=on?'Hide dims':'Show dims';};}
 function applyViewState(on){            // flip the toggle + swap the canvases (no 3D side effects)
  view3d=on;
  const t2=document.getElementById('vt2d'),t3=document.getElementById('vt3d');
@@ -1332,6 +1353,8 @@ function applyViewState(on){            // flip the toggle + swap the canvases (
 }
 async function setView(on){
  if(on){
+  if(dimMode||dimChain||dimSplitMode){dimMode=dimChain=dimSplitMode=false;selDimIds.clear();setDimMode();document.body.classList.remove('dimsplit');}  // entering 3D disarms the 2D dim/chain/split tools so their X/Y/F/S/Esc keys don't double-fire with the 3D tool
+  if(selIds.size)sel3dDimId=null;  // a member selected in 2D wins over a stale 3D-dim selection
   if(!window.Steel3DView){toast('3D view unavailable (renderer failed to load)');return;}  // stay in 2D
   try{
    if(!view3dReady){window.Steel3DView.init(document.getElementById('stage3d'),view3dApi);view3dReady=true;}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.44.0",
+  "version": "0.45.1",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {