@reekon-tools/boldr-cad 1.6.0 → 1.8.0

package/src/editor/keypad.ts

@@ -118,6 +118,22 @@ export function keypadSetReading(v: number): void {
   kps.cur.error = undefined;
 }
 
+/** Whether an open keypad would take a laser reading now (a length one, with laser on): keypadTakeLaser's test alone. */
+export function keypadTakesLaser(): boolean {
+  const k = kps.cur;
+  return !!k && k.spec.laser !== false && !k.spec.numeric;
+}
+
+/**
+ * Whether a reading of `v` taken into the open keypad now would replace a measured value: only the host's own keypad
+ * applies a reading at once (this one puts it in the display, still to be applied), and only one opened on such a
+ * value says so (KeypadSpec.overwrites: a dimension's).
+ */
+export function keypadReadingOverwrites(v: number): boolean {
+  const k = kps.cur;
+  return !!k && !!k.host && keypadTakesLaser() && !!k.spec.overwrites?.(v);
+}
+
 /**
  * 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.
@@ -125,7 +141,7 @@ export function keypadSetReading(v: number): void {
  */
 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 || !keypadTakesLaser()) return false;
   if (k.host) { keypadSubmit(v, capture); return true; }
   keypadSetReading(v);
   k.capture = capture !== undefined ? { of: capture, text: k.text } : undefined;

package/src/editor/laser.ts

@@ -9,9 +9,10 @@ import { lengthDimOf, lineLen } from '../model/sketch';
 import { SK } from '../model/store';
 import { faceLength } from '../model/wallfaces';
 import { V } from '../render/view';
-import { LENGTH_SET_ALREADY, setDimValue, type DimValueOpts } from '../tools/dim';
+import { LENGTH_SET_ALREADY, replacesMeasured, setDimValue, type DimValueOpts } from '../tools/dim';
 import { fmtLen } from '../units';
-import { keypadTakeLaser } from './keypad';
+import { advanceAfterReading } from './advance';
+import { keypadReadingOverwrites, keypadTakeLaser, keypadTakesLaser } from './keypad';
 import { refreshKeypad, refreshTray, toast } from './ports';
 import { selInfo } from './selection';
 
@@ -82,9 +83,9 @@ function readingTarget(id: string): [string, (1 | -1)?] {
   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 });
+/** A reading put on a line's (or straight wall's) length, or a circle's or arc's diameter. Whether it took. */
+function setReading(id: string, v: number, side?: 1 | -1, capture?: unknown): boolean {
+  return SK().lines[id] ? setLineLength(id, v, side, { capture }) : setCurveDiameter(id, v, side, { capture });
 }
 
 /**
@@ -109,12 +110,13 @@ function appliedTo(id: string): string {
  */
 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);
+  const target = selectedReadingTarget();
+  if (target) {
+    const [id, side] = target;
+    const took = setReading(id, v, side, capture);
     toast('Laser ' + fmtLen(v) + ' applied to ' + appliedTo(id));
+    // on round to the next line clockwise, for the next reading (not past one the drawing refused, or asked about)
+    if (took) advanceAfterReading(id, side);
     return;
   }
   laser.readings.unshift({ id: uid('m'), v, ...(capture !== undefined ? { capture } : {}) });
@@ -123,6 +125,32 @@ export function applyReading(v: number, capture?: unknown): void {
   toast('Select a line, then take the reading.', { warn: true });
 }
 
