@floless/app 0.64.0 → 0.66.0

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.64.0" : void 0,
+    define: true ? "0.66.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.64.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.66.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -59133,14 +59133,16 @@ function writeViewer3dApp(dir, appId, scene) {
   bakeSceneIntoApp(flo, scene);
   return flo;
 }
-function writeIfcApp(dir, appId, scene, outputPath) {
+function writeIfcApp(dir, appId, scene, outputPath, opts = {}) {
   (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
   const flo = (0, import_node_path17.join)(dir, `${appId}.flo`);
+  const displayName = opts.displayName ?? "Steel IFC";
+  const description = opts.description ?? "IFC file written from an approved steel.takeoff/v1 contract (a companion export; the contract is the source of truth).";
   (0, import_node_fs20.writeFileSync)(flo, [
     `app: ${appId}`,
     "version: 0.1.0",
-    "display-name: Steel IFC",
-    "description: IFC file written from an approved steel.takeoff/v1 contract (a companion export; the contract is the source of truth).",
+    `display-name: ${displayName}`,
+    `description: ${description}`,
     "exposes-as-agent: false",
     "requires:",
     "  - ifc@0.1.x",
@@ -64142,20 +64144,41 @@ async function startServer() {
     return { ok: true, report: { ...extracted, interactive: true }, skipped };
   });
   app.post("/api/contract/:appId/export-ifc", async (req, reply) => {
-    const doc = readContract(req.params.appId);
+    const doc = readContractForApp(req.params.appId);
     if (doc == null) return reply.status(404).send({ ok: false, error: "no contract to export" });
-    const v = validateSteelTakeoff(doc);
-    if (!v.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
-    const { scene, skipped } = contractToScene(doc);
+    const isVector = typeof doc === "object" && doc != null && doc.type === "drawing.vector/v1";
+    let scene;
+    let skipped;
+    let extrusionsSkipped = 0;
+    let writeOpts;
+    let emptyError;
+    if (isVector) {
+      const cleaned = postProcess(doc);
+      const vv = validateContract(cleaned);
+      if (!vv.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
+      const built = viewsToScene(cleaned);
+      extrusionsSkipped = built.scene.elements.filter((e) => e.kind === "extrusion").length;
+      scene = { ...built.scene, elements: built.scene.elements.filter((e) => e.kind === "box") };
+      skipped = built.skipped;
+      writeOpts = { displayName: "Drawing IFC", description: "IFC file written from a reconstructed drawing.vector/v1 model (member geometry only; a companion export)." };
+      emptyError = extrusionsSkipped > 0 ? `no member geometry to export \u2014 this model is ${extrusionsSkipped} extruded ${extrusionsSkipped === 1 ? "body" : "bodies"}, which don't export to IFC yet` : "no 3D to export \u2014 reconstruct a plan + elevation first (open View 3D to see what's missing)";
+    } else {
+      const v = validateSteelTakeoff(doc);
+      if (!v.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
+      const built = contractToScene(doc);
+      scene = built.scene;
+      skipped = built.skipped;
+      emptyError = "no resolvable members to export \u2014 every member is an RFI (no AISC size yet)";
+    }
     if (scene.elements.length === 0) {
-      return reply.status(422).send({ ok: false, error: "no resolvable members to export \u2014 every member is an RFI (no AISC size yet)", skipped });
+      return reply.status(422).send({ ok: false, error: emptyError, skipped });
     }
     const companionId = `${req.params.appId}-ifc`;
     const filename = `${req.params.appId}.ifc`;
     const outPath = (0, import_node_path28.join)(appPath(companionId), filename);
     let flo;
     try {
-      flo = writeIfcApp(appPath(companionId), companionId, scene, outPath);
+      flo = writeIfcApp(appPath(companionId), companionId, scene, outPath, writeOpts);
     } catch (e) {
       app.log.error({ companionId, err: e instanceof Error ? e.message : e }, "export-ifc: companion app write failed");
       return reply.status(500).send({ ok: false, error: `could not write the IFC companion app: ${e instanceof Error ? e.message : "write error"}` });
@@ -64178,7 +64201,7 @@ async function startServer() {
     if (!(0, import_node_fs30.existsSync)(outPath)) return reply.send({ ok: false, error: "the IFC export produced no file" });
     const content = (0, import_node_fs30.readFileSync)(outPath, "utf8");
     broadcast({ type: "apps-changed" });
-    return { ok: true, filename, content, bytes: Buffer.byteLength(content), skipped };
+    return { ok: true, filename, content, bytes: Buffer.byteLength(content), skipped, ...extrusionsSkipped ? { extrusionsSkipped } : {} };
   });
   app.post("/api/contract/:appId/export-tekla", async (req, reply) => {
     const doc = readContract(req.params.appId);

package/dist/web/aware.js

@@ -1364,6 +1364,9 @@
         // that page — distinct from the steel `scene` chain below (AWARE exporter companions).
         if (window.CONTRACT_RENDERERS[contractType].viewerUrl) {
           addNodeAction(card, 'View 3D ▸', () => openLocalViewer(currentId, contractType));
+          // A reconstructed model's MEMBER geometry exports to IFC through the same companion as
+          // steel (extruded bodies are view-only for now — the server says so if there's nothing).
+          addNodeAction(card, 'Export IFC ▸', () => exportContractIfc(currentId, true)); // isVector → "unplaced" skip wording
         }
         // The 3D/IFC/BOM/Tekla chain derives a scene from the contract — only contract types that
         // declare `scene` support it (a drawing.vector node would 4xx on these endpoints).
@@ -1862,7 +1865,7 @@
   // Export IFC ▸ — write the approved takeoff OUT to a universal .ifc and download it. The server
   // builds a model-free ifc companion, runs it, and returns the .ifc text (res.content); the browser
   // turns it into a download. api() throws on any failure (no contract, all-RFI, compile/write error).
-  async function exportContractIfc(appId) {
+  async function exportContractIfc(appId, isVector) {
     showToast('Generating IFC…', 'info');
     try {
       const res = await api('/api/contract/' + encodeURIComponent(appId) + '/export-ifc', { method: 'POST' });
@@ -1873,7 +1876,13 @@
       document.body.appendChild(a); a.click(); a.remove();
       setTimeout(() => URL.revokeObjectURL(url), 4000);
       const dropped = Array.isArray(res.skipped) ? res.skipped.length : 0;
-      showToast(`IFC downloaded — ${res.filename || appId + '.ifc'}${dropped ? ` · ${dropped} RFI member(s) skipped` : ''}`, 'ok');
+      // Skip wording differs by contract: steel `skipped` = RFI members (no AISC size); a vector
+      // reconstruction's `skipped` = unplaced entities, plus extruded bodies (extrusionsSkipped)
+      // that don't export to IFC yet. Label each honestly.
+      const notes = [];
+      if (dropped) notes.push(isVector ? `${dropped} unplaced` : `${dropped} RFI member${dropped === 1 ? '' : 's'}`);
+      if (res.extrusionsSkipped) notes.push(`${res.extrusionsSkipped} extruded ${res.extrusionsSkipped === 1 ? 'body' : 'bodies'} (view-only)`);
+      showToast(`IFC downloaded — ${res.filename || appId + '.ifc'}${notes.length ? ' · ' + notes.join(', ') + ' skipped' : ''}`, 'ok');
     } catch (e) {
       showToast('IFC export failed: ' + (e && e.message ? e.message : String(e)), 'warn');
     }

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

@@ -51,6 +51,19 @@ const EP_END = 0xf472b6;             // end endpoint (end 2) — magenta
 
 // ---- 3D dimension tool ----
 let dimMode3d = false;            // tool armed
+let snapOnly3d = null;            // Tekla-style snap override for the dim tool: a snapCandidates type ('vertex'|'intersection'|'midpoint'|'centerline'|'vertical-axis'), 'none' = free, null = all (set from the right-click menu in steel-editor.html)
+// map a 3D candidate type → the 2D running-snap key (⋯ menu → Snapping). Types with no key (level, vertical-axis) are 3D-only aids, always allowed.
+const SNAP3D_PREF = { vertex: 'end', intersection: 'int', midpoint: 'mid', centerline: 'line', 'grid-line': 'line', 'grid-int': 'int' };
+// a grid candidate belongs to the same override FAMILY as its member analog, so "Intersection only" also forces grid intersections and "Centerline only" also forces grid lines.
+const SNAP3D_FAMILY = { 'grid-int': 'intersection', 'grid-line': 'centerline' };
+// is a candidate of this type allowed right now? transient override wins (forces one type/family, or 'none' = free); else honour the persistent running-snaps.
+function candAllowed3d(type) {
+  if (snapOnly3d === 'none') return false;
+  if (snapOnly3d) return type === snapOnly3d || SNAP3D_FAMILY[type] === snapOnly3d;
+  const pref = api && api.snapEnabled && api.snapEnabled(); const k = SNAP3D_PREF[type];
+  return !k || !pref || pref[k] !== false;
+}
+let rightDownXY = null, rightMoved = false; // right button: dragged (= orbit/pan, no menu) vs clicked (= snap menu)
 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)
@@ -113,9 +126,11 @@ function init(canvas, theApi) {
   epPreview = new THREE.Line(new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]), new THREE.LineBasicMaterial({ color: 0x3b82f6 }));
   epPreview.material.depthTest = false; epPreview.renderOrder = 997; epPreview.visible = false; scene.add(epPreview);
   raycaster = new THREE.Raycaster();
-  // a --brand snap marker (one sphere at the winning snap target; the readout carries the type)
-  marker = new THREE.Mesh(new THREE.SphereGeometry(1, 16, 12), new THREE.MeshBasicMaterial({ color: 0x3b82f6 }));
-  marker.visible = false; marker.renderOrder = 999; marker.material.depthTest = false; scene.add(marker);
+  // Snap marker: a camera-facing cyan RETICLE (crosshair ring + per-type inner glyph), not a bare dot —
+  // a solid sphere vanished against the dark bg + coloured steel. Cyan #22d3ee matches the 2D snap marker;
+  // every stroke gets a dark halo so it reads on any background. depthTest off → always on top.
+  marker = new THREE.Sprite(new THREE.SpriteMaterial({ map: reticleFor('dot'), transparent: true, depthTest: false, depthWrite: false }));
+  marker.visible = false; marker.renderOrder = 999; scene.add(marker);
   // live dimension readout (toast-styled, follows the cursor during a drag — feet + snap type).
   // Two spans + textContent (never innerHTML) so it's XSS-proof; the type span is muted.
   readout = document.createElement('div');
@@ -1126,7 +1141,7 @@ function onKey(e) {
   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 === 'escape') { e.preventDefault(); if (snapOnly3d) setSnapOnly3d(null); else if (dimDraft3d) { dimDraft3d = null; dimPreviewLine.visible = false; readout.style.display = 'none'; } else toggleDimTool(); return; } // Esc steps back: drop the snap override → cancel the in-progress dim → exit the tool (mirrors the 2D two-step)
     if (k === 'f' || k === 'x' || k === 'y' || k === 'z') { e.preventDefault(); setDimAxis(k === 'f' ? 'free' : k); reflectDimAxisBar(); return; } // sticky axis: Free / X / Y / Z
   }
   // Named-view shortcuts mirror the ViewCube faces (parity with AWARE viewer-3d): T/F/R/B/L snap to an ortho view.
@@ -1140,11 +1155,13 @@ function onKey(e) {
 // ---- 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'; }
+  if (!dimMode3d) { dimDraft3d = null; dimCandidates3d = null; dimPreviewLine.visible = false; marker.visible = false; readout.style.display = 'none'; canvasEl.style.cursor = 'default'; setSnapOnly3d(null); } // disarming ends the operation → the snap override reverts to all snaps
   else { if (clipMode) setClipMode(null); if (wpMode) armWorkPlanePick(wpMode); if (api && api.disarmTransform) api.disarmTransform(); if (api && api.disarmAdd) api.disarmAdd(); drClear3d(); controls.enabled = true; canvasEl.style.cursor = 'crosshair'; }  // arming the dim tool disarms the clip pick, a set-plane pick, Move/Copy AND Add-member (all share the left-click + Esc)
   reflectDimBar();
   return dimMode3d;
 }
+// snap override setter — notifies the host page so its header chip stays in sync with every clear path
+function setSnapOnly3d(k) { snapOnly3d = k || null; if (api && api.onSnapOnlyChanged) api.onSnapOnlyChanged(); }
 function setDimAxis(a) { if (['free', 'x', 'y', 'z'].includes(a)) dimAxis3d = a; }
 function dimAxis() { return dimAxis3d; }
 function setDims3dVisible(on) { dims3dVisibleFlag = !!on; refreshDims(); }
@@ -1784,8 +1801,8 @@ function wpPointAt(e) {
   const wp = effectiveWP();
   const hit = rayToWP(e.clientX, e.clientY, wp); if (!hit) return null;
   if (!e.altKey) {
-    if (!tfCandidates) tfCandidates = snapCandidates(members(), api.ptPerFt(), api.defaultTosMm());
-    const r = snapPoint(hit, tfCandidates, toScreen, SNAP_TOL_PX);
+    if (!tfCandidates) tfCandidates = allCandidates(null);   // members + grid, so Move/Copy + draw-on-plane snap to the grid too
+    const r = snapPoint(hit, tfCandidates.filter((c) => candAllowed3d(c.type)), toScreen, SNAP_TOL_PX);  // honour the running-snaps / override
     if (r.candidate) return { p: projectToPlane(r.snapped, wp.origin, wp.normal), snap: true, type: r.candidate.type };
   }
   return { p: hit, snap: false, type: null };
@@ -1835,7 +1852,7 @@ function tfPreview(e) {
   const r = wpPointAt(e); if (!r) return;
   const p = tfConstrain(r.p, e);
   tfLast = p; tfLastClient = [e.clientX, e.clientY];
-  if (r.snap && tfAxis === 'free' && !e.shiftKey) { marker.position.set(p[0], p[1], p[2]); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+  if (r.snap && tfAxis === 'free' && !e.shiftKey) showMarker(p, r.type); else marker.visible = false;
   const v = [p[0] - tfDraft.base[0], p[1] - tfDraft.base[1], p[2] - tfDraft.base[2]];
   tfGhostBuild(tfOffsetsFor(v, st));
   if (!tfRubber) { tfRubber = new THREE.Line(new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]), new THREE.LineBasicMaterial({ color: 0x22d3ee })); tfRubber.material.depthTest = false; tfRubber.renderOrder = 997; scene.add(tfRubber); }
@@ -1913,7 +1930,7 @@ function drClick(e) {
 }
 function drPreview(e) {
   const r = wpPointAt(e); if (!r) return;
-  if (r.snap) { marker.position.set(r.p[0], r.p[1], r.p[2]); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+  if (r.snap) showMarker(r.p, r.type); else marker.visible = false;
   if (!drDraft) { readout.style.display = 'none'; return; }
   const p = drShiftLock(r.p, e);
   if (!drRubber) { drRubber = new THREE.Line(new THREE.BufferGeometry().setFromPoints([new THREE.Vector3(), new THREE.Vector3()]), new THREE.LineBasicMaterial({ color: 0x22d3ee })); drRubber.material.depthTest = false; drRubber.renderOrder = 997; scene.add(drRubber); }
@@ -1933,7 +1950,45 @@ function pxToWorldAt(px, pos) {
   const dist = pos ? camera.position.distanceTo(pos) : camera.position.distanceTo(controls.target);
   return px * (2 * Math.tan(THREE.MathUtils.degToRad(perspCam.fov) / 2) * dist) / h;
 }
-const markerSize = () => pxToWorldAt(8, marker && marker.position); // snap marker ~8px at its own depth
+const RETICLE_PX = 44; // on-screen size of the snap reticle (the full sprite); the ring/glyph fill the middle ~55%
+// One CanvasTexture per glyph kind (built lazily, cached). Each shape is stroked twice — a wide dark halo
+// first, then the cyan on top — so the marker stays legible over dark bg, bright members, or the grid.
+const reticleTex = {};
+function makeReticleTexture(kind) {
+  const S = 128, c = document.createElement('canvas'); c.width = c.height = S;
+  const g = c.getContext('2d'), cx = S / 2, cy = S / 2, CY = '#22d3ee', HALO = 'rgba(2,8,23,0.9)';
+  g.lineCap = 'round'; g.lineJoin = 'round';
+  const dual = (draw, wCy, wHalo) => { g.strokeStyle = HALO; g.lineWidth = wHalo; draw(); g.strokeStyle = CY; g.lineWidth = wCy; draw(); };
+  dual(() => { g.beginPath(); g.arc(cx, cy, 38, 0, Math.PI * 2); g.stroke(); }, 5, 11);          // crosshair ring
+  const tick = (dx, dy) => { g.beginPath(); g.moveTo(cx + dx * 44, cy + dy * 44); g.lineTo(cx + dx * 58, cy + dy * 58); g.stroke(); };
+  dual(() => { tick(0, -1); tick(0, 1); tick(-1, 0); tick(1, 0); }, 5, 11);                       // N/E/S/W ticks
+  const r = 15;                                                                                   // inner glyph, mirrors the 2D marker language
+  if (kind === 'x') dual(() => { g.beginPath(); g.moveTo(cx - r, cy - r); g.lineTo(cx + r, cy + r); g.moveTo(cx - r, cy + r); g.lineTo(cx + r, cy - r); g.stroke(); }, 7, 13);
+  else if (kind === 'tri') dual(() => { g.beginPath(); g.moveTo(cx, cy - r); g.lineTo(cx + 0.87 * r, cy + 0.5 * r); g.lineTo(cx - 0.87 * r, cy + 0.5 * r); g.closePath(); g.stroke(); }, 6, 12);
+  else if (kind === 'bar') dual(() => { g.beginPath(); g.moveTo(cx - r, cy); g.lineTo(cx + r, cy); g.stroke(); }, 8, 14);
+  else if (kind === 'vbar') dual(() => { g.beginPath(); g.moveTo(cx, cy - r); g.lineTo(cx, cy + r); g.stroke(); }, 8, 14);
+  else if (kind === 'square') dual(() => { g.beginPath(); g.rect(cx - r, cy - r, 2 * r, 2 * r); g.stroke(); }, 7, 13); // vertex/endpoint = square (CAD convention; matches the 2D endpoint marker)
+  else if (kind === 'hourglass') dual(() => { g.beginPath(); g.moveTo(cx - r, cy - r); g.lineTo(cx + r, cy - r); g.lineTo(cx - r, cy + r); g.lineTo(cx + r, cy + r); g.closePath(); g.stroke(); }, 6, 12); // on-line ("nearest") = hourglass/clepsydra, matches the 2D marker
+  else { g.fillStyle = HALO; g.beginPath(); g.arc(cx, cy, 11, 0, Math.PI * 2); g.fill(); g.fillStyle = CY; g.beginPath(); g.arc(cx, cy, 8, 0, Math.PI * 2); g.fill(); } // dot (fallback)
+  const tex = new THREE.CanvasTexture(c); if (THREE.SRGBColorSpace) tex.colorSpace = THREE.SRGBColorSpace; tex.needsUpdate = true;
+  return tex;
+}
+// snap-candidate type → glyph kind (matches the 2D circle/×/△/─ vocabulary)
+function reticleFor(type) {
+  const k = (type === 'intersection' || type === 'grid-int') ? 'x' : type === 'midpoint' ? 'tri'
+    : (type === 'centerline' || type === 'grid-line') ? 'hourglass'  // snap ONTO a line = "nearest"
+    : type === 'level' ? 'bar'                                       // elevation level = horizontal bar
+    : type === 'vertical-axis' ? 'vbar' : type === 'vertex' ? 'square' : 'dot';
+  return reticleTex[k] || (reticleTex[k] = makeReticleTexture(k));
+}
+let lastSnapType3d = null; // test-observability: the glyph the reticle last showed (null when hidden)
+// Place + size + show the snap reticle at a world point, glyph chosen by snap type. Screen-constant size.
+function showMarker(p, type) {
+  marker.material.map = reticleFor(type); marker.material.needsUpdate = true;
+  marker.position.set(p[0], p[1], p[2]);
+  marker.scale.setScalar(pxToWorldAt(RETICLE_PX, marker.position));
+  marker.visible = true; lastSnapType3d = type || 'dot';
+}
 
 // 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,
@@ -1947,21 +2002,42 @@ function dimPointAt(e, anchor) {
   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 = allCandidates(null);
-  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 };
+  if (!dimCandidates3d) dimCandidates3d = allCandidates(null);   // member + grid candidates (allCandidates folds in the grid)
+  const cands = dimCandidates3d.filter((c) => candAllowed3d(c.type)); // right-click override (one type / free) + the persistent running-snaps from the ⋯ menu
+  // Grid geometry is drawn at its OWN Z (often ground, e.g. 0), which can be far from the steel-level planeZ.
+  // Evaluate grid candidates against a ray hit on the GRID plane so they align with what's drawn; member
+  // candidates keep the member/scene plane. Pick whichever winner is closest to the cursor on screen.
+  const gz = gridPlaneZ();
+  const isGrid = (c) => c.type === 'grid-int' || c.type === 'grid-line';
+  const gridCands = gz != null ? cands.filter(isGrid) : [];
+  const memCands = gridCands.length ? cands.filter((c) => !isGrid(c)) : cands;
+  const best = (cset, dragged) => { if (!cset.length || !dragged) return null; const r = snapPoint(dragged, cset, toScreen, SNAP_TOL_PX);
+    if (!r.candidate) return null; const a = toScreen(dragged), b = toScreen(r.snapped); return { r, d: Math.hypot(a.x - b.x, a.y - b.y) }; };
+  const rMem = best(memCands, [hit[0], hit[1], hit[2]]);
+  const hitGrid = gridCands.length ? rayToPlane(e.clientX, e.clientY, gz) : null;
+  const rGrid = best(gridCands, hitGrid);
+  const win = rGrid && (!rMem || rGrid.d <= rMem.d) ? rGrid : rMem;
+  return { p: win ? win.r.snapped : hit, type: win ? win.r.candidate.type : null };
+}
+// The grid's world Z (where its snap targets live), derived from the current grid candidates — or null if no grid.
+function gridPlaneZ() {
+  if (!dimCandidates3d) return null;
+  const p = dimCandidates3d.find((c) => c.type === 'grid-int'); if (p) return p.p[2];
+  const l = dimCandidates3d.find((c) => c.type === 'grid-line'); if (l) return l.a[2];
+  return 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 === 2) { rightDownXY = [e.clientX, e.clientY]; rightMoved = false; } // arm the click-vs-drag test for the snap menu
   if (e.button !== 0) return;                 // RIGHT/MIDDLE → OrbitControls (orbit/pan)
   if (wpMode === 'face') { e.stopPropagation(); const r = wpFacePick(e.clientX, e.clientY); if (r) { workPlane = r; wpMode = null; canvasEl.style.cursor = 'default'; renderWorkPlane(); reflectWpBar(); if (api && api.toast) api.toast('Working plane set on the face'); } return; } // armed: one face click sets the plane
   if (wpMode === '3pt') { e.stopPropagation();
     const r = dimPointAt(e); if (!r) return;
     wpDraft = wpDraft || []; wpDraft.push(r.p);
-    marker.position.set(r.p[0], r.p[1], r.p[2]); marker.scale.setScalar(markerSize()); marker.visible = true;
+    showMarker(r.p, r.type);
     if (wpDraft.length === 3) { const wp = planeFrom3Points(wpDraft[0], wpDraft[1], wpDraft[2]);
       wpDraft = null; wpMode = null; marker.visible = false; canvasEl.style.cursor = 'default';
       if (wp) { wp.kind = 'p3'; workPlane = wp; renderWorkPlane(); if (api && api.toast) api.toast('Working plane set from 3 points'); }
@@ -2000,11 +2076,13 @@ function onDown(e) {
     const geo = m ? memberGeometry(m, ppf, dtos) : null;
     const mesh = meshById.get(id);
     const planeZ = geo ? (geo.line[0][2] + geo.line[1][2]) / 2 : 0;
+    const ctrl = e.ctrlKey || e.metaKey;
     pending = {
-      id, ctrl: e.ctrlKey || e.metaKey, ppf, planeZ,
+      id, ctrl, ppf, planeZ,
+      copy: ctrl, copyIds: ctrl ? (selIds.has(id) ? [...selIds] : [id]) : null,  // Ctrl+drag copies: the selection if this member is in it, else just it
       grab: geo ? rayToPlane(e.clientX, e.clientY, planeZ) : null,
       origMm: geo ? geo.line.map((p) => [p[0], p[1], p[2]]) : null,
-      candidates: allCandidates(id),
+      candidates: allCandidates(ctrl ? undefined : id).filter((c) => candAllowed3d(c.type)),  // member + grid snap targets (a ctrl-copy snaps to the ORIGINAL too; a move excludes itself), filtered by the running-snaps (⋯ menu → Snapping)
       levels: elevationLevels(members(), ppf, dtos, id), // Alt-drag (vertical) snaps to these T.O.S levels
       mesh, meshPos0: mesh ? mesh.position.clone() : null, delta: null, mode: null,
     };
@@ -2020,7 +2098,7 @@ function onMoveVertical(e) {
   const newZ = r.candidate ? r.snapped[2] : hit[2];
   pending.dz = newZ - pending.planeZ;
   if (pending.mesh && pending.meshPos0) pending.mesh.position.set(pending.meshPos0.x, pending.meshPos0.y, pending.meshPos0.z + pending.dz);
-  if (r.candidate) { marker.position.set(gx, gy, newZ); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+  if (r.candidate) showMarker([gx, gy, newZ], r.candidate.type); else marker.visible = false;
   readout._dist.textContent = (newZ / FT_MM).toFixed(2) + ' ft'; // resulting T.O.S elevation
   readout._type.textContent = r.candidate ? ' · level' : ' ↕';
   readout.style.left = (e.clientX + 14) + 'px'; readout.style.top = (e.clientY + 14) + 'px'; readout.style.display = 'block';
@@ -2035,7 +2113,7 @@ function startEndpointGrab(ep, e) {
     pending = {
       epDrag: true, id: ep.id, end: ep.end, ppf,
       planeZ: g.line[ep.end][2], fixed: g.line[1 - ep.end],
-      candidates: allCandidates(ep.id),
+      candidates: allCandidates(ep.id).filter((c) => candAllowed3d(c.type)),  // member + grid snap targets, filtered by the running-snaps (⋯ menu → Snapping)
       newPt: [g.line[ep.end][0], g.line[ep.end][1]],
     };
     dragEp = { id: ep.id, end: ep.end };
@@ -2053,13 +2131,14 @@ function onMoveEndpoint(e) {
   const f = pending.fixed;
   epPreview.geometry.setFromPoints([new THREE.Vector3(f[0], f[1], f[2]), new THREE.Vector3(np[0], np[1], pending.planeZ)]);
   epPreview.visible = true;
-  if (r.candidate) { marker.position.set(np[0], np[1], np[2]); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+  if (r.candidate) showMarker(np, r.candidate.type); else marker.visible = false;
   const len = Math.hypot(np[0] - f[0], np[1] - f[1]) / FT_MM;
   readout._dist.textContent = len.toFixed(2) + ' ft'; readout._type.textContent = r.candidate ? ' · ' + r.candidate.type : '';
   readout.style.left = (e.clientX + 14) + 'px'; readout.style.top = (e.clientY + 14) + 'px'; readout.style.display = 'block';
 }
 
 function onMove(e) {
+  if (rightDownXY && Math.hypot(e.clientX - rightDownXY[0], e.clientY - rightDownXY[1]) > 5) rightMoved = true; // right-DRAG = orbit/pan, so no snap menu on the release
   if (!renderer || !canvasEl || canvasEl.style.display === 'none') return; // 3D inactive — ignore window pointer events
   if (boxSel) { onBoxMove(e); return; }
   if (pending && pending.clipDrag) { onMoveClip(e); return; }   // dragging a clip handle (plane offset / box face)
@@ -2067,7 +2146,9 @@ function onMove(e) {
   if (pending.epDrag) { onMoveEndpoint(e); return; }
   if (!pending.grab || !pending.origMm) return;
   if (!dragging && Math.hypot(e.clientX - downXY[0], e.clientY - downXY[1]) <= DRAG_TOL_PX) return;
-  if (!dragging) pending.mode = e.altKey ? 'vertical' : 'plan'; // lock the mode at drag start (Alt = vertical/elevation)
+  const canDrag = pending.copy || (api && api.dragMoveEnabled && api.dragMoveEnabled());
+  if (!canDrag) { if (!pending._hinted) { pending._hinted = true; if (api && api.dragMoveHint) api.dragMoveHint(); } return; }  // drag-move OFF, plain grab → never translate; onUp selects the member (dragging stays false)
+  if (!dragging) pending.mode = pending.copy ? 'copy' : (e.altKey ? 'vertical' : 'plan'); // lock the mode at drag start (copy is plan-only; Alt = vertical/elevation)
   dragging = pending;
   if (pending.mode === 'vertical') { onMoveVertical(e); return; }
   const cur = rayToPlane(e.clientX, e.clientY, pending.planeZ); if (!cur) return;
@@ -2083,14 +2164,26 @@ function onMove(e) {
   }
   if (corr) { dx += corr[0]; dy += corr[1]; }
   pending.delta = [dx, dy];
-  if (pending.mesh && pending.meshPos0) pending.mesh.position.set(pending.meshPos0.x + dx, pending.meshPos0.y + dy, pending.meshPos0.z);
-  if (at) { marker.position.set(at[0], at[1], at[2]); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false;
+  if (pending.copy) positionCopyGhost(dx, dy);                                     // Ctrl+drag: move a translucent ghost, never the original
+  else if (pending.mesh && pending.meshPos0) pending.mesh.position.set(pending.meshPos0.x + dx, pending.meshPos0.y + dy, pending.meshPos0.z);
+  if (at) showMarker(at, atType); else marker.visible = false;
   // live dimension readout: plan distance moved (feet) + the snap type, near the cursor
   readout._dist.textContent = (Math.hypot(dx, dy) / FT_MM).toFixed(2) + ' ft';
   readout._type.textContent = atType ? ' · ' + atType : '';
   readout.style.left = (e.clientX + 14) + 'px'; readout.style.top = (e.clientY + 14) + 'px'; readout.style.display = 'block';
 }
 
+// Ctrl+drag copy: a translucent ghost of the grabbed set (copyIds) shifted by the plan delta. Clones
+// share the source geometry + one material (like the Move/Copy tool's ghost) — nothing to dispose.
+let copyGhost = null;
+function positionCopyGhost(dx, dy) {
+  if (copyGhost) scene.remove(copyGhost);
+  copyGhost = new THREE.Group();
+  if (!tfGhostMat) tfGhostMat = new THREE.MeshBasicMaterial({ color: 0x3b82f6, transparent: true, opacity: 0.3, depthWrite: false });
+  for (const id of (pending.copyIds || [])) { const m = meshById.get(id); if (!m || !m.visible) continue; const c = new THREE.Mesh(m.geometry, tfGhostMat); c.applyMatrix4(m.matrixWorld); c.position.x += dx; c.position.y += dy; copyGhost.add(c); }
+  scene.add(copyGhost);
+}
+function clearCopyGhost() { if (copyGhost) { scene.remove(copyGhost); copyGhost = null; } }
 function onBoxMove(e) {
   if (Math.hypot(e.clientX - boxSel.x, e.clientY - boxSel.y) < DRAG_TOL_PX) { rubber.style.display = 'none'; return; }
   boxSel.moved = true;
@@ -2114,7 +2207,8 @@ function membersInRect(x0, y0, x1, y1) {
 }
 
 function onUp(e) {
-  if (marker) marker.visible = false; if (readout) readout.style.display = 'none'; if (rubber) rubber.style.display = 'none'; if (epPreview) epPreview.visible = false; dragEp = null; // always clear overlays
+  if (e.button === 2) rightDownXY = null; // end the click-vs-drag test (rightMoved keeps the verdict for the contextmenu that follows)
+  if (marker) marker.visible = false; if (readout) readout.style.display = 'none'; if (rubber) rubber.style.display = 'none'; if (epPreview) epPreview.visible = false; clearCopyGhost(); dragEp = null; // always clear overlays
   if (!renderer || !canvasEl || canvasEl.style.display === 'none') { downXY = null; boxSel = pending = dragging = null; if (controls) controls.enabled = true; return; } // 3D hidden mid-gesture → drop stale gesture state (no resume on re-show)
   const bs = boxSel; boxSel = null;
   if (bs) { // empty-space gesture: drag = box-select, click = clear selection
@@ -2149,7 +2243,14 @@ function onUp(e) {
     }
     return;
   }
-  if (!wasDragging) { clickSelect(e.clientX, e.clientY, p.ctrl); return; } // click → cycle-pick: member, or a derived part stacked on it at a joint
+  if (!wasDragging) {
+    if (p.id && !p.geo && !p.epDrag && !p.copy && moved > DRAG_TOL_PX && api && api.onSelect) { api.onSelect(p.id, false); return; } // a blocked drag (drag-move OFF) selects the GRABBED member, not whatever's under the release point
+    clickSelect(e.clientX, e.clientY, p.ctrl); return; // click → cycle-pick: member, or a derived part stacked on it at a joint (Ctrl+click = additive select)
+  }
+  if (p.copy) { // Ctrl+drag → commit a copy at the plan delta (the editor clones + selects); the ghost was the preview
+    if (p.delta && !(p.delta[0] === 0 && p.delta[1] === 0) && api && api.onCopyDrag3d) api.onCopyDrag3d(p.copyIds, p.delta[0], p.delta[1]);
+    return;
+  }
   if (p.mode === 'vertical') { // elevation drag → write T.O.S (inches)
     if (p.dz && Math.abs(p.dz) > 1e-6) {
       if (api && api.onSelect) api.onSelect(p.id, false);
@@ -2181,7 +2282,7 @@ function onHoverMove(e) {
     if (wpMode) {                              // armed set-plane pick: crosshair (+ snap marker for the 3pt flow)
       canvasEl.style.cursor = 'crosshair';
       if (wpMode === '3pt') { const r = dimPointAt({ clientX: lastHoverXY[0], clientY: lastHoverXY[1], altKey: dimLastAlt });
-        if (r && !(wpDraft && wpDraft.length)) { marker.position.set(...r.p); marker.scale.setScalar(markerSize()); marker.visible = true; } }
+        if (r && !(wpDraft && wpDraft.length)) showMarker(r.p, r.type); }
       updateStatusChip(); return; }
     if (addActive()) {                         // Add-member armed: snap marker + rubber preview on the working plane
       canvasEl.style.cursor = 'crosshair';
@@ -2191,14 +2292,15 @@ function onHoverMove(e) {
       canvasEl.style.cursor = 'crosshair';
       if (tfDraft) tfPreview({ clientX: lastHoverXY[0], clientY: lastHoverXY[1], altKey: dimLastAlt, shiftKey: tfLastShift });
       else { const r = wpPointAt({ clientX: lastHoverXY[0], clientY: lastHoverXY[1], altKey: dimLastAlt });
-        if (r && r.snap) { marker.position.set(...r.p); marker.scale.setScalar(markerSize()); marker.visible = true; } else marker.visible = false; }
+        if (r && r.snap) showMarker(r.p, r.type); else marker.visible = false; }
       updateStatusChip(); return; }
     if (clipMode) { canvasEl.style.cursor = 'crosshair'; if (clipMode === 'box') clipBoxPreviewAt(lastHoverXY[0], lastHoverXY[1]); return; } // armed clip pick: crosshair (+ live box preview while drawing)
     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;
+      const snapped = !!(r && r.type);
+      if (snapped) showMarker(r.p, r.type); else marker.visible = false; // reticle only on a real snap (free point rides the preview line) — parity with 2D snapClear
+      canvasEl.style.cursor = snapped ? 'none' : 'crosshair'; // at a snap the reticle IS the cursor (Tekla) — hide the native crosshair so it doesn't double up on the marker
       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;
@@ -2218,7 +2320,8 @@ function onHoverMove(e) {
     hoverEp = null;
     let top = null; try { top = pickAllAt(lastHoverXY[0], lastHoverXY[1])[0] || null; } catch { top = null; }
     const topMesh = top ? meshById.get(top) : null, isPart = !!(topMesh && topMesh.userData.derived);
-    canvasEl.style.cursor = geoMode() ? 'crosshair' : (top ? (isPart ? 'pointer' : 'grab') : 'default'); // derived part → pointer (select-only); member → grab (draggable)
+    const canDrag = api && api.dragMoveEnabled && api.dragMoveEnabled();
+    canvasEl.style.cursor = geoMode() ? 'crosshair' : (top ? ((isPart || !canDrag) ? 'pointer' : 'grab') : 'default'); // derived part → pointer (select-only); member → grab only when drag-move is ON, else pointer (a click just selects — the cursor tells the truth, like 2D)
     if (top !== hoverId) { hoverId = top; rebuildEndpoints(); updateStatusChip(); }
   });
 }
@@ -2238,9 +2341,12 @@ function updateStatusChip() {
   else if (showId) { const m = members().find((x) => x.id === showId); txt = m ? `${m.id} · ${m.profile || '—'}` : ''; }
   else if (selIds.size > 1) txt = `${selIds.size} members selected`;
   else if (isolatedIds) txt = `Isolated: ${isolatedIds.size} · Show all to restore`;
-  // A read-only host (the vector 3D viewer) supplies its own idle hint — the default speaks
-  // editing verbs (move/stretch/elevate) that a viewer's no-op api would silently ignore.
-  else txt = (api && typeof api.statusHint === 'function' && api.statusHint()) || 'Drag to move · ends to stretch · Alt+drag elevation · right-drag orbit · dbl-click to zoom in';
+  // A read-only host (the vector 3D viewer) supplies its own idle hint — the default speaks editing
+  // verbs (move/stretch/elevate) a viewer's no-op api would silently ignore. Otherwise the default
+  // tells the truth about the drag-move toggle (grab-to-move ON vs click-to-select + Ctrl+drag-copy).
+  else if (api && typeof api.statusHint === 'function' && api.statusHint()) txt = api.statusHint();
+  else { const canDrag = api && api.dragMoveEnabled && api.dragMoveEnabled();
+    txt = (canDrag ? 'Drag to move · ' : 'Click to select · Ctrl+drag to copy · ') + 'ends to stretch · Alt+drag elevation · right-drag orbit · dbl-click to zoom in'; }
   hoverChip.textContent = txt;
   hoverChip.style.left = (rect.left + rect.width / 2) + 'px'; hoverChip.style.transform = 'translateX(-50%)';
   hoverChip.style.top = (rect.bottom - 30) + 'px';
@@ -2254,6 +2360,7 @@ function hide() {
   if (wpMode) { wpMode = null; wpDraft = null; if (marker) marker.visible = false; reflectWpBar(); }  // drop an in-progress set-plane pick — else a stale face/3pt pick steals the first click on return
   cmClear3d(); drClear3d();                     // and any 3D Move/Copy or draw draft/ghosts
   if (dimLabelHost) dimLabelHost.style.display = 'none'; // the loop that hides labels is about to stop — hide synchronously so none are stranded
+  clearCopyGhost();                                // drop a stale Ctrl+drag copy ghost on the way out
   if (canvasEl) canvasEl.style.display = 'none'; if (hoverChip) hoverChip.style.display = 'none'; if (rafId) { cancelAnimationFrame(rafId); rafId = null; }
 }
 function isReady() { return built; }
@@ -2309,6 +2416,8 @@ function debug() {
     endpoints: epGroup ? epGroup.children.length : 0,
     endpointColors: epGroup ? epGroup.children.map((c) => '#' + c.material.color.getHexString()) : [],
     hoverId, hoverEp, dragEp, refLine: refLineOn,
+    snapMarker: marker && marker.visible ? { type: lastSnapType3d, at: [marker.position.x, marker.position.y, marker.position.z] } : null, // test-observability for the snap reticle
+
     inFrustum: (() => { let n = 0, t = 0; for (const m of meshById.values()) { t++; const v = m.getWorldPosition(new THREE.Vector3()).project(camera); if (Math.abs(v.x) <= 1 && Math.abs(v.y) <= 1 && v.z >= -1 && v.z <= 1) n++; } return { n, t }; })(),
     camPos: camera ? [camera.position.x, camera.position.y, camera.position.z] : null,
     target: controls ? [controls.target.x, controls.target.y, controls.target.z] : null,
@@ -2336,6 +2445,13 @@ function centerOf(id) {
   return { x: rect.left + (w.x * 0.5 + 0.5) * rect.width, y: rect.top + (-w.y * 0.5 + 0.5) * rect.height };
 }
 function worldOf(id) { const m = meshById.get(id); if (!m) return null; const w = m.getWorldPosition(new THREE.Vector3()); return [w.x, w.y, w.z]; } // test helper: a rendered part's world position
+// test helper: client (px) coords of every POINT snap candidate of `type` currently in view (members + grid, via
+// allCandidates) — drives precise E2E snap hovers, including grid nodes/intersections (grid-int).
+function snapCandidatesScreen(type) {
+  const rect = canvasEl.getBoundingClientRect();
+  return allCandidates(null).filter((c) => c.type === type && c.p)
+    .map((c) => { const s = toScreen(c.p); return { world: c.p, x: rect.left + s.x, y: rect.top + s.y }; });
+}
 window.Steel3DView = {
   init, show, hide, rebuild, setSelection, isReady, dispose,
   setProjection, projection, setDisplayMode, mode: () => displayMode, frameAll, frameSelection, applyView,
@@ -2350,12 +2466,13 @@ window.Steel3DView = {
   cmEscape, cmHasBase, cmClear3d, setCmAxis, cmLastClient, cmHudApply,
   drClear3d, drEscape: () => { if (drDraft) { drDraft = null; drClear3d(); return true; } return false; },
   toggleDimTool, setDimAxis, dimAxis, setDims3dVisible, dims3dVisible, refreshDims,
+  setSnapOnly: setSnapOnly3d, snapOnly: () => snapOnly3d, dimToolOn: () => dimMode3d, rightDragged: () => rightMoved, // Tekla-style snap override (right-click menu lives in steel-editor.html)
   refreshOverlayDims,
   overlayDimsInfo: () => computeOverlayDims().map((s) => ({ label: s.label, cat: s.cat })),   // the dims currently emitted (toggle + visibility applied) — for tests
   overlayLabelTexts: () => overlayLabelPool.filter((el) => el.style.display !== 'none' && el.style.visibility !== 'hidden').map((el) => el.textContent),
   dims3dCount: () => (api && api.getDims3d ? (api.getDims3d() || []).length : 0),
   selDims3dCount: () => (api && api.selDim3d ? (api.selDim3d() || []).length : 0),   // test helper: how many 3D dims are selected
   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, worldOf, clipHandlesScreen,
+  debug, probe, screenOf, centerOf, worldOf, snapCandidatesScreen, clipHandlesScreen,
   pointClipped: (p) => isPointClipped(p),   // test helper: is a world point on the cut-away side of any active clip?
 };

package/dist/web/steel-editor.html

@@ -31,7 +31,8 @@
  select,input{background:#0f172a;color:var(--text);border:1px solid #475569;border-radius:6px;padding:6px;width:100%;font:13px system-ui}
  .row{margin:8px 0} .danger{background:#7f1d1d;border-color:#991b1b} .danger:hover{background:#991b1b}
  .pill{display:inline-block;padding:1px 6px;border-radius:4px;font-size:11px}
- line.member{cursor:move;stroke-width:6;stroke-linecap:round}
+ line.member{cursor:pointer;stroke-width:6;stroke-linecap:round}    /* default (drag-move OFF): a click selects → the pointer cursor tells the truth */
+ body.dragmove line.member{cursor:move}                            /* drag-move ON: the move cursor signals a drag will translate — a per-hover second signal beside the toolbar pill */
  line.member.sel{stroke-width:7} line.member.rfi{stroke-dasharray:10 6}
  circle.handle{fill:var(--bg);stroke:#f8fafc;stroke-width:3;cursor:grab}
  line.seg{stroke:#475569;stroke-width:2;opacity:0;cursor:crosshair} body.add line.seg{opacity:.5}
@@ -84,6 +85,33 @@
  .aithumb button{position:absolute;top:-5px;right:-5px;width:16px;height:16px;padding:0;border-radius:8px;font-size:10px;line-height:16px;text-align:center;background:#7f1d1d;border-color:#991b1b;color:#fecaca}
  #saveStat.dirty{color:#fbbf24} #saveStat.ok{color:#86efac} #saveStat.err{color:#fca5a5}
  #csStat.local{border:1px solid #22d3ee;background:rgba(34,211,238,.10);border-radius:4px;padding:1px 6px}  /* lift the chip out of the muted row when a local frame is active (reuses the dim/accent cyan — no new colour) */
+ #snapStat{cursor:pointer;border:1px solid #22d3ee;background:rgba(34,211,238,.10);border-radius:4px;padding:1px 6px}  /* snap-override chip — same cyan treatment as #csStat.local; the cyan IS the snap-marker colour it restricts */
+ #snapStat:hover b{color:#fff}
+ #snapMenu{position:fixed;left:0;top:0;z-index:45;min-width:186px}  /* right-click snap menu — reuses the .m3dmenu skin, opened at the cursor */
+ #snapMenu .sg{display:inline-block;width:17px;color:#22d3ee}       /* leading glyph = the marker the cursor will show */
+ #snapMenu button.dim{opacity:.55}                                  /* a running-snap turned off in the ⋯ menu — still forceable here (AutoCAD-style) */
+ #snapMenu .offtag{font-size:9px;text-transform:uppercase;letter-spacing:.05em;color:var(--mut);margin-left:6px}
+ /* ⋯ menu → Snapping section: persistent running-snap toggles as delicate slider switches (CSS-only, no native input). Toggle = brand blue (the menu's "on" language); the glyph stays snap-cyan (a legend of the on-canvas marker), dimmed when the snap is off. */
+ #moreMenu .msnap-hdr{display:flex;align-items:center;justify-content:space-between}   /* collapsible "Snapping" header — saves menu space; the rows live in .msnap-sect below */
+ #moreMenu .msnap-hdr .chev{color:var(--mut);font-size:10px;transition:transform .15s}
+ #moreMenu .msnap-hdr[aria-expanded=true] .chev{transform:rotate(90deg)}
+ #moreMenu .msnap-sect{display:none} #moreMenu .msnap-sect.open{display:block}
+ #moreMenu button.msnap{display:flex;align-items:center;gap:0}
+ #moreMenu button.msnap.on{color:var(--text)}   /* the switch carries the state — don't also brand the text (reads as an armed tool elsewhere in this menu) */
+ #moreMenu .mck{position:relative;width:26px;height:14px;margin-right:9px;border-radius:7px;border:1px solid var(--line);background:#0b1220;flex:none;transition:background-color .15s,border-color .15s}
+ #moreMenu .mck::after{content:'';position:absolute;top:1px;left:1px;width:10px;height:10px;border-radius:50%;background:var(--mut);transition:transform .15s,background-color .15s}
+ #moreMenu button.msnap.on .mck{background:rgba(59,130,246,.28);border-color:var(--brand)}
+ #moreMenu button.msnap.on .mck::after{transform:translateX(12px);background:var(--brand)}
+ #moreMenu button.msnap .sg{display:inline-block;width:17px;color:#22d3ee;opacity:.5;flex:none;transition:opacity .15s}
+ #moreMenu button.msnap.on .sg{opacity:1}
+ /* Quick-access snap bar — always-expanded row of glyph toggles, bottom-right of the canvas (both views); reuses the brand-fill "on" toolbar language */
+ #snapBar{position:absolute;right:12px;bottom:12px;z-index:8;display:flex;gap:2px;padding:3px;background:var(--panel);border:1px solid var(--line);border-radius:8px;box-shadow:0 4px 14px rgba(0,0,0,.45)}
+ #snapBar.s3d{right:104px}   /* in 3D, sit just LEFT of the bottom-right world-axis triad (#m3dAxes, right 15 + 78 wide) — same bottom edge, side by side (the ViewCube is top-right) */
+ #snapBar button{width:24px;height:24px;display:grid;place-items:center;border:0;border-radius:5px;background:transparent;color:#22d3ee;opacity:.55;font-size:12px;line-height:1;cursor:pointer;padding:0;transition:background-color .12s,opacity .12s,color .12s}
+ #snapBar button:hover{background:rgba(148,163,184,.12);opacity:.9}
+ #snapBar button.on{background:var(--brand);color:#0f172a;opacity:1}
+ #snapBar button:focus-visible{outline:2px solid var(--brand);outline-offset:1px}
+ #moreMenu .mhint{color:var(--mut);font-size:11px;line-height:1.4;padding:4px 12px 6px;max-width:230px;white-space:normal}
  #rfiStat{cursor:pointer;text-decoration:underline dotted} #rfiStat:hover b{color:#fff}
  #confStat{cursor:pointer;text-decoration:underline dotted} #confStat:hover b{filter:brightness(1.25)}
  .conf-cats{display:grid;grid-template-columns:repeat(2,1fr);gap:10px;padding:14px;border-bottom:1px solid var(--line)}
@@ -131,9 +159,11 @@
  /* "More" overflow menu — themed popup (reuses the #comboPop look); flat rows keep each button's id + handler. */
  /* Move/Copy split buttons + transform-suite chrome — all within the locked baseline tokens. */
 .cmwrap{position:relative;display:inline-flex}
-.cmwrap>button:first-child{border-radius:6px 0 0 6px}
-.cmwrap .cmcaret{border-radius:0 6px 6px 0;border-left:0;padding:0 5px;min-width:22px;color:var(--mut)}
-.cmwrap>button.on,.cmwrap .cmcaret.on{background:var(--brand);border-color:var(--brand);color:#fff}
+#xfB{white-space:nowrap}
+#xfB.on{background:var(--brand);border-color:var(--brand);color:#fff}   /* a transform tool is armed */
+.cmmenu .mstate{margin-left:auto;font-size:11px;color:var(--mut);padding-left:12px}   /* the Drag-to-move on/off state, right-aligned in its menu row */
+.cmmenu #dragMoveB.on .mstate{color:var(--brand)}
+.cmmenu #dragMoveB.on{color:var(--text)}
 .cmmenu{display:none;position:absolute;left:0;top:calc(100% + 6px);min-width:200px;background:var(--panel);border:1px solid #475569;border-radius:8px;box-shadow:0 8px 24px rgba(0,0,0,.5);padding:4px 0;z-index:30}
 .cmmenu.open{display:block}
 .cmmenu button{display:flex;justify-content:space-between;gap:12px;width:100%;text-align:left;background:transparent;border:0;border-radius:0;padding:7px 12px;color:var(--text);white-space:nowrap}
@@ -158,7 +188,7 @@
 #moreWrap{position:relative;display:inline-flex}
  #moreMenu{position:absolute;right:0;top:calc(100% + 6px);min-width:210px;background:var(--panel);border:1px solid #475569;border-radius:8px;box-shadow:0 8px 24px rgba(0,0,0,.5);padding:4px 0;z-index:30;display:none}
  #moreMenu.open{display:block}
- #moreMenu .mlabel,.m3dmenu .mlabel{font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--mut);padding:8px 12px 2px}
+ #moreMenu .mlabel,.m3dmenu .mlabel,.cmmenu .mlabel{font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--mut);padding:8px 12px 2px}
  #moreMenu hr{border:0;border-top:1px solid var(--line);margin:4px 0}
  #moreMenu button{display:block;width:100%;text-align:left;background:transparent;border:0;border-radius:0;padding:7px 12px;color:var(--text);white-space:nowrap}
  #moreMenu button:hover{background:#334155}
@@ -184,6 +214,9 @@
  #lbImg{position:absolute;left:50%;top:50%;max-width:86vw;max-height:80vh;transform-origin:center;user-select:none;-webkit-user-drag:none}
  line.draw{stroke:var(--brand);stroke-width:6;stroke-linecap:round;stroke-dasharray:8 5;opacity:.85;pointer-events:none}
  .snapmk{fill:none;stroke:#22d3ee;stroke-width:2;vector-effect:non-scaling-stroke;pointer-events:none}
+ line.extguide{stroke:#22d3ee;stroke-width:1.5;stroke-dasharray:6 5;opacity:.55;vector-effect:non-scaling-stroke;pointer-events:none}  /* extension guide ray — faintest line on screen (a hint, not committed geometry) */
+ /* while a snap marker is up, the marker IS the cursor (Tekla) — hide the native crosshair over the canvas so it doesn't double up on it. !important beats the per-tool crosshair rules below; scoped to #svg so panels keep their cursor. */
+ body.snapping #svg,body.snapping #svg *{cursor:none!important}
  line.dim{stroke:#22d3ee;stroke-width:2.5;vector-effect:non-scaling-stroke;pointer-events:stroke;cursor:pointer}
  line.dimwit{stroke:#22d3ee;stroke-width:1;opacity:.85;vector-effect:non-scaling-stroke;pointer-events:none}
  circle.dimend{fill:#22d3ee;pointer-events:none}
@@ -317,32 +350,42 @@
  <span class=stat id=rfiStat title="Click to list unresolved members (RFI)">RFI <b id=rc>0</b></span>
  <span class=stat id=dupStat title="Overlapping/duplicate members (same geometry)">Dup <b id=dpc>0</b></span>
  <span class=stat id=csStat title="Coordinate system — Global by default. Set a local frame from the ⋯ menu for skewed framing.">Axes <b>Global</b></span>
+ <span class=stat id=snapStat style="display:none" title="Snap restricted for this operation — right-click the canvas to change; click here or press Esc to clear">Snap <b>—</b></span>
  <span class=stat id=confStat title="Confidence report — AI-read score vs. target. Click to review element evidence." style="display:none">Confidence <b id=confPct>—</b><span id=confTgt></span></span>
  <span class=stat id=saveStat title="Edits auto-save in this browser (localStorage)">Saved</span>
  <span class=stat id=srcStat style="display:none"></span><span style="flex:1"></span>
  <button id=undoB title="Undo (Ctrl+Z)">↶</button>
  <button id=redoB title="Redo (Ctrl+Y / Ctrl+Shift+Z)">↷</button>
- <button id=mAdd title="Toggle add-member mode">Add member</button>
- <button id=dimB title="Dimension tool (D) — click two snapped points, then a third to place. Default Free (aligned); hold Shift to lock to an axis, X/Y force horizontal/vertical, F free.">⊢ Dimension</button>
+ <button id=mAdd title="Toggle add-member mode — drag to draw. Shift=ortho, Alt=no snap, right-click=restrict snap to one type">Add member</button>
+ <button id=dimB title="Dimension tool (D) — click two snapped points, then a third to place. Default Free (aligned); hold Shift to lock to an axis, X/Y force horizontal/vertical, F free. Right-click the canvas to restrict snapping to one type.">⊢ Dimension</button>
  <div class=cmwrap>
-  <button id=mvB title="Move (M) — pick a base point, then a destination. Type a distance or dx,dy after the first pick for an exact move.">↔ Move</button><button id=mvCaret class=cmcaret aria-haspopup=menu aria-expanded=false aria-label="Move options">▾</button>
-  <div class=cmmenu id=mvMenu role=menu>
+  <button id=xfB aria-haspopup=menu aria-expanded=false title="Move, Copy, array and to-level, plus how left-dragging a member behaves. Move (M) / Copy (C) also arm from the keyboard.">Move / Copy ▾</button>
+  <div class=cmmenu id=xfMenu role=menu>
+   <div class=mlabel>Move</div>
    <button id=mvTwoB>Move — two points <span class=mkbd>M</span></button>
    <button id=mvLevelB>Move to level…</button>
-  </div>
- </div>
- <div class=cmwrap>
-  <button id=cpB title="Copy (C) — pick a base point, then a destination. Set ×N in the panel for a linear row; type a value for an exact offset.">⧉ Copy</button><button id=cpCaret class=cmcaret aria-haspopup=menu aria-expanded=false aria-label="Copy options">▾</button>
-  <div class=cmmenu id=cpMenu role=menu>
+   <div class=mlabel>Copy</div>
    <button id=cpTwoB>Copy — two points <span class=mkbd>C</span></button>
    <button id=cpArrB>Copy array…</button>
    <button id=cpLevelB>Copy to level…</button>
+   <div class=mlabel>Dragging</div>
+   <button id=dragMoveB role=menuitemcheckbox aria-checked=false title="When ON, left-dragging a member moves it. When OFF (default), a click only selects — members can't be nudged by accident (Move and Ctrl+drag-copy still work). Applies to 2D and 3D.">Drag to move<span class=mstate id=dragMoveState>Off</span></button>
   </div>
  </div>
  <button id=askAiBtn>Ask AI ▸</button>
  <div id=moreWrap>
   <button id=moreBtn title="More actions" aria-haspopup=menu aria-expanded=false aria-label="More actions">⋯</button>
   <div id=moreMenu role=menu>
+   <button id=snapHdr class=msnap-hdr aria-expanded=false aria-controls=snapSect title="Running snaps — click to expand and turn each on/off (also on the snap bar, bottom-right)">Snapping<span class=chev aria-hidden=true>▸</span></button>
+   <div id=snapSect class=msnap-sect>
+    <button class="msnap on" data-snap=end role=menuitemcheckbox aria-checked=true title="Snap to member/segment endpoints"><span class=mck aria-hidden=true></span><span class=sg aria-hidden=true>□</span>Endpoint</button>
+    <button class="msnap on" data-snap=int role=menuitemcheckbox aria-checked=true title="Snap to where two members/segments cross"><span class=mck aria-hidden=true></span><span class=sg aria-hidden=true>✕</span>Intersection</button>
+    <button class="msnap on" data-snap=mid role=menuitemcheckbox aria-checked=true title="Snap to the midpoint of a member/segment"><span class=mck aria-hidden=true></span><span class=sg aria-hidden=true>△</span>Midpoint</button>
+    <button class="msnap on" data-snap=line role=menuitemcheckbox aria-checked=true title="Snap to the nearest point on any member/segment line"><span class=mck aria-hidden=true></span><span class=sg aria-hidden=true>⧗</span>Nearest</button>
+    <button class="msnap" data-snap=ext role=menuitemcheckbox aria-checked=false title="Snap along the invisible extension of a member/line past its endpoint, with a dashed guide line"><span class=mck aria-hidden=true></span><span class=sg aria-hidden=true>┈</span>Extension</button>
+    <div class=mhint>Right-click the canvas any time to force one snap type for a single pick.</div>
+   </div>
+   <hr>
    <div class=mlabel>Dimensions</div>
    <button id=dimToggleB title="Show or hide all placed dimensions on the plan">Hide dimensions</button>
    <button id=calloutToggleB title="Show or hide the clickable callout bubbles (section / elevation / detail references) on the plan">Hide callouts</button>
@@ -390,7 +433,7 @@
    <span class=tb-sep></span>
    <!-- Measure / annotate -->
    <button id=m3dRef data-tip="Show each member's reference line (centreline)">Ref line</button>
-   <button id=m3dDim data-tip="Measure — click two snapped points (D); axis Free/X/Y/Z, Alt = vertical">Dimension</button>
+   <button id=m3dDim data-tip="Measure — click two snapped points (D); axis Free/X/Y/Z, Alt = vertical; right-click = restrict snap">Dimension</button>
    <div class=seg-group id=m3dDimAxis style="display:none"><button data-d3axis=free class=on data-tip="Free 3D measurement (F)">Free</button><button data-d3axis=x data-tip="Lock measurement to X (X)">X</button><button data-d3axis=y data-tip="Lock measurement to Y (Y)">Y</button><button data-d3axis=z data-tip="Lock to Z / vertical (Z); Alt = quick vertical">Z</button></div>
    <button id=m3dDimShow data-tip="Show or hide placed 3D dimensions" style="display:none">Hide dims</button>
    <span class=tb-sep></span>
@@ -440,6 +483,14 @@
    <span id=zPct>100%</span>
    <button id=zFit title="Zoom to fit (Home)">Fit</button>
   </div>
+  <!-- Quick-access snap toggles (same persistent state as the ⋯ menu → Snapping section; keep the two in sync — same 5 items). -->
+  <div id=snapBar role=group aria-label="Snap settings">
+   <button data-snap=end title="Endpoint snap">□</button>
+   <button data-snap=int title="Intersection snap">✕</button>
+   <button data-snap=mid title="Midpoint snap">△</button>
+   <button data-snap=line title="Nearest snap">⧗</button>
+   <button data-snap=ext title="Extension snap">┈</button>
+  </div>
  </div>
  <aside id=panel></aside>
 </main>
@@ -1190,6 +1241,7 @@ function doDup(){const arr=selArr();if(!arr.length)return;const o=12,pv=snapshot
  selIds=ns;selDimIds.clear();mode='sel';setMode();pushUndo(pv);render();}
 function esc(s){return String(s).replace(/[<>&"]/g,c=>({'<':'&lt;','>':'&gt;','&':'&amp;','"':'&quot;'}[c]));}
 function render(){
+ document.body.classList.remove('snapping');   // a wholesale svg rebuild drops any #snapMark → clear the cursor-hide flag too (the next pointermove re-adds it if still snapping)
  if(geoMode&&(selIds.size<1||(geoMode==='split'&&selIds.size!==1))){geoMode=null;document.body.classList.remove('geo');}   // Split needs exactly one member; Extend/Trim works on any selection
  let s=RB64?`<image href="data:image/jpeg;base64,${RB64}" x="${X0}" y="${Y0}" width="${X1-X0}" height="${Y1-Y0}"/>`:'';
  s+=gridSvg();   // structural grid under the linework (members/dims stay on top)
@@ -1580,43 +1632,107 @@ function rectHit(p0,p1,r){
  const c=[[r[0],r[1]],[r[2],r[1]],[r[2],r[3]],[r[0],r[3]]];
  for(let i=0;i<4;i++) if(segSeg(p0,p1,c[i],c[(i+1)%4])) return true;
  return false;}
-// --- snap to existing member/segment/dimension endpoints + MIDPOINTS (△); members lie on grids → snaps to grid intersections; Alt = off ---
-const SNAP_PX=9; let snapPts=[], snapSegs=[], snapMids=[], lastSnapKind='end';   // lastSnapKind drives the marker glyph: 'mid' → triangle, else circle
+// --- snap to existing member/segment/dimension endpoints + MIDPOINTS (△) + line INTERSECTIONS (×); members lie on grids → snaps to grid intersections; Alt = off; right-click = snap-override menu ---
+const SNAP_PX=9; let snapPts=[], snapSegs=[], snapMids=[], snapInts=[], snapGeom=[], lastSnapKind='end', snapExtFrom=null;   // lastSnapKind → marker glyph; snapGeom = member/segment lines (no dims) for extension; snapExtFrom = the endpoint an extension snap projects from
+let snapOnly=null;   // Tekla-style TRANSIENT override: 'end'|'int'|'mid'|'line'|'ext' restricts snapping to ONE type for the current operation (right-click menu); null = use the persistent running-snaps
+// persistent running-snaps (AutoCAD Osnap-style), GLOBAL across models, toggled from the ⋯ menu → Snapping
+const SNAP_PREF_KEY='steel:snapPrefs:v1', SNAP_DEFAULTS={end:true,int:true,mid:true,line:true,ext:false};
+let snapEnabled=(()=>{try{return Object.assign({},SNAP_DEFAULTS,JSON.parse(localStorage.getItem(SNAP_PREF_KEY)||'{}'));}catch(_){return {...SNAP_DEFAULTS};}})();
+function saveSnapPrefs(){try{localStorage.setItem(SNAP_PREF_KEY,JSON.stringify(snapEnabled));}catch(_){}}
+// a type fires when a transient override forces exactly it (override ignores running-snaps, AutoCAD-style), else when its running-snap is on
+const snapAllowed=k=>snapOnly?snapOnly===k:snapEnabled[k]!==false;
 const _mid=(a,b)=>[(a[0]+b[0])/2,(a[1]+b[1])/2];
+// intersection of segments a-b and c-d (inside both), or null. ponytail: O(n²) pairwise per buildSnap — fine for hundreds of lines; spatial index if a big plan ever lags.
+function _segX(a,b,c,d){const rx=b[0]-a[0],ry=b[1]-a[1],sx=d[0]-c[0],sy=d[1]-c[1],den=rx*sy-ry*sx;
+ if(Math.abs(den)<1e-9)return null;const qx=c[0]-a[0],qy=c[1]-a[1],t=(qx*sy-qy*sx)/den,u=(qx*ry-qy*rx)/den;
+ return (t<0||t>1||u<0||u>1)?null:[a[0]+rx*t,a[1]+ry*t];}
 function buildSnap(except,opts){const ex=except instanceof Set?except:(except!=null?new Set([except]):new Set());   // id or Set of ids to skip
- snapPts=[];snapSegs=[];snapMids=[];
- for(const m of P.members){if(ex.has(m.id))continue;snapPts.push(m.wp[0],m.wp[1]);snapSegs.push([m.wp[0],m.wp[1]]);snapMids.push(_mid(m.wp[0],m.wp[1]));}
- for(const s of P.segments){snapPts.push(s.a,s.b);snapSegs.push([s.a,s.b]);snapMids.push(_mid(s.a,s.b));}
- if(dimsVisible&&Array.isArray(P.dims))for(const d of P.dims){if(ex.has(d.id))continue;   // snap to a dimension's VISIBLE (offset) line — its ends, midpoint, and onto-line (dimGeo already gives g.mid)
-   const g=dimGeo(d.a,d.b,d.axis,d.off,d.rot);snapPts.push(g.p1,g.p2);snapSegs.push([g.p1,g.p2]);snapMids.push(g.mid);}
- if(gridOn()&&!(opts&&opts.noGrid)){const geo=gridGeo();if(geo){const gs=GC().gridSnapGeom(geo);   // grid lines + intersections snap like member geometry (a hidden grid doesn't snap; a DRAGGED grid line must not stick to its own intersections)
-   for(const sg of gs.segs)snapSegs.push(sg);for(const q of gs.pts)snapPts.push(q);}}}
+ snapPts=[];snapSegs=[];snapMids=[];snapInts=[];snapGeom=[];   // snapGeom = real member/segment/grid lines (extension + intersections project off these, never off dim/annotation lines)
+ for(const m of P.members){if(ex.has(m.id))continue;snapPts.push(m.wp[0],m.wp[1]);snapSegs.push([m.wp[0],m.wp[1]]);snapMids.push(_mid(m.wp[0],m.wp[1]));snapGeom.push([m.wp[0],m.wp[1]]);}
+ for(const s of P.segments){snapPts.push(s.a,s.b);snapSegs.push([s.a,s.b]);snapMids.push(_mid(s.a,s.b));snapGeom.push([s.a,s.b]);}
+ if(gridOn()&&!(opts&&opts.noGrid)){const geo=gridGeo();if(geo){const gs=GC().gridSnapGeom(geo);   // grid lines snap like member geometry — nearest + extension + member/grid intersections; grid nodes → endpoints. (Hidden grid doesn't snap; a DRAGGED grid line passes opts.noGrid so it can't stick to its own lines.)
+   for(const sg of gs.segs){snapSegs.push(sg);snapGeom.push(sg);}for(const q of gs.pts)snapPts.push(q);}}
+ for(let i=0;i<snapGeom.length;i++)for(let j=i+1;j<snapGeom.length;j++){const x=_segX(snapGeom[i][0],snapGeom[i][1],snapGeom[j][0],snapGeom[j][1]);if(x)snapInts.push(x);}   // member×member, member×grid and grid×grid crossings → intersection (×) snap
+ if(dimsVisible&&!(opts&&opts.noDims)&&Array.isArray(P.dims))for(const d of P.dims){if(ex.has(d.id))continue;   // dim (annotation) lines: nearest / endpoint / midpoint only — NOT intersections or extension; opts.noDims skips them (e.g. a grid-line drag shouldn't stick to annotations)
+   const g=dimGeo(d.a,d.b,d.axis,d.off,d.rot);snapPts.push(g.p1,g.p2);snapSegs.push([g.p1,g.p2]);snapMids.push(g.mid);}}
 // nearest point lying ON another member/segment LINE (perpendicular foot, clamped to the segment) within tol
 function nearestOnLine(x,y,tol){let bp=null,bd=tol;
  for(const sg of snapSegs){const pr=projPt([x,y],sg[0],sg[1]);const d=Math.hypot(pr.pt[0]-x,pr.pt[1]-y);if(d<bd){bd=d;bp=pr.pt;}}
  return bp?{x:bp[0],y:bp[1],d:bd}:null;}
-function snap(x,y){const tol=SNAP_PX/zoom;lastSnapKind='end';let bp=null,bd=tol;
- for(const q of snapPts){const d=Math.hypot(q[0]-x,q[1]-y);if(d<bd){bd=d;bp=q;}}
- if(bp)return {x:bp[0],y:bp[1],hit:true,kind:'end'};                       // 1) endpoint / grid intersection (highest priority)
- let mp=null,md=tol;for(const q of snapMids){const d=Math.hypot(q[0]-x,q[1]-y);if(d<md){md=d;mp=q;}}
- if(mp){lastSnapKind='mid';return {x:mp[0],y:mp[1],hit:true,kind:'mid'};}  // 2) midpoint of a member/segment/dimension line (△)
- const ln=nearestOnLine(x,y,tol);if(ln)return {x:ln.x,y:ln.y,hit:true,kind:'line'};  // 3) else snap ONTO a line (not only its endpoints)
- let sx=x,sy=y,bx=tol,by=tol;                                              // 4) else axis-align to a nearby point
- for(const q of snapPts){const dx=Math.abs(q[0]-x);if(dx<bx){bx=dx;sx=q[0];}const dy=Math.abs(q[1]-y);if(dy<by){by=dy;sy=q[1];}}
- return {x:sx,y:sy,hit:false,kind:null};}
+// nearest point on the EXTENSION of a line — the perpendicular foot on the infinite line, but ONLY where it
+// lies BEYOND the segment (t<0 or t>1). Returns the foot + the endpoint it extends from (for the dashed guide).
+function nearestOnExtension(x,y,tol){let best=null,bd=tol;
+ for(const sg of snapGeom){const a=sg[0],b=sg[1],vx=b[0]-a[0],vy=b[1]-a[1],L2=vx*vx+vy*vy;if(L2<1e-9)continue;
+   const t=((x-a[0])*vx+(y-a[1])*vy)/L2;if(t>=0&&t<=1)continue;                 // on the segment itself → that's the "nearest" snap, not extension
+   const fx=a[0]+t*vx,fy=a[1]+t*vy,d=Math.hypot(fx-x,fy-y);
+   if(d<bd){bd=d;best={x:fx,y:fy,from:(t<0?a:b)};}}
+ return best;}
+function snap(x,y){const tol=SNAP_PX/zoom;lastSnapKind='end';snapExtFrom=null;
+ if(snapAllowed('end')){let bp=null,bd=tol;
+  for(const q of snapPts){const d=Math.hypot(q[0]-x,q[1]-y);if(d<bd){bd=d;bp=q;}}
+  if(bp)return {x:bp[0],y:bp[1],hit:true,kind:'end'};}                      // 1) endpoint / grid intersection (highest priority)
+ if(snapAllowed('int')){let ip=null,idd=tol;for(const q of snapInts){const d=Math.hypot(q[0]-x,q[1]-y);if(d<idd){idd=d;ip=q;}}
+  if(ip){lastSnapKind='int';return {x:ip[0],y:ip[1],hit:true,kind:'int'};}} // 2) member/segment line crossing (×) — Tekla's intersection snap
+ if(snapAllowed('mid')){let mp=null,md=tol;for(const q of snapMids){const d=Math.hypot(q[0]-x,q[1]-y);if(d<md){md=d;mp=q;}}
+  if(mp){lastSnapKind='mid';return {x:mp[0],y:mp[1],hit:true,kind:'mid'};}} // 3) midpoint of a member/segment/dimension line (△)
+ if(snapAllowed('line')){const ln=nearestOnLine(x,y,tol);if(ln){lastSnapKind='line';return {x:ln.x,y:ln.y,hit:true,kind:'line'};}}  // 4) nearest point ON a line (hourglass)
+ if(snapAllowed('ext')){const ex=nearestOnExtension(x,y,tol);if(ex){lastSnapKind='ext';snapExtFrom=ex.from;return {x:ex.x,y:ex.y,hit:true,kind:'ext'};}}  // 5) along a line's EXTENSION past its end (dashed guide) — off by default
+ if(!snapOnly&&snapEnabled.end!==false){let sx=x,sy=y,bx=tol,by=tol;         // 6) else axis-align to a nearby endpoint's row/column (an endpoint-based aid → off when Endpoint snap is off, or under any "only X" override)
+  for(const q of snapPts){const dx=Math.abs(q[0]-x);if(dx<bx){bx=dx;sx=q[0];}const dy=Math.abs(q[1]-y);if(dy<by){by=dy;sy=q[1];}}
+  return {x:sx,y:sy,hit:false,kind:null};}
+ return {x,y,hit:false,kind:null};}
 // one persistent marker element; kind 'mid' draws an upward triangle, everything else the original circle. Defaults to the last snap()'s kind.
 function snapMark(x,y,kind){kind=kind||lastSnapKind;snapClear();
  const ns='http://www.w3.org/2000/svg';let el;
  if(kind==='mid'){const r=8/zoom;el=document.createElementNS(ns,'path');el.setAttribute('d',`M ${x} ${y-r} L ${x+0.866*r} ${y+0.5*r} L ${x-0.866*r} ${y+0.5*r} Z`);}  // apex-up equilateral, centroid ON the snap point
- else{el=document.createElementNS(ns,'circle');el.setAttribute('cx',x);el.setAttribute('cy',y);el.setAttribute('r',6/zoom);}
- el.id='snapMark';el.setAttribute('class','snapmk');svg.appendChild(el);}
-function snapClear(){const c=document.getElementById('snapMark');if(c)c.remove();}
+ else if(kind==='int'){const r=7/zoom;el=document.createElementNS(ns,'path');el.setAttribute('d',`M ${x-r} ${y-r} L ${x+r} ${y+r} M ${x-r} ${y+r} L ${x+r} ${y-r}`);}  // × centred on the line crossing
+ else if(kind==='end'){const r=6/zoom;el=document.createElementNS(ns,'rect');el.setAttribute('x',x-r);el.setAttribute('y',y-r);el.setAttribute('width',2*r);el.setAttribute('height',2*r);}  // endpoint = SQUARE (CAD convention)
+ else if(kind==='ext'){const r=6/zoom;el=document.createElementNS(ns,'rect');el.setAttribute('x',x-r);el.setAttribute('y',y-r);el.setAttribute('width',2*r);el.setAttribute('height',2*r);el.setAttribute('stroke-dasharray',`${3/zoom} ${2/zoom}`);  // extension = a DASHED square (on the endpoint's ray) + the dashed guide line below
+   if(snapExtFrom){const g=document.createElementNS(ns,'line');g.setAttribute('x1',snapExtFrom[0]);g.setAttribute('y1',snapExtFrom[1]);g.setAttribute('x2',x);g.setAttribute('y2',y);g.id='snapExtLine';g.setAttribute('class','extguide');svg.appendChild(g);}}
+ else{const r=7/zoom;el=document.createElementNS(ns,'path');el.setAttribute('d',`M ${x-r} ${y-r} L ${x+r} ${y-r} L ${x-r} ${y+r} L ${x+r} ${y+r} Z`);}  // on-line ("nearest") = HOURGLASS/clepsydra (AutoCAD Nearest glyph); circle is reserved for a future Center snap
+ el.id='snapMark';el.setAttribute('class','snapmk');svg.appendChild(el);document.body.classList.add('snapping');}   // marker up → hide the native crosshair (see .snapping CSS)
+function snapClear(){const c=document.getElementById('snapMark');if(c)c.remove();const g=document.getElementById('snapExtLine');if(g)g.remove();document.body.classList.remove('snapping');}
+// --- Tekla-style snap override (right-click): restrict snapping to ONE type for the current operation.
+// 2D: right-click anywhere on the canvas (set it before grabbing an endpoint — a drag captures the pointer).
+// 3D: right-CLICK while the Dimension tool is armed (right-DRAG stays orbit/pan). The override clears when
+// the operation ends: tool disarm, plan/view switch, a select-mode drag ending, Esc, or "All snaps". ---
+const SNAP_KINDS_2D=[['end','□','Endpoint'],['int','✕','Intersection'],['mid','△','Midpoint'],['line','⧗','Nearest'],['ext','┈','Extension']];   // glyphs mirror the on-canvas markers; 'line' = AutoCAD "Nearest"
+const SNAP_KINDS_3D=[['vertex','□','Vertex'],['intersection','✕','Intersection'],['midpoint','△','Midpoint'],['centerline','⧗','Centerline'],['vertical-axis','│','Vertical axis']];
+function snapKindLabel(k,is3d){const r=(is3d?SNAP_KINDS_3D:SNAP_KINDS_2D).find(x=>x[0]===k);return r?r[2]:k;}
+function updSnapStat(){const el=document.getElementById('snapStat');if(!el)return;
+ const V=window.Steel3DView,k=view3d?(V&&V.snapOnly?V.snapOnly():null):snapOnly;
+ if(!k){el.style.display='none';return;}
+ el.style.display='';el.innerHTML='Snap <b>'+(k==='none'?'off':esc(snapKindLabel(k,view3d))+' only')+'</b>';}
+function setSnapOnly(k,is3d){if(is3d){const V=window.Steel3DView;if(V&&V.setSnapOnly)V.setSnapOnly(k);}else{snapOnly=k;}updSnapStat();}
+function snapOnlyClear2d(){if(snapOnly){snapOnly=null;updSnapStat();}}
+function snapMenuEl(){let m=document.getElementById('snapMenu');
+ if(!m){m=document.createElement('div');m.id='snapMenu';m.className='m3dmenu';m.setAttribute('role','menu');m.tabIndex=-1;document.body.appendChild(m);
+  m.addEventListener('click',e=>{const b=e.target.closest('button');if(!b)return;setSnapOnly(b.dataset.k||null,m._is3d);closeSnapMenu();});}
+ return m;}
+function snapMenuOpen(){const m=document.getElementById('snapMenu');return !!(m&&m.classList.contains('open'));}
+function closeSnapMenu(){const m=document.getElementById('snapMenu');if(m)m.classList.remove('open');}
+function openSnapMenu(x,y,is3d){const m=snapMenuEl();m._is3d=!!is3d;
+ const V=window.Steel3DView,cur=is3d?(V&&V.snapOnly?V.snapOnly():null):snapOnly;
+ const off=k=>!is3d&&k&&snapEnabled[k]===false;   // a running-snap turned off in the ⋯ menu → dim it here (the override can still force it — AutoCAD-style)
+ const row=(k,g,l)=>`<button role=menuitem data-k="${k}" class="${(cur===k||(!cur&&!k))?'on':''}${off(k)?' dim':''}"><span class=sg aria-hidden=true>${g}</span>${l}${off(k)?' <span class=offtag>off</span>':''}</button>`;
+ m.innerHTML=row('','✓','All snaps (default)')+'<hr>'+(is3d?SNAP_KINDS_3D:SNAP_KINDS_2D).map(r=>row(r[0],r[1],r[2])).join('')+'<hr>'+row('none','⌀','No snap (free)');
+ m.classList.add('open');const r=m.getBoundingClientRect();
+ m.style.left=Math.max(4,Math.min(x,innerWidth-r.width-8))+'px';m.style.top=Math.max(4,Math.min(y,innerHeight-r.height-8))+'px';
+ m.focus();}
+document.addEventListener('pointerdown',e=>{if(snapMenuOpen()&&!e.target.closest('#snapMenu'))closeSnapMenu();},true);
+document.getElementById('stage').addEventListener('contextmenu',e=>{e.preventDefault();openSnapMenu(e.clientX,e.clientY,false);});
+document.getElementById('stage3d').addEventListener('contextmenu',e=>{e.preventDefault();const V=window.Steel3DView;
+ if(!V||!V.dimToolOn||!V.dimToolOn())return;                       // 3D menu only for the armed dim tool
+ if(V.rightDragged&&V.rightDragged())return;                       // that right button was an orbit/pan, not a click
+ openSnapMenu(e.clientX,e.clientY,true);});
+document.getElementById('snapStat').onclick=()=>{snapOnly=null;const V=window.Steel3DView;if(V&&V.setSnapOnly)V.setSnapOnly(null);updSnapStat();};
 // --- Dimension tool: armed mode + 3-click placement (anchor, anchor, offset). Shares the editor's
 // buildSnap/snap/snapMark stack. The in-progress preview lives in its own <g> (render() rebuilds
 // svg.innerHTML wholesale, so we only render() on commit/cancel — like the draw/marquee temps). ---
 const SVGNS='http://www.w3.org/2000/svg';
 function setDimMode(){document.body.classList.toggle('dimon',dimMode);document.getElementById('dimB').classList.toggle('on',dimMode);
  if(dimMode){if(mode==='add'){mode='sel';setMode();}if(csaxisMode){csaxisMode=false;setCsMode();}if(cmTool)disarmCm();geoMode=null;setGeo();selIds.clear();selDimIds.clear();dimsVisible=true;updDimToggle();}  // arming clears conflicting modes (add/set-axes/move-copy) + ensures dims are visible — covers the D-key path too, not just the button
+ snapOnlyClear2d();                                 // any dim-tool transition ends the previous operation → the snap override reverts (arming must not inherit add-mode's override)
  dimDraft=null;dimChainPrev=null;dimPrevClear();}
 function dimSnapAt(e){const q=toSvg(e);let x=q.x,y=q.y;
  if(!e.altKey){buildSnap(null);const sn=snap(x,y);x=sn.x;y=sn.y;return {x,y,raw:[q.x,q.y],hit:sn.hit};}
@@ -1659,9 +1775,9 @@ function dimSetAxis(ax){dimAxis=ax;if(dimDraft)dimDraft.axis=ax;
 function dimHintText(){if(dimChainPrev)return 'Chaining — click the next point to add another dimension from the last one. Enter or Esc ends the chain.';
  const loc=!!(P&&P.frame);
  const a={free:'Free (aligned)',x:loc?'X (local)':'X (horizontal)',y:loc?'Y (local)':'Y (vertical)'}[dimDraft?dimDraft.axis:dimAxis];
- return 'Dimension — '+a+(dimChain?' · Chain ON':'')+(loc?' · local axes':'')+'. Click 1: start · Click 2: end · Click 3: place. Shift=lock axis · X/Y/F force · Alt=no snap · Esc=cancel.';}
+ return 'Dimension — '+a+(dimChain?' · Chain ON':'')+(loc?' · local axes':'')+'. Click 1: start · Click 2: end · Click 3: place. Shift=lock axis · X/Y/F force · Alt=no snap · right-click=snap menu · Esc=cancel.';}
 function toggleDimChain(){dimChain=!dimChain;if(!dimChain){dimChainPrev=null;dimPrevClear();}render();}  // Chain (C): toggle continuous dimensioning; turning it off ends any running chain (render() repaints the panel)
-function toggleDimSplit(){dimSplitMode=!dimSplitMode;snapClear();render();}  // S / "Add split point": arm splitting on the selected dim(s); each click then inserts a point
+function toggleDimSplit(){dimSplitMode=!dimSplitMode;snapClear();snapOnlyClear2d();render();}  // S / "Add split point": arm splitting on the selected dim(s); each click then inserts a point; any transition drops the previous operation's snap override
 // Split the SELECTED dim nearest the click into two at a point ON its baseline (same axis + offset).
 // Picks the closest selected dim within a screen tolerance whose interior the click projects into; the
 // split point is the perpendicular foot, so a free (oblique) dim never kinks and the total is preserved.
@@ -1693,12 +1809,16 @@ function dimRefreshPrev(){if(!dimMode||!dimDraft||!dimLastPtr)return;
 // array N×M. Same shell as the Dimension tool: armed flag routes the pointer handlers, the preview
 // lives in its own <g> (no render() until commit), commits go through edit()/pushUndo. ---
 let cmTool=null,cmArrayMode=false,cmDraft=null,cmAxis='free',cmCount=1,cmCountA=2,cmCountB=2,cmLastPtr=null,cmLastEvt=null;
+// Drag-to-move: OFF by default so a click only selects (no accidental nudges). Persisted per-browser,
+// global (a UI pref, not per-app). Ctrl+drag-copy ignores this — it's an explicit gesture.
+let dragMoveOn=false; try{dragMoveOn=localStorage.getItem('steel:dragmove:v1')==='1';}catch(_){}
+let dragHintShown=false; try{dragHintShown=localStorage.getItem('steel:dragmovehint:v1')==='1';}catch(_){}   // one-time "drag-move is off" teach on the first blocked drag
+function setDragMove(on){dragMoveOn=!!on;document.body.classList.toggle('dragmove',dragMoveOn);
+ const b=document.getElementById('dragMoveB');if(b){b.classList.toggle('on',dragMoveOn);b.setAttribute('aria-checked',String(dragMoveOn));const st=document.getElementById('dragMoveState');if(st)st.textContent=dragMoveOn?'On':'Off';}
+ try{localStorage.setItem('steel:dragmove:v1',dragMoveOn?'1':'0');}catch(_){}}
 // cmDraft: {base:[x,y], vA:null} — array mode sets vA=[dx,dy,0] once direction A is picked/typed
 function setCmUi(){document.body.classList.toggle('cmon',!!cmTool);
- document.getElementById('mvB').classList.toggle('on',cmTool==='move');
- document.getElementById('mvCaret').classList.toggle('on',cmTool==='move');
- document.getElementById('cpB').classList.toggle('on',cmTool==='copy');
- document.getElementById('cpCaret').classList.toggle('on',cmTool==='copy');}
+ document.getElementById('xfB').classList.toggle('on',!!cmTool);}   // the Transform button fills when Move OR Copy is armed (the side-panel badge names which)
 function disarmCm(){cmTool=null;cmArrayMode=false;cmDraft=null;cmHudClose();cmPrevClear();setCmUi();
  if(window.Steel3DView&&window.Steel3DView.cmClear3d)window.Steel3DView.cmClear3d();}   // drop the 3D-side pick/preview too
 function armCm(tool,array){ // re-arming the same config toggles the tool off — works in 2D and (on the working plane) in 3D
@@ -1870,6 +1990,7 @@ function toLevelCommit(tool,ti){const sel=selArr();const T=C.plans[ti];
 function setCsMode(){document.body.classList.toggle('csaxison',csaxisMode);
  const b=document.getElementById('csSetB');if(b)b.classList.toggle('on',csaxisMode);
  if(csaxisMode){if(mode==='add'){mode='sel';setMode();}if(dimMode){dimMode=false;setDimMode();}if(cmTool)disarmCm();geoMode=null;setGeo();selIds.clear();selDimIds.clear();}  // arming disarms conflicting tools + clears selection
+ snapOnlyClear2d();                                 // any set-axes transition ends the previous operation → the snap override reverts (arming must not inherit another tool's override)
  csDraft=null;csPrevClear();}
 function csSnapAt(e){const q=toSvg(e);if(e.altKey)return [q.x,q.y];buildSnap(null);const sn=snap(q.x,q.y);return [sn.x,sn.y];}
 function csClick(e){const p=csSnapAt(e);
@@ -1926,7 +2047,7 @@ svg.addEventListener('pointerdown',e=>{if(e.button!==0)return;const t=e.target;
   const gel=gb||ghit;
   if(gel&&mode==='sel'&&!geoMode&&!dimSplitMode&&!picking&&P.grid){
    const axis=gel.dataset.gv!=null?'v':'h',gi=+(gel.dataset.gv!=null?gel.dataset.gv:gel.dataset.gh);
-   if(isFinite(gi)){buildSnap(null,{noGrid:true});const q=toSvg(e);const geo=gridGeo();const line=geo&&geo[axis][gi];
+   if(isFinite(gi)){buildSnap(null,{noGrid:true,noDims:true});const q=toSvg(e);const geo=gridGeo();const line=geo&&geo[axis][gi];
     if(line){const end=gb?+(gb.dataset.end||0):null;   // a bubble grab can become an END drag (along the line); a body grab is always a perpendicular move
      drag={type:'gridline',axis,gi,startPt:[q.x,q.y],orig:axis==='v'?line.x:line.y,origEnd:end===0?line.lo:line.hi,end,
       base:geo[axis].map(l=>axis==='v'?l.x:l.y),bubble:!!gb,moved:false,dir:null,pre:snapshot()};  // base = dragstart positions so one drag quantizes the string ONCE (no 1/16" creep on unmoved lines)
@@ -1968,12 +2089,16 @@ svg.addEventListener('pointerdown',e=>{if(e.button!==0)return;const t=e.target;
    return;}}
  if(t.classList.contains('seg')&&mode==='add'){addFromSeg(t.dataset.seg);return;}
  if(t.tagName==='image'&&mode==='add'){buildSnap(null);let q=toSvg(e),x0=q.x,y0=q.y;if(!e.altKey){const sn=snap(x0,y0);x0=sn.x;y0=sn.y;}const ln=document.createElementNS('http://www.w3.org/2000/svg','line');ln.setAttribute('class','draw');ln.setAttribute('x1',x0);ln.setAttribute('y1',y0);ln.setAttribute('x2',x0);ln.setAttribute('y2',y0);svg.appendChild(ln);drag={type:'draw',x0,y0,line:ln};svg.setPointerCapture(e.pointerId);e.preventDefault();return;}
- if(t.classList.contains('member')&&mode==='sel'){const id=t.dataset.id;
-   if(e.ctrlKey||e.metaKey){selIds.has(id)?selIds.delete(id):selIds.add(id);render();return;}
-   if(!selIds.has(id)){selIds=new Set([id]);render();}
-   const p=toSvg(e),items=selArr().map(m=>({id:m.id,o0:m.wp[0].slice(),o1:m.wp[1].slice()}));
-   buildSnap(new Set(items.map(it=>it.id)));                         // snap a dragged line to other members'/segments' endpoints (grid lines)
-   drag={type:'move',start:[p.x,p.y],items,pre:snapshot()};svg.setPointerCapture(e.pointerId);e.preventDefault();return;}
+ if(t.classList.contains('member')&&mode==='sel'){const id=t.dataset.id,ctrl=(e.ctrlKey||e.metaKey),p=toSvg(e);
+   // Plain click selects on down (so a no-drag click still selects even with drag-move off). Ctrl defers
+   // its select to up — a ctrl-DRAG copies, a ctrl-CLICK toggles selection (today's behavior).
+   if(!ctrl&&!selIds.has(id)){selIds=new Set([id]);render();}
+   const canDrag=ctrl||dragMoveOn;                                   // plain grab only translates when the toggle is on; ctrl always drags (to copy)
+   const srcIds=(ctrl&&!selIds.has(id))?new Set([id]):new Set(selArr().map(m=>m.id));  // ctrl on an unselected member copies just it; else the whole selection
+   const items=[...srcIds].map(mid=>{const m=byId(mid);return{id:mid,o0:m.wp[0].slice(),o1:m.wp[1].slice()};});
+   buildSnap(srcIds);                                                // snap the dragged line(s) to OTHER members'/segments' endpoints
+   drag={type:'grab',copy:ctrl,armed:canDrag,start:[p.x,p.y],items,clickId:id,pre:snapshot(),moved:false};
+   svg.setPointerCapture(e.pointerId);e.preventDefault();return;}   // always capture: even an unarmed grab tracks the gesture so a blocked drag can teach the toggle
  if((t===svg||t.tagName==='image'||t.classList.contains('seg'))&&mode==='sel'){const p=toSvg(e);   // t===svg → drag on bare canvas (no raster) still box-selects
    const rc=document.createElementNS('http://www.w3.org/2000/svg','rect');rc.setAttribute('class','marquee');svg.appendChild(rc);
    drag={type:'marquee',x0:p.x,y0:p.y,add:(e.ctrlKey||e.metaKey),rect:rc};svg.setPointerCapture(e.pointerId);e.preventDefault();}});
@@ -2022,14 +2147,26 @@ svg.addEventListener('pointermove',e=>{
    drag.line.setAttribute('x2',x);drag.line.setAttribute('y2',y);drag.cur=[x,y];return;}
  if(drag.type==='marquee'){const x=Math.min(drag.x0,p.x),y=Math.min(drag.y0,p.y),w=Math.abs(p.x-drag.x0),h=Math.abs(p.y-drag.y0);
    drag.rect.setAttribute('x',x);drag.rect.setAttribute('y',y);drag.rect.setAttribute('width',w);drag.rect.setAttribute('height',h);drag.cur=[x,y,x+w,y+h];return;}
- if(drag.type==='move'){let dx=p.x-drag.start[0],dy=p.y-drag.start[1];
+ if(drag.type==='grab'){const rawdx=p.x-drag.start[0],rawdy=p.y-drag.start[1];
+   if(!drag.moved){
+     if(Math.hypot(rawdx,rawdy)<4/zoom)return;                       // below the drag threshold — still a potential click
+     drag.moved=true;
+     if(!drag.armed)return;                                          // drag-move OFF, plain grab → never translate (the up-handler teaches the toggle)
+     if(drag.copy){                                                  // materialize clones once; from here it's a normal move of the clones
+       const ns=new Set(),ci=[];
+       for(const it of drag.items){const src=byId(it.id);if(!src)continue;const c=cloneMember(src);P.members.push(c);ns.add(c.id);ci.push({id:c.id,o0:c.wp[0].slice(),o1:c.wp[1].slice()});}
+       selIds=ns;drag.items=ci;buildSnap(ns);render();}}             // select the clones + snap them to the sources/others; render shows them (drag continues via updateLine)
+   if(!drag.armed)return;
+   let dx=rawdx,dy=rawdy;
    if(e.shiftKey){[dx,dy]=orthoLock(0,0,dx,dy);snapClear();}                          // ortho move — lock the delta to the local frame (or screen H/V)
-   else if(!e.altKey){let best=null,bd=SNAP_PX/zoom;                  // shift the group so a moving endpoint lands on a snap target (endpoint, midpoint △, OR line)
+   else if(!e.altKey){let best=null,bd=SNAP_PX/zoom;                  // shift the group so a moving endpoint lands on a snap target (endpoint, intersection ×, midpoint △, OR line) — each family honours the right-click override
      for(const it of drag.items)for(const o of [it.o0,it.o1]){const nx=o[0]+dx,ny=o[1]+dy;
-       for(const q of snapPts){const d=Math.hypot(q[0]-nx,q[1]-ny);if(d<bd){bd=d;best={q,cx:q[0]-nx,cy:q[1]-ny,kind:'end'};}}
-       for(const q of snapMids){const d=Math.hypot(q[0]-nx,q[1]-ny);if(d<bd){bd=d;best={q,cx:q[0]-nx,cy:q[1]-ny,kind:'mid'};}}
-       const ln=nearestOnLine(nx,ny,bd);if(ln){bd=ln.d;best={q:[ln.x,ln.y],cx:ln.x-nx,cy:ln.y-ny,kind:'line'};}}  // also snap onto other lines
-     if(best){dx+=best.cx;dy+=best.cy;snapMark(best.q[0],best.q[1],best.kind);}else snapClear();}
+       if(snapAllowed('end'))for(const q of snapPts){const d=Math.hypot(q[0]-nx,q[1]-ny);if(d<bd){bd=d;best={q,cx:q[0]-nx,cy:q[1]-ny,kind:'end'};}}
+       if(snapAllowed('int'))for(const q of snapInts){const d=Math.hypot(q[0]-nx,q[1]-ny);if(d<bd){bd=d;best={q,cx:q[0]-nx,cy:q[1]-ny,kind:'int'};}}
+       if(snapAllowed('mid'))for(const q of snapMids){const d=Math.hypot(q[0]-nx,q[1]-ny);if(d<bd){bd=d;best={q,cx:q[0]-nx,cy:q[1]-ny,kind:'mid'};}}
+       if(snapAllowed('line')){const ln=nearestOnLine(nx,ny,bd);if(ln){bd=ln.d;best={q:[ln.x,ln.y],cx:ln.x-nx,cy:ln.y-ny,kind:'line'};}}  // also snap onto other lines (honours the running-snaps + override)
+       if(snapAllowed('ext')){const ex=nearestOnExtension(nx,ny,bd);if(ex){bd=Math.hypot(ex.x-nx,ex.y-ny);best={q:[ex.x,ex.y],cx:ex.x-nx,cy:ex.y-ny,kind:'ext',from:ex.from};}}}  // ...and onto a line's extension (parity with the single-endpoint drag / draw / dim paths)
+     if(best){dx+=best.cx;dy+=best.cy;if(best.kind==='ext')snapExtFrom=best.from;snapMark(best.q[0],best.q[1],best.kind);}else snapClear();}
    else snapClear();
    for(const it of drag.items){const m=byId(it.id);if(!m)continue;
      m.wp[0]=[it.o0[0]+dx,it.o0[1]+dy];m.wp[1]=[it.o1[0]+dx,it.o1[1]+dy];updateLine(m);}
@@ -2041,6 +2178,7 @@ svg.addEventListener('pointermove',e=>{
  m.wp[drag.h]=[x,y];updateLine(m);updateHandles(m);});
 svg.addEventListener('pointerup',()=>{if(!drag)return;snapClear();
  if(drag.type==='gridline'){const wasBubble=drag.bubble,moved=drag.moved,pre=drag.pre;drag=null;gridReadoutHide();
+   snapOnlyClear2d();                                                  // a grid-line drag is one discrete operation → its single-shot snap override always reverts (grid-line drags can run while the grid panel is open, so don't gate on anyToolActive())
    if(!moved){if(wasBubble){setGridMode(true);                         // opens the panel (clears the logical selection). NO render() — replacing the bubble between the two clicks of a dbl-click would swallow the rename gesture…
      svg.querySelectorAll('line.member.sel').forEach(n=>{n.classList.remove('sel');n.style.filter='';});   // …so drop the stale selection VISUALS surgically instead
      svg.querySelectorAll('circle.handle,circle.dimhandle,circle.numbg,text.numtx').forEach(n=>n.remove());
@@ -2056,7 +2194,19 @@ svg.addEventListener('pointerup',()=>{if(!drag)return;snapClear();
    const r=drag.cur;if(r&&(r[2]-r[0]>2||r[3]-r[1]>2)){for(const m of P.members)if(rectHit(m.wp[0],m.wp[1],r))selIds.add(m.id);
      if(dimsVisible)for(const d of P.dims){const g=dimGeo(d.a,d.b,d.axis,d.off,d.rot);if(rectHit(g.p1,g.p2,r)||rectHit(g.w[0][0],g.w[0][1],r)||rectHit(g.w[1][0],g.w[1][1],r))selDimIds.add(d.id);}}  // area-select grabs dims by their VISIBLE geometry — the dim line + its two witness lines (not the invisible anchor span)
    drag.rect.remove();drag=null;render();return;}
- if(drag.pre&&snapshot()!==drag.pre)pushUndo(drag.pre);drag=null;render();});
+ if(drag.type==='grab'){
+   if(!drag.moved){                                                  // no drag past threshold → it was a click
+     if(drag.copy){selIds.has(drag.clickId)?selIds.delete(drag.clickId):selIds.add(drag.clickId);}  // ctrl+click toggles selection (deferred from down)
+     drag=null;render();return;}
+   if(!drag.armed){                                                  // dragged but drag-move OFF → nothing moved; teach the toggle once
+     drag=null;render();
+     if(!dragHintShown){dragHintShown=true;try{localStorage.setItem('steel:dragmovehint:v1','1');}catch(_){}toast('Drag-to-move is off — turn it on in the toolbar, or use ↔ Move (M)');}
+     return;}
+   if(drag.pre&&snapshot()!==drag.pre)pushUndo(drag.pre);           // armed move/copy committed (copy always changed geometry via its clones)
+   const wasCopy=drag.copy;if(!anyToolActive())snapOnlyClear2d();drag=null;render();if(wasCopy)toast('Copied '+selIds.size+' member'+(selIds.size===1?'':'s'));return;}  // a grab move/copy was the operation → single-shot override clears
+ if(drag.pre&&snapshot()!==drag.pre)pushUndo(drag.pre);
+ if(!anyToolActive())snapOnlyClear2d();             // a select-mode drag WAS the operation → the override was single-shot
+ drag=null;render();});
 svg.addEventListener('pointercancel',()=>{if(drag&&drag.type==='gridline'){drag=null;gridReadoutHide();snapClear();render();}});   // a cancelled pointer must not strand the floating readout
 svg.addEventListener('dblclick',e=>{   // dbl-click a grid bubble → rename that label in place
  const at=document.elementFromPoint(e.clientX,e.clientY);   // the pointer capture the drag takes retargets dblclick to the svg root — resolve the bubble by position, not e.target
@@ -2067,7 +2217,7 @@ svg.addEventListener('dblclick',e=>{   // dbl-click a grid bubble → rename tha
 function setMode(){document.body.classList.toggle('add',mode==='add');document.getElementById('mAdd').classList.toggle('on',mode==='add');}
 document.getElementById('mAdd').onclick=()=>{if(dimMode){dimMode=false;setDimMode();}if(csaxisMode){csaxisMode=false;setCsMode();}if(cmTool)disarmCm();
  if(view3d&&window.Steel3DView){const dm=document.getElementById('m3dDim');if(dm&&dm.classList.contains('on'))window.Steel3DView.toggleDimTool();}  // the 3D dim tool shares the left-click — disarm it when entering add mode
- selDimIds.clear();mode=(mode==='add'?'sel':'add');if(mode==='add')selIds.clear();else if(window.Steel3DView&&window.Steel3DView.drClear3d)window.Steel3DView.drClear3d();setMode();render();setLastCmd('Add member',()=>{if(mode!=='add'){if(dimMode){dimMode=false;setDimMode();}mode='add';selIds.clear();setMode();render();}});};  // entering add/sel disarms the Dimension + set-axes tools (else they keep eating canvas clicks) and drops any dim selection; leaving add clears the 3D draw draft
+ selDimIds.clear();mode=(mode==='add'?'sel':'add');if(mode==='add')selIds.clear();else if(window.Steel3DView&&window.Steel3DView.drClear3d)window.Steel3DView.drClear3d();snapOnlyClear2d();setMode();render();setLastCmd('Add member',()=>{if(mode!=='add'){if(dimMode){dimMode=false;setDimMode();}mode='add';selIds.clear();setMode();render();}});};  // entering add/sel disarms the Dimension + set-axes tools + drops any dim selection + reverts a snap override; leaving add clears the 3D draw draft
 document.getElementById('dimB').onclick=()=>{if(csaxisMode){csaxisMode=false;setCsMode();}dimMode=!dimMode;setDimMode();render();setLastCmd('Dimension',()=>{if(!dimMode){dimMode=true;setDimMode();render();}});};
 document.getElementById('csSetB').onclick=()=>{csaxisMode=!csaxisMode;setCsMode();render();};
 document.getElementById('csResetB').onclick=()=>{resetFrame();render();};
@@ -2092,10 +2242,12 @@ document.getElementById('mrgB').onclick=()=>{const r=mergeCollinearJS(P.members)
  toast('Merged '+r.mergedAway+' segment'+(r.mergedAway===1?'':'s')+' into '+r.runs+' member'+(r.runs===1?'':'s'));};
 document.getElementById('undoB').onclick=doUndo;
 document.getElementById('redoB').onclick=doRedo;
+document.getElementById('dragMoveB').onclick=()=>{setDragMove(!dragMoveOn);toast(dragMoveOn?'Drag to move: ON — dragging a member moves it':'Drag to move: OFF — a click only selects');};
+setDragMove(dragMoveOn);   // reflect the persisted state on load (body class + pill)
 addEventListener('keydown',e=>{
  const inForm=/^(INPUT|SELECT|TEXTAREA)$/.test((document.activeElement||{}).tagName);
  if(e.key==='Escape'&&moreOpen()){closeMore();moreBtn.focus();return;}
- if(e.key==='Escape'&&(mvMenuC.isOpen()||cpMenuC.isOpen())){mvMenuC.close();cpMenuC.close();return;}
+ if(e.key==='Escape'&&xfMenuC.isOpen()){xfMenuC.close();return;}
  if(lvOpen()){if(e.key==='Escape')closeLevelModal();return;}   // the level modal is modal: no Delete/undo/tool keys mutate state underneath it
  if(e.key==='Escape'&&lightboxOpen()){closeLightbox();return;}
  if(e.key==='Escape'&&askAiIsOpen()){askAiClose();return;}
@@ -2104,6 +2256,8 @@ addEventListener('keydown',e=>{
  if(e.key==='Escape'&&framesOpen()){closeFrames();return;}
  if(e.key==='Escape'&&rfiOpen()){closeRFI();return;}
  if(e.key==='Escape'&&confOpen()){closeConf();return;}
+ if(e.key==='Escape'&&snapMenuOpen()){closeSnapMenu();return;}
+ if(e.key==='Escape'&&!view3d&&snapOnly){snapOnlyClear2d();return;}  // own Esc rung: 1st Esc drops the snap override, the next cancels the tool/draft (mirrors the set-axes two-step)
  if(e.key==='Home'){e.preventDefault();if(view3d&&window.Steel3DView)window.Steel3DView.frameAll();else fitToWindow();return;}
  if(!view3d&&!inForm&&(((e.key==='z'||e.key==='Z')&&e.altKey)||(e.key===' '&&e.shiftKey))){e.preventDefault();zoomToSelection();return;}  // 2D zoom-to-selected (Tekla Shift+Space / Alt+Z); 3D handles its own (steel-3d-view onKey)
  if((e.key===' '||e.key==='Enter')&&!inForm&&!e.ctrlKey&&!e.metaKey&&!e.altKey&&!e.shiftKey){if(!anyToolActive()&&lastCmd){e.preventDefault();repeatLast();}return;}  // idle Space/Enter → repeat the last command (AutoCAD/Tekla)
@@ -2158,17 +2312,29 @@ function moreOpen(){return moreMenu.classList.contains('open');}
 function moreOutside(e){if(!moreMenu.contains(e.target)&&e.target!==moreBtn)closeMore();}
 function closeMore(){moreMenu.classList.remove('open');moreBtn.setAttribute('aria-expanded','false');document.removeEventListener('mousedown',moreOutside,true);}
 moreBtn.onclick=e=>{e.stopPropagation();if(moreOpen())closeMore();else{moreMenu.classList.add('open');moreBtn.setAttribute('aria-expanded','true');document.addEventListener('mousedown',moreOutside,true);}};
-moreMenu.addEventListener('click',e=>{if(e.target.closest('button'))closeMore();});  // an item's own handler runs (bubble) before this closes the menu
+moreMenu.addEventListener('click',e=>{if(e.target.closest('button')&&!e.target.closest('.msnap')&&!e.target.closest('.msnap-hdr'))closeMore();});  // an item's own handler runs (bubble) before this closes the menu; the snap toggles + the "Snapping" expander keep the menu open (settings, not one-shot actions)
+// "Snapping" is collapsible to save menu space — the header expands the running-snap switches below it
+{const snapHdr=document.getElementById('snapHdr'),snapSect=document.getElementById('snapSect');
+ snapHdr.onclick=e=>{e.stopPropagation();const open=snapSect.classList.toggle('open');snapHdr.setAttribute('aria-expanded',String(open));};}
+// --- Running-snaps: one source of truth (snapEnabled) rendered onto TWO surfaces — the ⋯ menu switches
+// (aria-checked) + the quick-access snap bar (aria-pressed). toggleSnap() is the only writer; both surfaces
+// call it, so they can't drift. The transient right-click override is separate and never writes here. ---
+const snapBar=document.getElementById('snapBar');
+function reflectSnapPrefs(){
+ for(const b of moreMenu.querySelectorAll('button.msnap')){const on=snapEnabled[b.dataset.snap]!==false;b.classList.toggle('on',on);b.setAttribute('aria-checked',String(on));}
+ for(const b of snapBar.querySelectorAll('button')){const on=snapEnabled[b.dataset.snap]!==false;b.classList.toggle('on',on);b.setAttribute('aria-pressed',String(on));}}
+function toggleSnap(k){snapEnabled[k]=!(snapEnabled[k]!==false);saveSnapPrefs();reflectSnapPrefs();snapClear();}  // clear any stale marker so the change shows on the next move
+for(const b of moreMenu.querySelectorAll('button.msnap'))b.onclick=e=>{e.stopPropagation();toggleSnap(b.dataset.snap);};   // menu switch (keeps the menu open — settings, not a one-shot action)
+for(const b of snapBar.querySelectorAll('button'))b.onclick=()=>toggleSnap(b.dataset.snap);                            // quick-bar glyph
+reflectSnapPrefs();
 // --- Move/Copy split-button dropdowns: same open/close discipline as the ⋯ menu ---
 function wireCmMenu(caretId,menuId){const b=document.getElementById(caretId),m=document.getElementById(menuId);
  const close=()=>{m.classList.remove('open');b.setAttribute('aria-expanded','false');document.removeEventListener('mousedown',out,true);};
  const out=e=>{if(!m.contains(e.target)&&e.target!==b)close();};
  b.onclick=e=>{e.stopPropagation();if(m.classList.contains('open'))close();else{m.classList.add('open');b.setAttribute('aria-expanded','true');document.addEventListener('mousedown',out,true);}};
- m.addEventListener('click',e=>{if(e.target.closest('button'))close();});
+ m.addEventListener('click',e=>{const btn=e.target.closest('button');if(btn&&btn.id!=='dragMoveB')close();});  // items close the menu — except the Drag-to-move toggle, which stays open so its state flip is visible
  return {close,isOpen:()=>m.classList.contains('open')};}
-const mvMenuC=wireCmMenu('mvCaret','mvMenu'),cpMenuC=wireCmMenu('cpCaret','cpMenu');
-document.getElementById('mvB').onclick=()=>armCm('move',false);
-document.getElementById('cpB').onclick=()=>armCm('copy',false);
+const xfMenuC=wireCmMenu('xfB','xfMenu');   // one Transform dropdown holds Move, Copy, their options + the Drag-to-move toggle
 document.getElementById('mvTwoB').onclick=()=>armCm('move',false);
 document.getElementById('cpTwoB').onclick=()=>armCm('copy',false);
 document.getElementById('cpArrB').onclick=()=>armCm('copy',true);
@@ -2185,10 +2351,17 @@ const view3dApi={
  onSelect:(id,additive)=>{selDimIds.clear();sel3dDimIds.clear();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();sel3dDimIds.clear();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
+ snapEnabled:()=>snapEnabled,                                // the persistent running-snaps (⋯ menu → Snapping) — 3D honours the same on/off set
  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
  geoMode:()=>geoMode,                                        // 'el' | 'split' | null — armed Trim/Extend/Split state
  onMoveMember:(id,newWp)=>{edit(()=>{const m=byId(id);if(m)m.wp=newWp;});},  // 3D drag → write wp (undoable, autosaves, syncs 2D/chip/BOM)
+ dragMoveEnabled:()=>dragMoveOn,                                                    // the 3D view gates its plain member-drag on this
+ dragMoveHint:()=>{if(dragHintShown)return;dragHintShown=true;try{localStorage.setItem('steel:dragmovehint:v1','1');}catch(_){}toast('Drag-to-move is off — turn it on in the toolbar, or use ↔ Move (M)');},
+ onCopyDrag3d:(ids,dxMm,dyMm)=>{const k=304.8/((P&&P.pt_per_ft>0)?P.pt_per_ft:1),r6=n=>Math.round(n*1e6)/1e6;   // Ctrl+drag copy: mm delta → plan px (Y FLIPPED), clone + translate + select
+   const dpx=r6(dxMm/k),dpy=r6(-dyMm/k);
+   edit(()=>{const ns=new Set();for(const id of (ids||[])){const src=byId(id);if(!src)continue;const c=cloneMember(src);translateMembers([c],[dpx,dpy,0]);P.members.push(c);ns.add(c.id);}selIds=ns;});
+   toast('Copied '+(ids?ids.length:0)+' member'+((ids&&ids.length===1)?'':'s'));},
  onMoveEndpoint:(id,end,wp)=>{edit(()=>{const m=byId(id);if(m&&Array.isArray(m.wp)&&m.wp.length>=2)m.wp[end]=wp;});},  // 3D end-node drag → write just that endpoint
  onElevateMember:(id,dIn)=>{edit(()=>{const m=byId(id);if(!m)return;ensureMeta(m);  // 3D Alt-drag → raise/lower T.O.S by dIn inches
    if(m.role==='column'){m.col.tos=(m.col.tos!=null?m.col.tos:defaultTOS)+dIn;m.col.bos=(m.col.bos!=null?m.col.bos:0)+dIn;m.col.tosDef=false;}  // rigid raise (bos null→0, both shift) so the column isn't stretched
@@ -2200,6 +2373,7 @@ const view3dApi={
  getDimOverlays:()=>C.dim_overlays||{},   // the legend DIMENSIONS toggles {bolt_pitch,edge_clearance,cope_size} — the 3D view derives + filters overlays from this
  // 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();},
+ onSnapOnlyChanged:()=>updSnapStat(),   // keep the header snap-override chip honest for every 3D-side clear (tool disarm etc.)
  onDeleteDim3d:(id)=>{C.dims3d=(C.dims3d||[]).filter(x=>x.id!==id);sel3dDimIds.delete(id);scheduleSave();refreshDims3d();},
  onSelectDim3d:(id,mods)=>{ // Ctrl/Shift multi-select (same as parts); selecting a dim is exclusive with member/2D-dim/clip selection
   if(!id){sel3dDimIds.clear();render();return;}
@@ -2539,6 +2713,7 @@ function wire3DBar(){if(bar3dWired||!window.Steel3DView)return;bar3dWired=true;
  document.getElementById('m3dWpOff').addEventListener('keydown',ev=>{ev.stopPropagation();if(ev.key==='Enter'){ev.preventDefault();const xy=wpMenu.querySelector('button[data-wpp=xy]');if(xy)xy.click();}});}  // Enter in the offset = apply XY (the common case); stopPropagation keeps editor shortcuts out
 function applyViewState(on){            // flip the toggle + swap the canvases (no 3D side effects)
  view3d=on;
+ snapOnly=null;const V=window.Steel3DView;if(V&&V.setSnapOnly)V.setSnapOnly(null);closeSnapMenu();updSnapStat();  // switching views ends the operation → any snap override reverts
  const t2=document.getElementById('vt2d'),t3=document.getElementById('vt3d');
  t2.classList.toggle('on',!on);t2.setAttribute('aria-pressed',String(!on));
  t3.classList.toggle('on',on);t3.setAttribute('aria-pressed',String(on));
@@ -2549,6 +2724,7 @@ function applyViewState(on){            // flip the toggle + swap the canvases (
  document.getElementById('m3dBar').style.display=on?'flex':'none';
  document.getElementById('m3dCube').style.display=on?'block':'none';
  document.getElementById('m3dAxes').style.display=on?'block':'none';
+ document.getElementById('snapBar').classList.toggle('s3d',on);   // in 3D the snap bar shifts clear of the world-axis triad (bottom-right); see #snapBar.s3d
  if(!on)document.getElementById('m3dLegend').style.display='none';   // legend is shown by build3DLegend when entering 3D
 }
 async function setView(on){
@@ -3054,6 +3230,7 @@ function setPlan(i){C.active=i;P=C.plans[i];
  dimMode=false;dimChain=false;dimSplitMode=false;selDimIds=new Set();setDimMode();   // Dimension tool resets per plan (incl. chain + split); setDimMode syncs the button/body.dimon classes + clears any draft/preview/chain (dimsVisible persists across plans)
  if(gridMode||gridPick){gridMode=false;gridPick=false;document.body.classList.remove('gridpick');}   // grid panel/pick-origin disarm per plan like the other takeover tools (a leaked pick would set the origin in the WRONG sheet's display space)
  csaxisMode=false;setCsMode();                     // set-axes tool resets per plan; P.frame itself is per-plan data (persisted), so it stays
+ snapOnlyClear2d();closeSnapMenu();                // a snap override never outlives its plan (different geometry)
  disarmCm();                                       // Move/Copy resets per plan too (its counts persist — they're session prefs, not plan data)
  defaultTOS=(P.default_tos!=null?P.default_tos:198);
  P.default_tos=defaultTOS;  // make the default explicit so the 3D scene + bake use the SAME TOS the editor/dots do (contractToScene falls back to 0, not 198 — keeping them in sync stops the end dots floating off the steel)
@@ -3142,7 +3319,28 @@ if(new URLSearchParams(location.search).get('selftest')==='1'){(function(){
     r=r&&C.joints.length===1&&C.joints[0].main==='a1';             // …and the moved member kept its connection
    }finally{C.plans=sp;C.active=sA;P=sP;undo=su;redo=sr;selIds=ss;C.joints=sj;render();}
    return r;})(),'cross-plan undo+redo restores both plans + moved joints');
-  const msg=fails.length?('SELFTEST FAIL: '+fails.join(' | ')):'SELFTEST PASS (local-frame math)';
+  // 9) intersection snap (×) + the right-click snap override
+  {const sm=P.members,ss=P.segments,sd=P.dims,sdv=dimsVisible,sz=zoom,so=snapOnly;
+   zoom=1;P.members=[{id:'a',wp:[[0,0],[100,0]]},{id:'b',wp:[[50,-50],[50,50]]}];P.segments=[];P.dims=[];dimsVisible=false;
+   buildSnap(null,{noGrid:true});
+   const i1=snap(52,2);ok(i1.hit&&i1.kind==='int'&&pnear([i1.x,i1.y],[50,0]),'snap → intersection (×) at the crossing, outranks midpoint');
+   const e2=snap(1,1);ok(e2.hit&&e2.kind==='end','snap → endpoint still outranks intersection');
+   snapOnly='mid';const o1=snap(1,1);ok(!o1.hit&&pnear([o1.x,o1.y],[1,1]),'override mid → endpoint ignored, raw point back');
+   const o2=snap(50,2);ok(o2.hit&&o2.kind==='mid'&&pnear([o2.x,o2.y],[50,0]),'override mid → midpoint found');
+   snapOnly='none';const o3=snap(1,1);ok(!o3.hit&&pnear([o3.x,o3.y],[1,1]),'override none (free) → no snap at all');
+   snapOnly=so;P.members=sm;P.segments=ss;P.dims=sd;dimsVisible=sdv;zoom=sz;}
+  // 10) extension snap (dashed) + persistent running-snaps (⋯ menu → Snapping)
+  {const sm=P.members,ss=P.segments,sd=P.dims,sdv=dimsVisible,sz=zoom,se=Object.assign({},snapEnabled);
+   zoom=1;P.members=[{id:'a',wp:[[0,0],[100,0]]}];P.segments=[];P.dims=[];dimsVisible=false;buildSnap(null,{noGrid:true});
+   snapEnabled.ext=false;const x0=snap(150,1);ok(!x0.hit,'extension OFF by default → no snap past the end');
+   snapEnabled.ext=true;const x1=snap(150,1);ok(x1.hit&&x1.kind==='ext'&&pnear([x1.x,x1.y],[150,0])&&pnear(snapExtFrom,[100,0]),'extension ON → snaps onto the ray past the end, dashed from the near endpoint');
+   const x2=snap(50,1);ok(x2.kind!=='ext','extension does NOT fire ON the segment (that is the nearest/on-line snap)');
+   snapEnabled.end=false;const x3=snap(1,1);ok(x3.kind!=='end','disabling Endpoint in the running-snaps stops endpoint snapping');
+   const ax=snap(2,40);ok(pnear([ax.x,ax.y],[2,40]),'disabling Endpoint also stops the axis-align pull to an endpoint column (Codex fix)');
+   snapEnabled.end=true;const x4=snap(1,1);ok(x4.kind==='end','re-enabling Endpoint restores it');
+   const ax2=snap(2,40);ok(ax2.x===0,'with Endpoint on, axis-align still pulls to the endpoint column');
+   Object.assign(snapEnabled,se);P.members=sm;P.segments=ss;P.dims=sd;dimsVisible=sdv;zoom=sz;}
+  const msg=fails.length?('SELFTEST FAIL: '+fails.join(' | ')):'SELFTEST PASS (frame + snap + transform math)';
   console[fails.length?'error':'log'](msg);try{toast(msg);}catch(_){}
 })();}
 // --- provenance caption: show contract.source when present (read from <name> · <sheet> · <read_at>) ---

package/package.json

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