@reekon-tools/boldr-cad 1.6.0 → 1.7.0

package/src/editor/dimSize.ts

@@ -0,0 +1,53 @@
+import { ed } from '../app/state';
+import { clamp } from '../model/geom';
+import { settings } from '../model/settings';
+import { saveSoon } from '../model/store';
+import { requestDraw } from '../render/view';
+import { elevOpen } from './elevation';
+import { selInfo } from './selection';
+import { is3d } from './view3dState';
+
+/*
+  The size of the drawing's measurement tiles — its dimensions' chips: lengths, angles, diameters, a door's or window's
+  — one size for the whole file, every page, everyone's (the user's call, 2026-11-05: "rescaling is global so the scale
+  will apply to all measurement tiles in the cad file"). The bar's Size with a dimension picked opens its slider, as a
+  tile's Size does for the tiles (editor/linkActions.ts). It's kept with the file's settings (CadFileMeta.settings
+  .chipPct) and saved with the drawing; it isn't an undo step, as the wall height and the layers aren't.
+
+  Unlike a tile, a chip is drawn a set size on the screen, whatever the zoom, so its range is a chip's: from half to
+  three times its size, on the tiles' log scale, catching at 100%.
+*/
+
+/** The slider's range, percent. */
+export const DIM_PCT_MIN = 50, DIM_PCT_MAX = 300;
+
+/** Whether the bar offers Size: the plan in Draft, for someone who can edit, with a dimension picked. */
+export function dimSizeVisible(): boolean {
+  if (ed.readOnly || ed.mode !== 'draft' || elevOpen() || is3d() || !ed.sel.length) return false;
+  const s = selInfo();
+  return s.dims.length + s.odims.length > 0;
+}
+
+/** Size every measurement tile to `pct` percent (DIM_PCT_MIN to DIM_PCT_MAX), drawn at once — for the slider as it moves. */
+export function setDimPct(pct: number): void {
+  settings.chipPct = Math.round(clamp(pct, DIM_PCT_MIN, DIM_PCT_MAX));
+  requestDraw();
+}
+
+/** The slider let go: a change to save (the file's settings: Save, or the next save where saving is automatic). */
+export function dimSizeDone(): void {
+  ed.editSeq++;
+  saveSoon();
+  requestDraw();
+}
+
+/** The slider's steps (as the tiles' slider has: SIZE_STEPS of them, 100% in the middle of a log scale). */
+export const DIM_STEPS = 1000;
+const LOG_MIN = Math.log(DIM_PCT_MIN), LOG_SPAN = Math.log(DIM_PCT_MAX) - LOG_MIN, LOG_100 = (Math.log(100) - LOG_MIN) / LOG_SPAN;
+export const dimPctToStep = (pct: number): number => Math.round(((Math.log(clamp(pct, DIM_PCT_MIN, DIM_PCT_MAX)) - LOG_MIN) / LOG_SPAN) * DIM_STEPS);
+/** A step as a percent: whole percents, catching at 100% so the size the drawing had is easy to find again. */
+export function stepToDimPct(step: number): number {
+  const t = clamp(step, 0, DIM_STEPS) / DIM_STEPS;
+  if (Math.abs(t - LOG_100) < 0.02) return 100;
+  return Math.round(Math.exp(LOG_MIN + t * LOG_SPAN));
+}

package/src/editor/gestures.ts

@@ -16,9 +16,12 @@ import type { SelItem } from '../model/types';
 
 /*
   Pointer routing for the plan canvas, whatever delivers the pointers (DOM pointer events, React Native touches).
-  Pen draws, fingers navigate: once a pen has been seen, touch only pans and zooms. Without a pen, one finger drives
-  the tool and a second finger turns the action into a pan/pinch — a finger's press waits a moment for one first
-  (pressTiming). Two-finger tap undoes, three-finger tap redoes.
+  A finger or the Pencil drives the tool, one at a time, and a second finger turns a finger's action into a pan/pinch —
+  a finger's press waits a moment for one first (pressTiming). Two-finger tap undoes, three-finger tap redoes.
+  Pencil and fingers at once (the user's call, 2026-11-05; fingers used to only pan and zoom once a Pencil had been
+  seen): fingers landing while the Pencil is down pan and pinch around it, and the Pencil draws while fingers move the
+  view. A finger already down when the Pencil lands and not moving the view — a hand resting on the screen — never
+  pressed anything: it's set aside until it lifts (see parked).
   Mouse: middle or right button, or Space held, drags to pan; the wheel zooms.
   With a sheet up over the drawing (the keypad, a conflict, a question), the drawing only pans and zooms, by any
   pointer, and a tap on it closes the sheet. View only, a tap on a link's tile asks to open what it's for.
@@ -67,7 +70,9 @@ export const pressTiming = {
 };
 
 const ptrs = new Map<number, PointerIn>();
-let penSeen = false, gesture: Gesture | null = null, primary: PointerIn | null = null;
+let gesture: Gesture | null = null, primary: PointerIn | null = null;
+/** Fingers the Pencil landed on (setAsideFingers): they do nothing, and count for nothing, until they lift. */
+const parked = new Set<number>();
 /** close: a press under a sheet (see sheetUp) — a tap closes it; open: a view-only press — a tap opens a link's tile */
 let panDrag: { x: number; y: number; id: number; moved: number; close?: boolean; open?: boolean } | null = null;
 /** where the primary pointer went down, and whether a gesture on the drawing is in motion */