+/** Where a reading arriving now goes when no keypad takes it: the one selected line, wall edge or curve, in Draft. */
+function selectedReadingTarget(): [string, (1 | -1)?] | null {
+  const s = selInfo();
+  const one = s.n === 1 ? s.lines[0] ?? s.wfaces[0] ?? s.curves[0] : undefined;
+  return ed.mode === 'draft' && one ? readingTarget(one) : null;
+}
+
+/**
+ * Whether a reading of `v` arriving now would replace a measured value, for a host that warns before one does (BOLDR's
+ * mobile app, with the warning a filled annotation tile or form cell gets; the user's call, 2026-11-05): a value
+ * already entered (a driving dimension, not a default nobody measured), changed by it (replacesMeasured). That's a
+ * reading going onto the selected line, wall edge or curve; or into the host's own keypad opened on such a dimension (a
+ * phone's: it applies a reading at once). Not one into the editor's own keypad: it waits in the display to be applied.
+ * Not one linked to a measurement of the job: the editor asks about that itself (askLinkedChange).
+ */
+export function readingOverwrites(v: number): boolean {
+  if (keypadTakesLaser()) return keypadReadingOverwrites(v);
+  const target = selectedReadingTarget();
+  if (!target) return false;
+  const sk = SK(), [id] = target;
+  const ex = sk.lines[id] ? lengthDimOf(sk, id) : diamDimOf(id);
+  const c = ex ? sk.cons[ex] : undefined;
+  // (as setCurveDiameter gives it: a fillet's radius dimension holds the diameter)
+  return replacesMeasured(c, c?.type === 'diam' && c.rad ? v * 2 : v);
+}
+
 /**
  * Use a reading from the tray: `dropOn` is the line it was dragged onto (null: dropped off any line); without it
  * (a tap), it goes to the one selected line.

package/src/editor/linkActions.ts

@@ -5,12 +5,12 @@ import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { isLink, LINK_COLOR, LINK_HARD_MAX_IN, LINK_HARD_MIN_IN, LINK_MAX_IN, LINK_MIN_IN, LINK_SIDE_IN, LINK_TILE_PX, linkInfoOf, linkName, linkSide, linkSnapshot } from '../model/links';
 import { dimMeasurement } from '../model/measurement';
-import { imageLinkAt, linkAt } from '../render/hit';
+import { hitAny, imageLinkAt, linkAt } from '../render/hit';
 import { askConfirm } from './confirm';
 import { imageById } from '../model/images';
 import { settings } from '../model/settings';
 import { page, SK, store } from '../model/store';
-import type { LinkTarget, Note, Sketch, Underlay } from '../model/types';
+import type { LinkTarget, Note, SelItem, Sketch, Underlay } from '../model/types';
 import { tileTypeOf } from '../render/linkTile';
 import { cvs, linkBox, linkThumb, mainT, requestDraw, s2w, underlayMid } from '../render/view';
 import { setTool } from '../tools/registry';
@@ -18,6 +18,7 @@ import { elevOpen } from './elevation';
 import { is3d } from './view3dState';
 import { besideOpen, canLink, canOpenBeside, linksHost, openLink, openLinkBeside, pickLinks } from './links';
 import { toast } from './ports';
+import { refTarget } from './refDim';
 
 /*
   Linking. In Annotate the + puts the job's files the person picks on the plan as tiles (selected, to move them where
@@ -270,11 +271,16 @@ export function toggleExpand(): void {
   else if (u) collapseLink(u.id);
 }
 
-/** A view-only tap on the plan: on a link's tile or an expanded photo's badge, the person is asked, then what it's for opens. */
+/**
+ * A view-only tap on the plan: on a link's tile or an expanded photo's badge, the person is asked, then what it's for
+ * opens. Anywhere else, what's under it is picked to read its size — a line, a wall or its edge, a corner, a curve:
+ * its grey number shows (editor/refDim.ts; the user's call, 2026-11-05) — and a tap on nothing of the kind lets go.
+ */
 export function readOnlyTap(sx: number, sy: number, touch: boolean): void {
-  if (!ed.readOnly || !canLink()) return;
-  const t = linkAt(sx, sy, touch)?.link ?? imageLinkAt(sx, sy, touch)?.link;
-  if (!t || !canOpenLink(t)) return;
+  if (!ed.readOnly) return;
+  const t = canLink() ? linkAt(sx, sy, touch)?.link ?? imageLinkAt(sx, sy, touch)?.link : undefined;
+  if (!t) { pickToRead(sx, sy, touch); return; }
+  if (!canOpenLink(t)) return;
   const where = linkInfoOf(t)?.groupName ?? t.groupName;
   askConfirm({
     title: 'Open ' + linkName(t) + '?',
@@ -287,6 +293,19 @@ export function readOnlyTap(sx: number, sy: number, touch: boolean): void {
   });
 }
 
+/** What a view-only tap picks to read the size of: one thing the + measures alone (the selection is otherwise empty). */
+const READABLE = new Set(['line', 'wface', 'point', 'circle', 'arc']);
+
+function pickToRead(sx: number, sy: number, touch: boolean): void {
+  const h = hitAny(sx, sy, { touch, faces: true });
+  // (a wall picked whole: the side it was tapped on, which side of it its length is read on between two spaces)
+  if (h?.side && (h.type === 'line' || h.type === 'circle' || h.type === 'arc')) ed.wallTap = { id: h.id, side: h.side };
+  ed.sel = h && !h.weak && READABLE.has(h.type) ? [{ type: h.type as SelItem['type'], id: h.id }] : [];
+  // (a point that isn't a corner has no size to read)
+  if (ed.sel.length && !refTarget()) ed.sel = [];
+  requestDraw();
+}
+
 /** 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];

package/src/editor/ports.ts

@@ -38,6 +38,12 @@ export interface KeypadSpec {
   extras?: () => KeypadExtra[];
   /** the value; `capture`, a laser reading's record (laserReading's), when it's that reading applied as it came in */
   onDone?: (v: number, capture?: unknown) => void;
+  /**
+   * Whether `v` (as onDone takes it) would replace a value measured there: set by a keypad opened on a dimension, so a
+   * host that warns before a reading overwrites can ask, where the host's keypad applies a reading at once
+   * (laserReadingOverwrites).
+   */
+  overwrites?: (v: number) => boolean;
   /**
    * A line's length, or a dimension's angle: the job's measurements are offered with the keys (a page swiped to on a
    * touch screen, Select From List on a desktop), those of `kind` pickable — the one picked handed to `pick` (the
@@ -91,6 +97,8 @@ export interface EditorPorts {
   toggleImageRotation(anchor?: unknown): void;
   /** the link tiles' size slider, above the bar (its button again closes it) */
   toggleTileSize(anchor?: unknown): void;
+  /** the measurement tiles' size slider, above the bar, as the tiles' (editor/dimSize.ts) */
+  toggleDimSize(anchor?: unknown): void;
   /** let the user type a new name for a space */
   editRoomName(roomId: string): void;
   /** the mouse cursor over the plan (or the wall elevation), as a CSS cursor name ('' = the default); ignored without a mouse */
@@ -125,6 +133,7 @@ export const basePorts = (): EditorPorts => ({
   toggleImageOpacity() {},
   toggleImageRotation() {},
   toggleTileSize() {},
+  toggleDimSize() {},
   editRoomName() {},
   setCursor() {},
   dismissPopovers: () => false,
@@ -154,6 +163,7 @@ export const openPalette = (anchor?: unknown): void => ports.openPalette(anchor)
 export const toggleImageOpacity = (anchor?: unknown): void => ports.toggleImageOpacity(anchor);
 export const toggleImageRotation = (anchor?: unknown): void => ports.toggleImageRotation(anchor);
 export const toggleTileSize = (anchor?: unknown): void => ports.toggleTileSize(anchor);
+export const toggleDimSize = (anchor?: unknown): void => ports.toggleDimSize(anchor);
 export const editRoomName = (roomId: string): void => ports.editRoomName(roomId);
 export const setCursor = (cursor: string, where: 'plan' | 'elevation' = 'plan'): void => ports.setCursor(cursor, where);
 export const dismissPopovers = (): boolean => ports.dismissPopovers();

package/src/editor/refDim.ts

@@ -0,0 +1,61 @@
+import { afterEdit } from '../app/edit';
+import { ed } from '../app/state';
+import { measure } from '../model/constraints';
+import { pushHistory } from '../model/history';
+import { settings } from '../model/settings';
+import { addCons } from '../model/sketch';
+import { SK } from '../model/store';
+import type { Constraint } from '../model/types';
+import { selectionDim } from '../tools/dim';
+import { elevOpen } from './elevation';
+import { keypadOpen } from './keypad';
+import { noScaleYet } from './scaleGate';
+
+/*
+  Reference measurements by hand (the user's call, 2026-11-05: "upon selection of a line, two points, angle etc there
+  should be a grey measurement ... bottom bar should have a make reference option, when pressed the shown grey
+  measurement now stays on screen"). With something picked that the yellow + measures, the dimension it would make is
+  drawn as it measures now: a faded grey number with a dashed outline (the "ghost", render/draw.ts). It's a readout,
+  not a tap target: it sits on what it measures (a line's middle, a wall's cabinets), and a press there is for that —
+  the bar's + sets it. The bar's Make reference keeps it, as a reference dimension (never drives the drawing) that
+  stays on screen (`Constraint.kept`), solid grey in brackets. Only new ones: a dimension that drives stays driving. A reference the
+  drawing already set (one that would over-define it) shows only while selected, so it's drawn as a ghost too, and
+  Make reference keeps it. Everywhere (BOLDR's app and web), and in a drawing opened view-only, where a tap picks one
+  thing to read its size (readOnlyTap) and nothing can be kept.
+*/
+
+/**
+ * What the grey number is for: the dimension the + would make for the selection (`id` unset), or the reference already
+ * there for it that isn't kept. Null with nothing to show: a dimension already measured or kept there, nothing the +
+ * measures this way, the wall view, Annotate, another tool, the keypad up (it draws what it's setting), dimensions
+ * hidden, or a page whose sizes are still placeholders (rule 15).
+ */
+export function refTarget(): { c: Constraint; id?: string } | null {
+  if (ed.mode === 'annotate' || ed.tool !== 'select' || elevOpen() || keypadOpen() || !settings.layers.dims || noScaleYet()) return null;
+  const d = selectionDim();
+  if (!d) return null;
+  const sk = SK();
+  if (!d.existing) return { c: { ...d.c, value: measure(sk, d.c) } };
+  const e = sk.cons[d.existing];
+  return e.driving === false && !e.kept ? { c: e, id: d.existing } : null;
+}
+
+/** The dimension the grey number shows, when it isn't one of the drawing's yet. */
+export function ghostDim(): Constraint | null {
+  const t = refTarget();
+  return t && !t.id ? t.c : null;
+}
+
+/** Whether the bar offers Make reference: something to keep, in a drawing that can be edited. */
+export const makeRefVisible = (): boolean => !ed.readOnly && !!refTarget();
+
+/** Make reference: the grey number kept, as a reference dimension that stays on screen. One undo step. */
+export function makeReference(): void {
+  const t = refTarget();
+  if (!t || ed.readOnly) return;
+  pushHistory();
+  const sk = SK();
+  if (t.id) sk.cons[t.id].kept = true;
+  else addCons(sk, { ...t.c, driving: false, kept: true });
+  afterEdit();
+}

package/src/index.ts

@@ -11,8 +11,7 @@ export type { Unit } from './units';
 export { memoryProvider } from './data/memory';
 export { setFileSaver } from './react/ports';
 export { BESIDE as CAD_BESIDE } from './react/pageLock';
-export { laserReading, setLaserConnected, surveyClose, surveyCursor, surveyPoint } from './react/host';
-export type { HostKeypad, HostKeypadExtra, HostKeypadRequest, MeasurementList, MeasurementListPage } from './react/hostKeypad';
+export { laserReading, laserReadingOverwrites, setLaserConnected, surveyClose, surveyCursor, surveyPoint } from './react/host';export type { HostKeypad, HostKeypadExtra, HostKeypadRequest, MeasurementList, MeasurementListPage } from './react/hostKeypad';
 export type { CadLinkPick, CadLinks, CadSaveMeasurement, MeasurementKind } from './editor/links';
 export type { LinkInfo, LinkTarget } from './model/types';
 export { linkKey } from './model/links';

package/src/model/clockwise.ts

@@ -0,0 +1,121 @@
+import type { Sketch } from './types';
+
+/*
+  The next line clockwise round the shape a line is part of: where a laser reading moves on to once it has set a
+  line's length (editor/advance.ts; the user's call, 2026-11-05). Clockwise as seen: the plan's y runs up, so as it is
+  in the model too, and turning the view doesn't change it.
+
+  The shape is the face the line bounds, walked with it on the right: at each corner the walk takes the edge that turns
+  most to the right, so it keeps tracing the same face past a T (an inner wall) and comes round to where it started. A
+  line can bound two faces (a wall between two rooms) or only the outside: the walk that closes clockwise is the room
+  (its signed area negative), and between two rooms, the smaller one, or for a wall edge, the room that edge faces. A
+  run that never closes goes clockwise round its own middle, and stops at its end. Arcs are walked through (a fillet in
+  a room's corner) but never moved onto: the next straight line is. Guides aren't part of any shape.
+*/
+
+/** An edge walked one way: `id` (a line or an arc) from point `from` to point `to`. */
+interface Step { id: string; from: string; to: string }
+
+/** Every line and arc, by the points they end at (guides left out). */
+function ends(sk: Sketch): Map<string, { id: string; other: string }[]> {
+  const m = new Map<string, { id: string; other: string }[]>();
+  const add = (id: string, a: string, b: string) => {
+    if (a === b || !sk.points[a] || !sk.points[b]) return;
+    (m.get(a) ?? m.set(a, []).get(a)!).push({ id, other: b });
+    (m.get(b) ?? m.set(b, []).get(b)!).push({ id, other: a });
+  };
+  for (const [id, l] of Object.entries(sk.lines)) if (!l.constr) add(id, l.a, l.b);
+  for (const [id, c] of Object.entries(sk.arcs)) if (!c.constr) add(id, c.a, c.b);
+  return m;
+}
+
+const TURN = 2 * Math.PI;
+
+/** The step after `s`, keeping the face on the right: the edge at its end turning most to the right. Null at a dead end. */
+function after(sk: Sketch, at: Map<string, { id: string; other: string }[]>, s: Step): Step | null {
+  const v = sk.points[s.to], u = sk.points[s.from];
+  const back = Math.atan2(u.y - v.y, u.x - v.x);
+  let best: Step | null = null, least = Infinity;
+  for (const e of at.get(s.to) ?? []) {
+    if (e.id === s.id) continue;
+    const w = sk.points[e.other];
+    // (counter-clockwise from the way back: the least is the sharpest turn right)
+    let d = Math.atan2(w.y - v.y, w.x - v.x) - back;
+    while (d <= 1e-9) d += TURN;
+    while (d > TURN) d -= TURN;
+    if (d < least) { least = d; best = { id: e.id, from: s.to, to: e.other }; }
+  }
+  return best;
+}
+
+/** The walk from `s` on round: every step after it, and whether it came back to `s` (a closed shape). */
+function walk(sk: Sketch, at: Map<string, { id: string; other: string }[]>, s: Step): { steps: Step[]; closed: boolean } {
+  const steps: Step[] = [];
+  let cur: Step | null = s;
+  const most = 2 * (Object.keys(sk.lines).length + Object.keys(sk.arcs).length) + 2;
+  while (steps.length < most) {
+    cur = after(sk, at, cur!);
+    if (!cur) return { steps, closed: false };
+    if (cur.id === s.id && cur.from === s.from) return { steps, closed: true };
+    steps.push(cur);
+  }
+  return { steps, closed: false };
+}
+
+/** Twice the signed area round `s` and the steps after it (negative: clockwise, y up). */
+function area(sk: Sketch, s: Step, steps: Step[]): number {
+  let a = 0;
+  for (const t of [s, ...steps]) {
+    const p = sk.points[t.from], q = sk.points[t.to];
+    a += p.x * q.y - q.x * p.y;
+  }
+  return a;
+}
+
+/** The middle of everything joined to `pid` (the points it can reach along lines and arcs). */
+function middle(sk: Sketch, at: Map<string, { id: string; other: string }[]>, pid: string): { x: number; y: number } {
+  const seen = new Set([pid]), todo = [pid];
+  while (todo.length) for (const e of at.get(todo.pop()!) ?? []) if (!seen.has(e.other)) { seen.add(e.other); todo.push(e.other); }
+  let x = 0, y = 0;
+  for (const id of seen) { x += sk.points[id].x; y += sk.points[id].y; }
+  return { x: x / seen.size, y: y / seen.size };
+}
+
+/** The side of a straight line on the right of walking it as `s` does (+1 the left of its A → B, −1 the right). */
+const rightOf = (sk: Sketch, s: Step): 1 | -1 => (s.from === sk.lines[s.id]?.a ? -1 : 1);
+
+/**
+ * The next line clockwise from line or arc `id`, round the shape it's part of; null when there's none (a lone line, a
+ * run's end, a circle). `side`: a wall's edge it was measured on (+1 the left of its A → B): the edge of the next wall on
+ * the same side of the shape (the inside stays the inside) comes back with it. A line between two rooms goes round the
+ * one that edge faces, or the smaller one.
+ */
+export function nextClockwise(sk: Sketch, id: string, side?: 1 | -1): { id: string; side?: 1 | -1 } | null {
+  const e = sk.lines[id] ?? sk.arcs[id];
+  if (!e || e.constr || e.a === e.b) return null;
+  const at = ends(sk);
+  const fwd: Step = { id, from: e.a, to: e.b }, rev: Step = { id, from: e.b, to: e.a };
+  const wf = walk(sk, at, fwd), wr = walk(sk, at, rev);
+  const room = (s: Step, w: { steps: Step[]; closed: boolean }) => w.closed && area(sk, s, w.steps) < 0;
+  const inF = room(fwd, wf), inR = room(rev, wr);
+  let start: Step, w: { steps: Step[]; closed: boolean };
+  if (inF && inR) {
+    // between two rooms: the one the edge faces (on the walk's right), or the smaller
+    const pickF = side && sk.lines[id] ? rightOf(sk, fwd) === side : Math.abs(area(sk, fwd, wf.steps)) <= Math.abs(area(sk, rev, wr.steps));
+    [start, w] = pickF ? [fwd, wf] : [rev, wr];
+  } else if (inF || inR) {
+    [start, w] = inF ? [fwd, wf] : [rev, wr];
+  } else {
+    // a run that doesn't close: clockwise round its middle (the middle on the right of the way it's walked)
+    const m = middle(sk, at, e.a), a = sk.points[e.a], b = sk.points[e.b];
+    const leftOfAB = (b.x - a.x) * (m.y - a.y) - (b.y - a.y) * (m.x - a.x) >= 0;
+    [start, w] = leftOfAB ? [rev, wr] : [fwd, wf];
+  }
+  const next = w.steps.find(s => s.id !== id && sk.lines[s.id]);
+  if (!next) return null;
+  if (!side || !sk.lines[id]) return { id: next.id };
+  // the measured edge's side of the shape (on the walk's right, or its left), kept on the next line
+  const sameRight = rightOf(sk, start) === side;
+  const r = rightOf(sk, next);
+  return { id: next.id, side: sameRight ? r : (-r as 1 | -1) };
+}

package/src/model/settings.ts

@@ -24,13 +24,15 @@ export interface Settings extends UnitPrefs {
   layers: Layers;
   /** default wall height (floor to ceiling), inches */
   wallH: number;
+  /** the size of the drawing's measurement tiles (its dimensions' chips), percent: the file's, everyone's (editor/dimSize.ts) */
+  chipPct: number;
 }
 
 export const defaultLayers = (): Layers => ({ underlay: true, construction: true, dims: true, rooms: true, annot: true, cabinets: true, objSnap: true });
 
 export const settings = sessionState((): Settings => ({
   unit: 'ftin', denom: 16, snapGrid: false, autoCons: true, toolTips: true, showCons: true, theme: 'system', welcomed: false,
-  layers: defaultLayers(), wallH: 96,
+  layers: defaultLayers(), wallH: 96, chipPct: 100,
 }));
 
 useUnitPrefs(settings);

package/src/model/types.ts

@@ -58,6 +58,11 @@ export interface Constraint {
   value?: number;
   /** false = reference dimension (shown in parentheses, never drives geometry) */
   driving?: boolean;
+  /**
+   * a reference made by hand (the bar's Make reference: editor/refDim.ts): it stays on screen, as an entered dimension
+   * does. Any other reference — one the drawing already set — shows only while it or what it measures is selected.
+   */
+  kept?: boolean;
   /**
    * label offset from the measured span, across it (a distance between parallel lines or walls: along them); a
    * diameter's, how far past the circle the label sits; an angle's, its arc's radius once pulled off its corner

package/src/react/BottomBar.tsx

@@ -4,6 +4,8 @@ import { ed } from '../app/state';
 import { applyCtxAction, barItems, deleteSelection, iconAlone, plusAction, plusLabel, plusVisible } from '../editor/actions';
 import { addLinks, LINK_PLUS_LABEL, linkPlusVisible, linkSizeVisible, openLinkTarget, opensWithChoice, pageLinkSize, pageTilePct, pctToStep, selectedOpenTarget, setTilePct, SIZE_STEPS, stepToPct } from '../editor/linkActions';
 import { afterEdit } from '../app/edit';
+import { DIM_STEPS, dimPctToStep, dimSizeDone, dimSizeVisible, setDimPct, stepToDimPct } from '../editor/dimSize';
+import { settings } from '../model/settings';
 import { bar3d, run3d } from '../editor/view3d';
 import { is3d } from '../editor/view3dState';
 import { OPACITY_MIN, OPACITY_STEP, ROTATE_MAX, ROTATE_STEP, setUnderlayOpacity, setUnderlayRotation } from '../editor/project';
@@ -33,7 +35,7 @@ export function BottomBar({ phone }: { phone: boolean }) {
   // what's in the bar and what it's for, and the selected image's opacity and turn (its sliders)
   useEditorKey(() => {
     const u = ed.sel.length === 1 && ed.sel[0].type === 'underlay' ? imageById(ed.sel[0].id) : undefined;
-    return [buttonsKey(), barFor(), plusVisible(), ed.sel.length, u ? u.opacity ?? 0.6 : '', u ? (u.rot ?? 0) + (u.locked ? 'L' : '') : '', linkPlusVisible(), ui.linkFab, linkSizeVisible(), pageLinkSize() ?? ''].join('|');
+    return [buttonsKey(), barFor(), plusVisible(), ed.sel.length, u ? u.opacity ?? 0.6 : '', u ? (u.rot ?? 0) + (u.locked ? 'L' : '') : '', linkPlusVisible(), ui.linkFab, linkSizeVisible(), pageLinkSize() ?? '', dimSizeVisible(), settings.chipPct].join('|');
   });
   // (on a phone only buttons show: a bar that would hold just a label isn't shown at all. The 3D tab measures and
   // deletes nothing: what's tapped there shows its sizes, and what can be done with it from there)
@@ -54,6 +56,7 @@ export function BottomBar({ phone }: { phone: boolean }) {
         <View style={[s.bottom, phone ? s.phoneRow : s.centered]} onLayout={e => setRow(e.nativeEvent.layout.width)}>
           <ImagePopover />
           <LinkSizePopover />
+          <DimSizePopover />
           <OpenPopover />
           {/* a phone's bar sits between two springs that start as wide as the trash takes and share what's left
               equally, so it's centred; only the left one gives way (first, before the bar), so a long bar slides left
@@ -202,7 +205,7 @@ const BarButtons = memo(function BarButtons({ phone, onWidth }: { k: string; pho
               if (t && opensWithChoice(t)) { ui.imgPop = ui.imgPop === 'open' ? null : 'open'; notify(); return; }
               applyCtxAction(it.act, e.currentTarget);
             }}
-            style={st => [s.cb, iconAlone(it) && s.lead, it.on || (it.act === 'imgOpacity' && ui.imgPop === 'opacity') || (it.act === 'imgRotate' && ui.imgPop === 'rotate') || (it.act === 'linkSize' && ui.imgPop === 'tilesize') || (isOpen(it.act) && ui.imgPop === 'open') ? { backgroundColor: 'rgba(255,255,255,0.14)' } : null,
+            style={st => [s.cb, iconAlone(it) && s.lead, it.on || (it.act === 'imgOpacity' && ui.imgPop === 'opacity') || (it.act === 'imgRotate' && ui.imgPop === 'rotate') || (it.act === 'linkSize' && ui.imgPop === 'tilesize') || (it.act === 'dimSize' && ui.imgPop === 'dimsize') || (isOpen(it.act) && ui.imgPop === 'open') ? { backgroundColor: 'rgba(255,255,255,0.14)' } : null,
               it.on ? { backgroundColor: '#fff' } : hovered(st) && { backgroundColor: 'rgba(255,255,255,0.08)' }]}>
             <Icon name={it.ic} color={fg} />
             {/* (the bar's lead — Lock, or Open — and Lock wherever it is: its icon alone, its name said, not shown) */}
@@ -355,6 +358,47 @@ function LinkSizePopover() {
   );
 }
 
+/**
+ * The measurement tiles' size slider (editor/dimSize.ts): the bar's Size with a dimension picked, as LinkSizePopover is
+ * for the tiles — one size for every measurement tile in the file, in percent of the size they're drawn at (50% to
+ * 300%), catching at 100%. Kept quick the same way: the thumb and the number follow the finger, the drawing is redrawn
+ * at most once a frame, and the change is marked (to save) as it's let go. Not an undo step, as the file's other
+ * settings aren't.
+ */
+function DimSizePopover() {
+  const [live, setLive] = useState<number | null>(null);
+  const pending = useRef<{ v: number; frame: number } | null>(null);
+  const open = ui.imgPop === 'dimsize' && dimSizeVisible();
+  const pop = usePopup(open, { y: 8 }, 'bottom center');
+  if (!pop.present) return null;
+  const value = live ?? dimPctToStep(settings.chipPct);
+  const change = (v: number) => {
+    setLive(v);
+    const p = pending.current;
+    if (p) { p.v = v; return; }
+    pending.current = { v, frame: requestAnimationFrame(() => { const q = pending.current; pending.current = null; if (q) setDimPct(stepToDimPct(q.v)); }) };
+  };
+  const end = () => {
+    const p = pending.current;
+    if (p) { cancelAnimationFrame(p.frame); pending.current = null; setDimPct(stepToDimPct(p.v)); }
+    setLive(null);
+    dimSizeDone();
+    notify();
+  };
+  return (
+    <View style={s.popWrap} pointerEvents="box-none">
+      <Animated.View style={[s.pop, pop.style]} pointerEvents={open ? 'auto' : 'none'} testID={open ? 'dimSizePop' : undefined}>
+        <Text style={s.popLabel}>Measurement size</Text>
+        <View style={{ flex: 1 }}>
+          <Slider label="Measurement size" testID="dimSizeSlider" value={value} min={0} max={DIM_STEPS} step={1} format={v => stepToDimPct(v) + '%'}
+            onChange={change} onEnd={end} />
+        </View>
+        <Text style={s.popValue}>{(live != null ? stepToDimPct(live) : settings.chipPct) + '%'}</Text>
+      </Animated.View>
+    </View>
+  );
+}
+
 /** The hint for screen readers: what to do next with the tool or what's picked, read out as it changes. */
 export function SpokenHint() {
   useEditorKey(currentHint);

package/src/react/PlanCanvas.native.tsx

@@ -31,7 +31,8 @@ import { TABS_TOP, topLayout } from './topRow';
 
   As a tool follows the pointer, only the moving parts (preview, snap marker, selection box) are drawn again; the
   drawing is kept until it changes. Touches still reach editor/gestures.ts for the tools, Apple Pencil, and two- and
-  three-finger taps (undo, redo); it leaves the view to this canvas (setHostNavigation).
+  three-finger taps (undo, redo); it leaves the view to this canvas (setHostNavigation). A Pencil and fingers can be
+  down at once (fingers pan and pinch while it draws), so each touch is handed over with what it is (OwnType).
 
   While a finger or Pencil places or drags something, the lens (render/lens.ts) shows the drawing around it twice as
   close in a top corner: the same pictures again, through its zoom, clipped to it — nothing more is drawn for it.
@@ -52,8 +53,15 @@ interface Frame {
   /** the latest of the UI thread's views it was drawn at (see UiView) */
   seq: number;
 }
-/** A touch as the UI thread hands it over: id, position on the canvas, position in the window. */
-type Packed = [id: number, x: number, y: number, ax: number, ay: number];
+/** A touch as the UI thread hands it over: id, position on the canvas, position in the window, what it is. */
+type Packed = [id: number, x: number, y: number, ax: number, ay: number, kind: string];
+/**
+ * A touch that says what it is. react-native-gesture-handler gives an event one pointer type, whichever touch iOS lists
+ * first, so with an Apple Pencil and a finger both down it's a coin toss which the other is taken for; BOLDR patches it
+ * to say for each touch too (BOLDR_App patches/react-native-gesture-handler+*.patch). Without that, the event's is used.
+ */
+type OwnType = TouchData & { pointerType?: PointerType };
+interface Typed { id: number; x: number; y: number; ax: number; ay: number; kind: string }
 
 /** The latest of the UI thread's views this thread has taken; each frame says which it includes. */
 let hostSeq = 0;
@@ -65,11 +73,11 @@ let placeLens: (() => void) | null = null;
  * Touches from the UI thread: the view first, if the fingers moved it, then each touch to the editor's gestures (as a
  * pointer lands, `down` is every one still down: any other's lift was lost).
  */
-function touchesOnJS(type: number, kind: string, ts: Packed[], view: UiView | null, down: number[] | null): void {
+function touchesOnJS(type: number, ts: Packed[], view: UiView | null, down: number[] | null): void {
   if (view) { hostSeq = view.seq; setViewFromHost(view.s, view.cx, view.cy); }
   if (down) pointersStill(down);
   const fn = type === NAV_DOWN ? pointerDown : type === NAV_MOVE ? pointerMove : type === NAV_UP ? pointerUp : pointerCancel, t = Date.now();
-  for (const [id, x, y, ax, ay] of ts) fn({ id, kind, x, y, t, cx: ax, cy: ay });
+  for (const [id, x, y, ax, ay, kind] of ts) fn({ id, kind, x, y, t, cx: ax, cy: ay });
   // what a tool shows following the finger (a shape's outline, its marks, the snap), drawn now: left for the next frame
   // it reached the screen a frame behind the finger. Only when nothing but those moving parts changed — the drawing
   // itself, and the view, are drawn on the frame as before.
@@ -81,17 +89,22 @@ const kindOf = (t: PointerType): string => {
   'worklet';
   return t === PointerType.STYLUS ? 'pen' : t === PointerType.MOUSE ? 'mouse' : 'touch';
 };
-const pack = (ts: TouchData[]): Packed[] => {
+/** Each touch, and what it is: its own pointer type where it says, else the event's (see OwnType). */
+const typed = (ts: TouchData[], type: PointerType): Typed[] => {
+  'worklet';
+  return ts.map(t => ({ id: t.id, x: t.x, y: t.y, ax: t.absoluteX, ay: t.absoluteY, kind: kindOf((t as OwnType).pointerType ?? type) }));
+};
+const pack = (ts: Typed[]): Packed[] => {
   'worklet';
-  return ts.map(t => [t.id, t.x, t.y, t.absoluteX, t.absoluteY] as Packed);
+  return ts.map(t => [t.id, t.x, t.y, t.ax, t.ay, t.kind] as Packed);
 };
 
 export const PlanCanvas = memo(function PlanCanvas() {
   const first = useRef(true);
   const frame = useSharedValue<Frame | null>(null);
   const view = useSharedValue<UiView>({ s: 1, cx: 0, cy: 0, seq: 0 });
-  // the UI thread's own: the fingers down, whether they're navigating and where they were last, a pen seen
-  const nav = useSharedValue<NavState>({ fingers: {}, navigating: false, last: null, pen: false });
+  // the UI thread's own: the fingers down, whether they're navigating and where they were last, any Pencil down
+  const nav = useSharedValue<NavState>({ fingers: {}, navigating: false, last: null, pens: [] });
   const readOnly = useSharedValue(false);
   // the lens, and whether it's up (mounted only then: nothing drawn twice for it otherwise)
   const lens = useSharedValue<Lens | null>(null);
@@ -187,11 +200,11 @@ export const PlanCanvas = memo(function PlanCanvas() {
     /** A touch event on the UI thread: follow the fingers (render/navigate.ts), then hand the touches to this thread. */
     const touch = (type: number, e: GestureTouchEvent) => {
       'worklet';
-      const kind = kindOf(e.pointerType), down = type === NAV_DOWN ? e.allTouches.map(t => t.id) : null;
-      const r = navTouch(nav.value, type, kind, e.changedTouches, down, readOnly.value, view.value, frame.value);
+      const ts = typed(e.changedTouches, e.pointerType), down = type === NAV_DOWN ? e.allTouches.map(t => t.id) : null;
+      const r = navTouch(nav.value, type, kindOf(e.pointerType), ts, down, readOnly.value, view.value, frame.value);
       nav.value = r.st;
       if (r.view !== view.value) view.value = r.view;
-      runOnJS(touchesOnJS)(type, kind, pack(e.changedTouches), r.moved ? r.view : null, down);
+      runOnJS(touchesOnJS)(type, pack(ts), r.moved ? r.view : null, down);
     };
     const touches = Gesture.Manual()
       .onTouchesDown((e, manager) => {

package/src/react/host.ts

@@ -1,4 +1,4 @@
-import { applyReading, laser } from '../editor/laser';
+import { applyReading, laser, readingOverwrites } from '../editor/laser';
 import { store } from '../model/store';
 import { closeSurveyRun, setSurveyCursor, takeSurveyPoint } from '../tools/survey';
 import { notify } from './store';
@@ -33,6 +33,16 @@ export function laserReading(inches: number, capture?: unknown): boolean {
   return true;
 }
 
+/**
+ * Whether a reading of `inches`, passed to laserReading now, would replace a length or diameter already measured on
+ * the selected line, wall edge or curve (see readingOverwrites), for a host that warns first: hold the reading, ask,
+ * and pass it on only once the person agrees. Nothing changes by asking. False when no drawing is open to take it.
+ */
+export function laserReadingOverwrites(inches: number): boolean {
+  if (!editorHost.open || !store.project || !Number.isFinite(inches) || inches <= 0) return false;
+  return readingOverwrites(inches);
+}
+
 /**
  * A point measured by a templating device (BOLDR's T1R), in inches, on the plan's axes: x to the right, y UP. Turning
  * the device's own frame into that is the host's job, and it's where the handedness goes: a device whose angle turns