@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/editor/keypad.ts

@@ -8,15 +8,25 @@ import { closeKeypad, refreshKeypad, type KeypadSpec } from './ports';
   ("fresh"), the fraction and ( ) keys, the line under the display, laser readings, and reading the value on Apply.
 */
 
-/** `error`: why Apply was refused, shown until the next edit. */
-interface Kp { spec: KeypadSpec; text: string; fresh: boolean; error?: string }
+/** `error`: why Apply was refused, shown until the next edit. `host`: the host's own keypad is showing it. */
+interface Kp {
+  spec: KeypadSpec; text: string; fresh: boolean; error?: string; host?: boolean;
+  /** the last laser reading's record (laserReading's capture), and what it put in the display: kept while that's unchanged */
+  capture?: { of: unknown; text: string };
+}
 const kps = sessionState(() => ({ cur: null as Kp | null }));
 
 export const FRACTIONS = ['1/16', '1/8', '1/4', '3/8', '1/2', '5/8', '3/4', '7/8'];
-/** Key layouts: 'space', 'laser', '⌫' and '( )' are special keys. */
+/**
+ * Key layouts, phone-style (1 2 3 on top): '⌫' and '( )' are special keys. In lengths the 0 is three keys wide
+ * (`keySpan`); the fraction keys put their own space before them, so there's no space key. (A laser reading goes
+ * straight into an open keypad: no key for it.)
+ */
 export const keyLayout = (numeric?: boolean): string[] => numeric
-  ? ['7', '8', '9', '⌫', '4', '5', '6', '-', '1', '2', '3', '/', '+', '0', '.', '( )']
-  : ['7', '8', '9', '⌫', '4', '5', '6', "'", '1', '2', '3', '"', 'space', '0', '.', 'laser'];
+  ? ['1', '2', '3', '⌫', '4', '5', '6', '-', '7', '8', '9', '+', '0', '.', '/', '( )']
+  : ['1', '2', '3', '⌫', '4', '5', '6', '"', '7', '8', '9', "'", '0', '.'];
+/** How many columns (of four) a key takes. */
+export const keySpan = (k: string, numeric?: boolean): number => (k === '0' && !numeric ? 3 : 1);
 
 export const keypadOpen = (): boolean => !!kps.cur;
 export const keypadSpec = (): KeypadSpec | null => kps.cur?.spec ?? null;
@@ -25,10 +35,14 @@ export const keypadFresh = (): boolean => !!kps.cur?.fresh;
 /** The fraction row shows for lengths in feet and inches, not for degrees or millimetres. */
 export const fractionRowShown = (): boolean => !(kps.cur?.spec.numeric || settings.unit === 'mm');
 