@@ -85,7 +90,7 @@ let held: { p: PointerIn; at: PointerIn; moves: PointerIn[]; timer: ReturnType<t
 let wheelT: ReturnType<typeof setTimeout> | undefined;
 export const keys = { spaceDown: false };
 onSessionReset(() => {
-  ptrs.clear(); penSeen = false; gesture = null; primary = null; panDrag = null; keys.spaceDown = false; primaryAt = null; beforePress = null; primaryMoved = false;
+  ptrs.clear(); parked.clear(); gesture = null; primary = null; panDrag = null; keys.spaceDown = false; primaryAt = null; beforePress = null; primaryMoved = false;
   dropHeld();
   setMotion(false);
   clearTimeout(wheelT);
@@ -122,7 +127,8 @@ function evOf(p: PointerIn): PEv {
 }
 
 const curTool = () => tools[ed.tool];
-const touchList = () => [...ptrs.values()].filter(q => q.kind === 'touch');
+const touchList = () => [...ptrs.values()].filter(q => q.kind === 'touch' && !parked.has(q.id));
+const penDown = () => [...ptrs.values()].some(q => q.kind === 'pen');
 
 function gState(ts: PointerIn[]): GState | null {
   if (ts.length >= 2) { const a = ts[0], b = ts[1]; return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, d: hyp(a.x - b.x, a.y - b.y), n: ts.length }; }
@@ -160,7 +166,8 @@ function endGesture(t: number): void {
   if (g.moved < MOTION_PX && sheetUp()) closeSheet();
   // (view only: a finger's tap on a link's tile opens it, once the person says so)
   else if (g.moved < MOTION_PX && ed.readOnly && g.max === 1 && g.last && t - g.t0 < 500) readOnlyTap(g.last.x, g.last.y, true);
-  else if (g.moved < MOTION_PX && t - g.t0 < 380 && !ed.readOnly) { if (g.max === 2) undo(); else if (g.max >= 3) redo(); }
+  // (not with the Pencil mid-stroke: it would undo under it)
+  else if (g.moved < MOTION_PX && t - g.t0 < 380 && !ed.readOnly && !primary) { if (g.max === 2) undo(); else if (g.max >= 3) redo(); }
   saveViewSoon();
 }
 
@@ -216,9 +223,22 @@ function releaseHeld(): void {
   for (const m of h.moves) movePrimary(m);
 }
 
+/**
+ * The Pencil landed: a finger already down that isn't moving the view — a hand resting on the screen, or a finger
+ * beaten to it — never pressed anything (a press it made is undone, as for a second finger) and is set aside until it
+ * lifts. Fingers already panning or pinching carry on.
+ */
+function setAsideFingers(): void {
+  if (gesture) return;
+  dropHeld();
+  if (primary && primary.kind === 'touch') cancelPrimary();
+  for (const q of touchList()) parked.add(q.id);
+}
+
 function endPtr(e: PointerIn, cancel: boolean): void {
   const p = ptrs.get(e.id);
   ptrs.delete(e.id);
+  if (parked.delete(e.id)) return;
   if (panDrag && panDrag.id === e.id) {
     const still = panDrag.moved < MOTION_PX && !cancel, close = !!panDrag.close && still, open = !!panDrag.open && still;
     panDrag = null; setCursor(''); saveViewSoon();
@@ -239,7 +259,6 @@ function endPtr(e: PointerIn, cancel: boolean): void {
 
 export function pointerDown(e: PointerIn): void {
   dismissPopovers();
-  if (e.kind === 'pen') penSeen = true;
   ed.lastPointerTouch = e.kind !== 'mouse';
   const p = { ...e };
   ptrs.set(e.id, p);
@@ -250,9 +269,11 @@ export function pointerDown(e: PointerIn): void {
     setCursor('grabbing');
     return;
   }
+  if (e.kind === 'pen') setAsideFingers();
   if (e.kind === 'touch') {
     const touches = touchList();
-    if (penSeen || touches.length >= 2 || navOnly) {
+    // (with the Pencil down, a finger moves the view around it)
+    if (touches.length >= 2 || navOnly || penDown()) {
       // (a second finger while the first one's press waited: that never pressed anything)
       dropHeld();
       if (primary && primary.kind === 'touch') cancelPrimary();
@@ -280,6 +301,7 @@ export function pointerMove(e: PointerIn): void {
     return;
   }
   if (p) { p.x = e.x; p.y = e.y; }
+  if (parked.has(e.id)) return;
   if (gesture && p && p.kind === 'touch') { updateGesture(); return; }
   // (a finger whose press is waiting: its moves wait with it, and one past a tap sends them all now — a drag)
   if (held && e.id === held.at.id) {

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/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/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/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) => {