-export function keypadStart(spec: KeypadSpec): void {
-  kps.cur = { spec, text: spec.initial || '', fresh: !!spec.selectAll };
+/** Open the keypad for `spec`; `host`: the host shows its own keypad for it (see react/hostKeypad.ts). */
+export function keypadStart(spec: KeypadSpec, host = false): void {
+  kps.cur = { spec, text: spec.initial || '', fresh: !!spec.selectAll, host };
 }
 
+/** Whether the open keypad is the host's own. */
+export const keypadOnHost = (): boolean => !!kps.cur?.host;
+
 /** Close the keypad; returns what it was opened with. */
 export function keypadEnd(): KeypadSpec | null {
   const spec = kps.cur?.spec ?? null;
@@ -89,14 +103,23 @@ export function keypadSetReading(v: number): void {
   kps.cur.error = undefined;
 }
 
-/** A laser reading into an open length keypad. False if this keypad can't take one (degrees, or laser turned off). */
-export function keypadTakeLaser(v: number): boolean {
+/**
+ * A laser reading into an open length keypad. False if this keypad can't take one (degrees, or laser turned off).
+ * The host's own keypad can't be typed into from here, so a reading there is the value: it's applied at once.
+ * `capture`, the host's record of the reading, goes with the value if it's applied as it came in (see KeypadSpec.onDone).
+ */
+export function keypadTakeLaser(v: number, capture?: unknown): boolean {
   const k = kps.cur;
   if (!k || k.spec.laser === false || k.spec.numeric) return false;
+  if (k.host) { keypadSubmit(v, capture); return true; }
   keypadSetReading(v);
+  k.capture = capture !== undefined ? { of: capture, text: k.text } : undefined;
   return true;
 }
 
+/** The last reading's record, if the display still shows what it put there. */
+const readingCapture = (k: Kp): unknown => (k.capture && k.capture.text === k.text ? k.capture.of : undefined);
+
 const parse = (k: Kp): number | null => (k.spec.numeric ? parseNum(k.text) : parseLen(k.text));
 
 /** The value currently typed, or null if none/unreadable (for live previews on the canvas). */
@@ -123,6 +146,15 @@ export function keypadValue(): { v: number } | { error: string } {
   return v == null ? { error: 'Enter a length like 12\' 6" or 150.5' } : { v };
 }
 
+/** A value from the host's own keypad (or a laser reading into it): close the keypad and hand it on, as Apply does. */
+export function keypadSubmit(v: number, capture?: unknown): void {
+  const k = kps.cur;
+  if (!k) return;
+  const done = k.spec.onDone;
+  closeKeypad();
+  if (done) done(v, capture);
+}
+
 /**
  * Apply: close the keypad and hand the value to whoever opened it — or, if it can't be read, keep the keypad open
  * and say so under the display.
@@ -132,7 +164,7 @@ export function keypadApply(): void {
   if (!k) return;
   const r = keypadValue();
   if ('error' in r) { k.error = r.error; refreshKeypad(); return; }
-  const done = k.spec.onDone;
+  const done = k.spec.onDone, capture = readingCapture(k);
   closeKeypad();
-  if (done) done(r.v);
+  if (done) done(r.v, capture);
 }

package/src/editor/keys.ts

@@ -5,9 +5,14 @@ import { saveSoon } from '../model/store';
 import { fitView, requestDraw } from '../render/view';
 import { cancelTool, setTool, tools } from '../tools/registry';
 import { applyCtxAction, deleteSelection } from './actions';
+import { addLinks, linkPlusVisible, openSelectedLink, selectedLink } from './linkActions';
 import { keys } from './gestures';
 import { keypadApply, keypadDeleteLast, keypadInsert, keypadOpen } from './keypad';
-import { toggleConstr } from './mode';
+import { confirmCancel, confirmChoose, confirmOpen } from './confirm';
+import { toggleConstr, toggleWalls } from './mode';
+import { closeElevation, elevOpen, WALL_KEYS } from './elevation';
+import { key3d } from './view3d';
+import { is3d } from './view3dState';
 import {
   closeKeypad, dismissConflict, dismissPopovers, refreshKeypad, saveNowPort, setCursor, toast, updateCtx, updateHint,
 } from './ports';
@@ -16,20 +21,28 @@ import {
   Keyboard shortcuts for the plan, whatever delivers the keys (DOM key events, a hardware keyboard on a tablet).
   While the keypad is open, keys type into it. Otherwise: ⌘Z / ⇧⌘Z / ⌘Y undo and redo, ⌘S saves, Esc steps back one
   level at a time, Delete removes the selection, ⇧ + a letter adds a constraint, single letters pick tools, F fits,
-  G toggles grid snap, X toggles construction lines, and Space held turns a drag into a pan.
+  G toggles grid snap, W walls, X construction lines, and Space held turns a drag into a pan. In Annotate, + adds files
+  and measurements of the job and Enter opens the selected one. In the 3D tab: F frames everything and Esc lets go of
+  what's tapped.
 */
 
 /** A key press: `key` as in KeyboardEvent.key; `mod` is ⌘ or Ctrl. */
 export interface KeyIn { key: string; shift: boolean; mod: boolean; alt: boolean }
 
 const TOOLKEYS: Record<Mode, Record<string, string>> = {
-  draft: { v: 'select', l: 'line', s: 'freehand', w: 'wall', r: 'rect', c: 'circle', a: 'arc', d: 'dim', t: 'trim', o: 'offset', b: 'door', n: 'window', m: 'room' },
-  annotate: { v: 'aselect', k: 'arrow', p: 'pen', n: 'text', q: 'cloud', j: 'calib' },
+  draft: { v: 'select', l: 'line', s: 'freehand', r: 'rect', c: 'circle', a: 'arc', d: 'dim', t: 'trim', o: 'offset', b: 'door', n: 'window', m: 'room' },
+  annotate: { v: 'aselect', l: 'mline', k: 'arrow', r: 'mrect', c: 'mcircle', p: 'pen', n: 'text', q: 'cloud', j: 'calib' },
 };
 const SHIFT_CONS: Record<string, string> = { H: 'h', V: 'v', P: 'par', R: 'perp', L: 'col', T: 'tan', E: 'eq', M: 'mid', O: 'online', F: 'lock' };
 
 /** Handle a key press on the plan. Returns true when the key was used, so the host should stop its default action. */
 export function keyDown(e: KeyIn): boolean {
+  // a question up: Enter is its first choice, Escape closes it
+  if (confirmOpen()) {
+    if (e.key === 'Enter') confirmChoose(0);
+    else if (e.key === 'Escape') confirmCancel();
+    return !e.mod;
+  }
   if (ed.readOnly) {
     // view only: fit, and Space to pan
     if (e.key === ' ' && !keys.spaceDown) { keys.spaceDown = true; setCursor('grab'); return true; }
@@ -50,6 +63,8 @@ export function keyDown(e: KeyIn): boolean {
   if (e.mod && k === 'y') { redo(); return true; }
   if (e.mod && k === 's') { saveNowPort(); return true; }
   if (e.mod) return false;
+  // (the 3D tab has no tools)
+  if (is3d()) return key3d(e);
   const t = tools[ed.tool];
   if (t && t.key && t.key(e)) return true;
   // Esc steps back one level at a time: conflict sheet → popover → in-progress step + selection → the Select tool
@@ -64,6 +79,7 @@ export function keyDown(e: KeyIn): boolean {
     }
     const home = ed.mode === 'draft' ? 'select' : 'aselect';
     if (ed.tool !== home) setTool(home);
+    else if (elevOpen()) closeElevation(); // the wall view: back to the plan
     return false;
   }
   if (e.key === 'Delete' || e.key === 'Backspace') {
@@ -71,6 +87,9 @@ export function keyDown(e: KeyIn): boolean {
     deleteSelection();
     return true;
   }
+  // Annotate: + adds files and measurements (the + by the rail), Enter opens the selected link
+  if ((e.key === '+' || e.key === '=') && linkPlusVisible()) { void addLinks(); return true; }
+  if (e.key === 'Enter' && ed.mode === 'annotate' && selectedLink()) { openSelectedLink(); return true; }
   if (e.shift) {
     const c = SHIFT_CONS[e.key.toUpperCase()];
     if (c && ed.mode === 'draft') { applyCtxAction(c); return true; }
@@ -79,7 +98,8 @@ export function keyDown(e: KeyIn): boolean {
   if (k === 'f') { fitView(); return false; }
   if (k === 'g') { settings.snapGrid = !settings.snapGrid; toast('Snap to grid ' + (settings.snapGrid ? 'on' : 'off')); updateCtx(); saveSoon(); return false; }
   if (k === 'x' && ed.mode === 'draft') { toggleConstr(); toast(ed.drawConstr ? 'Drawing construction lines' : 'Drawing regular lines'); return false; }
-  const tk = TOOLKEYS[ed.mode][k];
+  if (k === 'w' && ed.mode === 'draft' && !elevOpen()) { toggleWalls(); toast(ed.drawWalls ? 'Drawing walls' : 'Drawing lines'); return false; }
+  const tk = (elevOpen() ? WALL_KEYS : TOOLKEYS[ed.mode])[k];
   if (tk) setTool(tk);
   return false;
 }

package/src/editor/laser.ts

@@ -3,9 +3,13 @@ import { ed } from '../app/state';
 import { dropHistory, pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { sessionState } from '../model/session';
+import { measure } from '../model/constraints';
+import { defaultFace, edgeLabel, edgeOf, wallOf } from '../model/planGeom';
 import { lengthDimOf, lineLen } from '../model/sketch';
 import { SK } from '../model/store';
-import { setDimValue } from '../tools/dim';
+import { faceLength } from '../model/wallfaces';
+import { V } from '../render/view';
+import { LENGTH_SET_ALREADY, setDimValue, type DimValueOpts } from '../tools/dim';
 import { fmtLen } from '../units';
 import { keypadTakeLaser } from './keypad';
 import { refreshKeypad, refreshTray, toast } from './ports';
@@ -16,33 +20,101 @@ import { selInfo } from './selection';
   keypad, onto the one selected line, or to the tray, where it can be dragged onto a line later.
 */
 
-export interface Reading { id: string; v: number }
+/** A reading, and the host's record of it (laserReading's `capture`), kept with it in the tray. */
+export interface Reading { id: string; v: number; capture?: unknown }
 /** `external`: a real measure the host app is connected to (otherwise the harness's simulated one). */
 export const laser = sessionState(() => ({ on: false, external: false, readings: [] as Reading[] }));
 
-/** Set a line's length: edit its length dimension, or add a driving one. */
-export function setLineLength(lid: string, v: number): void {
-  const sk = SK();
+/** What a new dimension takes from DimValueOpts: its link, and the reading it's from. */
+const linkFields = (o: DimValueOpts) => ({ ...(o.link ? { measurementRef: o.link } : {}), ...(o.capture !== undefined && !o.link ? { capture: o.capture } : {}) });
+
+/**
+ * Set a line's length: edit its length dimension, or add a driving one. A wall's is measured on `side`, the edge picked
+ * — or, picked whole, where the + measures it (the side a space is on, else its centerline). `opts`: a measurement of
+ * the job it's linked to, the laser reading it's from (see setDimValue). Whether it took (false: refused, or asked).
+ */
+export function setLineLength(lid: string, v: number, side?: 1 | -1, opts: DimValueOpts = {}): boolean {
+  const sk = SK(), l = sk.lines[lid];
+  if (!l) return false;
+  const wall = l.kind === 'wall' && !l.constr;
   const ex = lengthDimOf(sk, lid);
-  if (ex) { setDimValue(ex, v); return; }
-  const l = sk.lines[lid];
+  if (ex) return setDimValue(ex, v, wall && side ? { face: side } : undefined, opts);
+  const face = wall ? side ?? defaultFace(sk, lid, ed.wallTap?.id === lid ? ed.wallTap.side : undefined) : undefined;
   pushHistory();
-  const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: 0 });
+  const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: face ? (face * 30) / V().s : 0, ...(face ? { face } : {}), ...linkFields(opts) });
+  // a measurement of the job drives a line, or nothing: not one whose length the drawing already sets
+  if (r.ok && r.ref && opts.link) {
+    delete sk.cons[r.id!];
+    dropHistory();
+    toast(LENGTH_SET_ALREADY, { warn: true });
+    afterEdit();
+    return false;
+  }
   if (!r.ok) dropHistory();
   afterEdit();
+  return r.ok;
 }
 
-/** A reading arrived: into the keypad, onto the selected line, or into the tray (newest first, at most 8). */
-export function applyReading(v: number): void {
-  if (keypadTakeLaser(v)) { refreshKeypad(); return; }
-  const s = selInfo(), sk = SK();
-  if (ed.mode === 'draft' && s.lines.length === 1 && s.n === 1) {
-    const kind = sk.lines[s.lines[0]].kind === 'wall' ? 'wall' : 'line';
-    setLineLength(s.lines[0], v);
-    toast('Laser ' + fmtLen(v) + ' applied to the selected ' + kind);
+/** A circle's or arc's diameter dimension (a fillet's radius), if it has one. */
+const diamDimOf = (id: string): string | undefined => { const sk = SK(); return Object.keys(sk.cons).find(k => sk.cons[k].type === 'diam' && sk.cons[k].c === id); };
+
+/**
+ * Set a circle's or arc's diameter: edit its diameter dimension (a fillet's radius, as the radius), or add a driving
+ * one. A curved wall's is measured across `side`, the edge picked — or, picked whole, where the + measures it.
+ */
+export function setCurveDiameter(id: string, v: number, side?: 1 | -1, opts: DimValueOpts = {}): boolean {
+  const sk = SK();
+  if (!sk.circles[id] && !sk.arcs[id]) return false;
+  const wall = !!wallOf(sk, id), ex = diamDimOf(id);
+  if (ex) return setDimValue(ex, sk.cons[ex].rad ? v * 2 : v, wall && side ? { face: side } : undefined, opts);
+  const face = wall ? side ?? defaultFace(sk, id, ed.wallTap?.id === id ? ed.wallTap.side : undefined) : undefined;
+  pushHistory();
+  const r = tryAddConstraint({ type: 'diam', c: id, value: v, driving: true, ...(face ? { face } : {}), ...linkFields(opts) });
+  if (!r.ok) dropHistory();
+  afterEdit();
+  return r.ok;
+}
+
+/** What a reading goes on — a selected line, circle, arc or wall edge (or one it's dropped on): its id, and the edge's side. */
+function readingTarget(id: string): [string, (1 | -1)?] {
+  const sk = SK();
+  return sk.lines[id] || sk.circles[id] || sk.arcs[id] ? [id] : edgeOf(id);
+}
+
+/** A reading put on a line's (or straight wall's) length, or a circle's or arc's diameter. */
+function setReading(id: string, v: number, side?: 1 | -1, capture?: unknown): void {
+  if (SK().lines[id]) setLineLength(id, v, side, { capture }); else setCurveDiameter(id, v, side, { capture });
+}
+
+/**
+ * What a reading was put on, as the toast says it: 'the selected line', 'the inside edge of the wall', 'the Kitchen
+ * side of the wall', 'the circle across its inner edge'.
+ */
+function appliedTo(id: string): string {
+  const sk = SK(), l = sk.lines[id];
+  const kind = l ? (l.kind === 'wall' ? 'wall' : 'line') : sk.circles[id] ? 'circle' : 'arc';
+  const ex = l ? lengthDimOf(sk, id) : diamDimOf(id), face = ex ? sk.cons[ex].face : undefined;
+  if (!face) return 'the selected ' + kind;
+  const e = edgeLabel(sk, id, face), lower = e.endsWith(' edge') ? e[0].toLowerCase() + e.slice(1) : e;
+  return l ? 'the ' + lower + ' of the ' + kind : 'the ' + kind + ' across its ' + lower;
+}
+
+/**
+ * A reading arrived: into the keypad, onto the selected line or curve, or into the tray (newest first, at most 8).
+ * `capture` is the host's record of it (its device, its number), kept with the dimension it sets until that's saved
+ * to the group — or handed to the job with it, for one linked to a measurement there.
+ */
+export function applyReading(v: number, capture?: unknown): void {
+  if (keypadTakeLaser(v, capture)) { refreshKeypad(); return; }
+  const s = selInfo();
+  const one = s.n === 1 ? s.lines[0] ?? s.wfaces[0] ?? s.curves[0] : undefined;
+  if (ed.mode === 'draft' && one) {
+    const [id, side] = readingTarget(one);
+    setReading(id, v, side, capture);
+    toast('Laser ' + fmtLen(v) + ' applied to ' + appliedTo(id));
     return;
   }
-  laser.readings.unshift({ id: uid('m'), v });
+  laser.readings.unshift({ id: uid('m'), v, ...(capture !== undefined ? { capture } : {}) });
   laser.readings = laser.readings.slice(0, 8);
   refreshTray();
   toast('Reading ' + fmtLen(v) + ' saved to the tray');
@@ -55,14 +127,18 @@ export function applyReading(v: number): void {
 export function useTrayReading(id: string, dropOn?: string | null): void {
   const r = laser.readings.find(x => x.id === id);
   if (!r) return;
+  // (a line's id, or a wall edge's)
   let target: string | null = dropOn ?? null;
   if (dropOn === undefined) {
     const s = selInfo();
     if (s.lines.length === 1) target = s.lines[0];
-    else toast('Select a line first, or drag the reading onto one.');
+    else if (s.wfaces.length === 1) target = s.wfaces[0];
+    else if (s.curves.length === 1) target = s.curves[0];
+    else toast('Select a line first, or drag the reading onto one.', { warn: true });
   }
   if (target && ed.mode === 'draft') {
-    setLineLength(target, r.v);
+    const [id, side] = readingTarget(target);
+    setReading(id, r.v, side, r.capture);
     laser.readings = laser.readings.filter(x => x !== r);
     refreshTray();
     toast(fmtLen(r.v) + ' applied');
@@ -76,7 +152,7 @@ export function useTrayReading(id: string, dropOn?: string | null): void {
 export function keypadLaserReading(): number | null {
   if (!laser.external) return simulatedReading();
   const r = laser.readings.shift();
-  if (!r) { toast('Take a reading with the laser: it goes straight into this keypad.'); return null; }
+  if (!r) { toast('Take a reading with the laser: it goes straight into this keypad.', { warn: true }); return null; }
   refreshTray();
   return r.v;
 }
@@ -86,5 +162,7 @@ export function simulatedReading(): number {
   const s = selInfo(), sk = SK();
   let base = 48 + Math.random() * 168;
   if (s.lines.length === 1) base = lineLen(sk, sk.lines[s.lines[0]]);
+  else if (s.wfaces.length === 1) { const [id, side] = edgeOf(s.wfaces[0]); base = sk.lines[id] ? faceLength(sk, id, side) : measure(sk, { type: 'diam', c: id, face: side }); }
+  else if (s.curves.length === 1) base = measure(sk, { type: 'diam', c: s.curves[0] });
   return Math.max(1, Math.round((base + (Math.random() - 0.5) * 2.2) * 16) / 16);
 }

package/src/editor/linkActions.ts

@@ -0,0 +1,194 @@
+import { afterEdit } from '../app/edit';
+import { ed } from '../app/state';
+import { clamp } from '../model/geom';
+import { pushHistory } from '../model/history';
+import { uid } from '../model/ids';
+import { isLink, LINK_COLOR, LINK_MAX_IN, LINK_MIN_IN, LINK_TILE_PX, linkInfoOf, linkName, linkSide, linkSnapshot } from '../model/links';
+import { dimMeasurement } from '../model/measurement';
+import { linkAt } from '../render/hit';
+import { askConfirm } from './confirm';
+import { SK, store } from '../model/store';
+import type { LinkTarget, Note } from '../model/types';
+import { cvs, linkBox, mainT, requestDraw, s2w } from '../render/view';
+import { setTool } from '../tools/registry';
+import { elevOpen } from './elevation';
+import { is3d } from './view3dState';
+import { canLink, linksHost, openLink, pickLinks } from './links';
+import { toast } from './ports';
+
+/*
+  Linking. In Annotate the + puts the job's files the person picks on the plan as tiles (selected, to move them where
+  they belong), and a selected tile is opened, or given a leader, from the bar. Measurements come into a drawing only
+  as the lengths of lines, from a line's length keypad in Draft (tools/dim.ts): a linked dimension is opened or let go
+  of from the bar, and one of the drawing's own driving dimensions is saved to the drawing's group as a measurement of
+  the job (Save to group), linked to it from then on.
+*/
+
+/** Whether the + shows: Annotate's plan (not the wall view or 3D), for someone who can edit, with a host that links. */
+export const linkPlusVisible = (): boolean => !ed.readOnly && ed.mode === 'annotate' && !elevOpen() && !is3d() && canLink();
+
+export const LINK_PLUS_LABEL = 'Add a file';
+
+/** The one selected tile, if a tile is all that's selected. */
+export function selectedLink(): (Note & { link: LinkTarget }) | null {
+  if (ed.sel.length !== 1 || ed.sel[0].type !== 'note') return null;
+  const n = SK().notes.find(x => x.id === ed.sel[0].id);
+  return n && isLink(n) ? n : null;
+}
+
+/** Whether a tile's target can be opened: it's there (as far as the host has said), and the host can open it. */
+export function canOpenLink(t: LinkTarget): boolean {
+  const info = linkInfoOf(t);
+  return info?.exists !== false && info?.canOpen !== false;
+}
+
+/**
+ * The +: the person picks from the job, and what they picked goes on the plan (one undo step) in the middle of the
+ * screen, side by side and in rows if there are many — moved down and across, all together, from tiles already there
+ * — all selected, with Select markup on.
+ */
+export async function addLinks(): Promise<void> {
+  if (!linkPlusVisible()) return;
+  const pageId = store.curPageId;
+  const picked = await pickLinks();
+  if (!picked.length) return;
+  // (the person may have moved on meanwhile: another page, the other tab)
+  if (store.curPageId !== pageId || !linkPlusVisible()) { toast('Nothing was added: the drawing changed while you were picking. Try again.', { warn: true }); return; }
+  // (the page's tiles are all one size: the first is placed at a comfortable size on the screen, the rest follow it)
+  const T = mainT(), sk = SK(), ts = pageLinkSize(sk) ?? Math.round(clamp(LINK_TILE_PX / T.s, LINK_MIN_IN, LINK_MAX_IN) * 4) / 4;
+  // each a tile and a gap from the next, as many to a row as fit the screen
+  const cell = ts + LINK_GAP_PX / T.s, step = 30 / T.s;
+  const cols = Math.max(1, Math.min(picked.length, Math.floor((cvs.W - 160) / (cell * T.s))));
+  const rows = Math.ceil(picked.length / cols), [cx, cy] = s2w(cvs.W / 2, cvs.H / 2);
+  const spots = picked.map((_, i) => [cx + ((i % cols) - (cols - 1) / 2) * cell, cy - (Math.floor(i / cols) - (rows - 1) / 2) * cell]);
+  const taken = (px: number, py: number) => sk.notes.some(n => n.type === 'link' && Math.abs((n.x ?? 0) - px) < step / 2 && Math.abs((n.y ?? 0) - py) < step / 2);
+  let k = 0;
+  while (k < 40 && spots.some(([x, y]) => taken(x + k * step, y - k * step))) k++;
+  pushHistory();
+  const ids = picked.map((t, i) => {
+    const n: Note = { id: uid('lk'), type: 'link', x: spots[i][0] + k * step, y: spots[i][1] - k * step, ts, color: LINK_COLOR, link: linkSnapshot(t) };
+    sk.notes.push(n);
+    return n.id;
+  });
+  setTool('aselect');
+  ed.sel = ids.map(id => ({ type: 'note' as const, id }));
+  afterEdit();
+}
+
+/** The space between tiles added together, on the screen (points). */
+const LINK_GAP_PX = 16;
+
+/*
+  Every tile on a page is one size, on the drawing (so it zooms with the plan and prints at that size): the Tile size
+  slider above the bar, shown while a tile is selected, sizes them all together.
+*/
+
+/** The size of the page's tiles, inches on the drawing (null: it has none). */
+export function pageLinkSize(sk = SK()): number | null {
+  const n = sk.notes.find(isLink);
+  return n ? linkSide(n) : null;
+}
+
+/** Whether the Tile size slider shows: Annotate's plan, for someone who can edit, with a tile among what's selected. */
+export function linkSizeVisible(): boolean {
+  if (ed.readOnly || ed.mode !== 'annotate' || elevOpen() || is3d() || !ed.sel.length) return false;
+  const sk = SK();
+  return ed.sel.some(x => x.type === 'note' && sk.notes.find(n => n.id === x.id)?.type === 'link');
+}
+
+/**
+ * Size every tile on the page (inches, to the quarter, from LINK_MIN_IN to LINK_MAX_IN), drawn at once — for the slider
+ * as it moves. The caller makes the undo step before, and finishes the edit after.
+ */
+export function setLinkSize(inches: number): void {
+  const v = Math.round(clamp(inches, LINK_MIN_IN, LINK_MAX_IN) * 4) / 4;
+  for (const n of SK().notes) if (isLink(n)) n.ts = v;
+  requestDraw();
+}
+
+/** The slider runs along a log scale (a few inches to many feet, each step as noticeable as the last): 0 to SIZE_STEPS. */
+export const SIZE_STEPS = 1000;
+const LOG_MIN = Math.log(LINK_MIN_IN), LOG_SPAN = Math.log(LINK_MAX_IN) - LOG_MIN;
+export const sizeToStep = (inches: number): number => Math.round(((Math.log(clamp(inches, LINK_MIN_IN, LINK_MAX_IN)) - LOG_MIN) / LOG_SPAN) * SIZE_STEPS);
+export const stepToSize = (step: number): number => Math.exp(LOG_MIN + (clamp(step, 0, SIZE_STEPS) / SIZE_STEPS) * LOG_SPAN);
+
+/** A tile's leader on or off. On, it points out beside the tile (to the right, or the left near the screen's edge). */
+export function toggleLeader(id: string): void {
+  const n = SK().notes.find(x => x.id === id);
+  if (!n || !isLink(n)) return;
+  pushHistory();
+  if (n.leader) delete n.leader;
+  else {
+    const b = linkBox(mainT(), n), right = b.x + b.s + 80 < cvs.W - 24;
+    const [x, y] = s2w(right ? b.x + b.s + 70 : b.x - 70, b.cy + 50);
+    n.leader = [x, y];
+  }
+  afterEdit();
+}
+
+/** Open what the selected tile is for. */
+export function openSelectedLink(): void {
+  const n = selectedLink();
+  if (!n) return;
+  if (!canOpenLink(n.link)) { toast(linkInfoOf(n.link)?.exists === false ? 'That’s been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
+  openLink(n.link);
+}
+
+/** A view-only tap on the plan: on a link's tile, the person is asked, then what it's for opens. */
+export function readOnlyTap(sx: number, sy: number, touch: boolean): void {
+  if (!ed.readOnly || !canLink()) return;
+  const n = linkAt(sx, sy, touch);
+  if (!n || !canOpenLink(n.link)) return;
+  const t = n.link, where = linkInfoOf(t)?.groupName ?? t.groupName;
+  askConfirm({
+    title: 'Open ' + linkName(t) + '?',
+    msg: where ? 'It’s in ' + where + '.' : undefined,
+    choices: [{ label: 'Open', run: () => openLink(t) }, { label: 'Cancel', run: () => {} }],
+  });
+}
+
+/** Let go of a dimension's link: its value stays, the drawing's alone now. */
+export function unlinkDim(id: string): void {
+  const c = SK().cons[id];
+  if (!c?.measurementRef) return;
+  pushHistory();
+  delete c.measurementRef;
+  afterEdit();
+}
+
+/** Open the measurement a dimension is linked to. */
+export function openDimLink(id: string): void {
+  const t = SK().cons[id]?.measurementRef;
+  if (!t) return;
+  if (!canOpenLink(t)) { toast(linkInfoOf(t)?.exists === false ? 'That measurement has been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
+  openLink(t);
+}
+
+/**
+ * Whether a dimension can be saved to the drawing's group: one of the drawing's own driving dimensions with a value,
+ * on the plan, with a host that can save one there.
+ */
+export function canSaveDim(id: string): boolean {
+  const c = SK().cons[id], h = linksHost();
+  return !!c && !ed.readOnly && !elevOpen() && !!h?.saveMeasurement && h.canSave !== false && !c.measurementRef && !c.measurementId && !!dimMeasurement(c);
+}
+
+/**
+ * Save to group: the dimension becomes a measurement of the drawing's group (in its list, like any other — with the
+ * laser reading it's from, if one set it), and the dimension is linked to it from then on.
+ */
+export async function saveDimToGroup(id: string): Promise<void> {
+  const h = linksHost(), c = SK().cons[id];
+  if (!h || !c || !canSaveDim(id)) return;
+  const m = dimMeasurement(c)!, pageId = store.curPageId, was = JSON.stringify(c);
+  let t: LinkTarget | null = null;
+  try { t = await h.saveMeasurement!({ kind: m.kind, value: m.value, ...(c.capture !== undefined ? { capture: c.capture } : {}) }); } catch { t = null; }
+  if (!t) { toast('It couldn’t be saved to the group. Check the connection and try again.', { warn: true }); return; }
+  // (the drawing may have moved on meanwhile: the dimension's linked as it was saved, or not at all)
+  const cur = store.curPageId === pageId ? SK().cons[id] : undefined;
+  if (!cur || JSON.stringify(cur) !== was) { toast('Saved to the group, but the dimension changed meanwhile, so it isn’t linked. To link it, select its line, tap +, and pick it under the keys.', { warn: true }); return; }
+  pushHistory();
+  cur.measurementRef = linkSnapshot(t);
+  delete cur.capture;
+  afterEdit();
+}

package/src/editor/linkFollow.ts

@@ -0,0 +1,43 @@
+import { allCons } from '../model/faces';
+import { linkInfoOf } from '../model/links';
+import { dimMeasurement, dimValueOf } from '../model/measurement';
+import { onSessionReset } from '../model/session';
+import { SK, store } from '../model/store';
+import { setDimValue } from '../tools/dim';
+import { linksHost, onLinkInfo } from './links';
+import { staleEcho } from './linkWrite';
+
+/*
+  Dimensions linked to measurements of the job follow them: when the job says a measurement is something else now
+  (changed elsewhere, on another device, by someone else), or the drawing has a different value for it (an undo past
+  a change both made), the dimension takes the job's value. On the page being edited the drawing solves to it, as a
+  step of no undo of its own; on other pages the value is set, and the drawing solves when that page is next edited.
+  One the drawing can't hold is left as it is (and not tried again until the job's value changes).
+*/
+
+/** Values tried on dimensions and refused, by "page|constraint": not tried again until the job's value changes. */
+const refused = new Map<string, number>();
+let following = false;
+onSessionReset(() => { refused.clear(); following = false; });
+
+/** Bring every linked dimension in the project to what the job says it is now. */
+export function followLinked(): void {
+  const p = store.project;
+  if (following || !p || !linksHost()) return;
+  following = true;
+  try {
+    for (const pg of p.pages) for (const [cid, c] of allCons(pg.sk)) {
+      const t = c.measurementRef, info = t && linkInfoOf(t);
+      if (!t || !info || info.exists === false || info.value == null || staleEcho(t, info.value)) continue;
+      const m = dimMeasurement(c), key = pg.id + '|' + cid;
+      if (!m || m.value === info.value) { refused.delete(key); continue; }
+      if (refused.get(key) === info.value) continue;
+      const v = dimValueOf(c, { value: info.value });
+      if (pg.id === store.curPageId && SK().cons[cid] === c) {
+        if (!setDimValue(cid, v, undefined, { quiet: true })) refused.set(key, info.value);
+      } else c.value = v;
+    }
+  } finally { following = false; }
+}
+
+onLinkInfo(() => followLinked());