@reekon-tools/boldr-cad 1.0.0 → 1.2.0

package/src/editor/keypad.ts

@@ -1,6 +1,6 @@
 import { sessionState } from '../model/session';
 import { settings } from '../model/settings';
-import { fmtAng, fmtLen, parseLen, parseNum } from '../units';
+import { fmtAng, fmtLen, parseLen, parseNum, showFractions } from '../units';
 import { closeKeypad, refreshKeypad, type KeypadSpec } from './ports';
 
 /*
@@ -13,6 +13,8 @@ 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 };
+  /** the exact value behind the display (inches), and the text it was shown as: it's the value while that text stands */
+  exact?: { v: number; text: string };
 }
 const kps = sessionState(() => ({ cur: null as Kp | null }));
 
@@ -32,12 +34,24 @@ export const keypadOpen = (): boolean => !!kps.cur;
 export const keypadSpec = (): KeypadSpec | null => kps.cur?.spec ?? null;
 export const keypadText = (): string => kps.cur?.text ?? '';
 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');
+/** The fraction row shows for lengths read with fractions (feet and inches), not for degrees, metric or decimal units. */
+export const fractionRowShown = (): boolean => !(kps.cur?.spec.numeric || !showFractions());
+
+const isMetricUnit = (): boolean => settings.unit === 'mm' || settings.unit === 'cm' || settings.unit === 'm';
+/** An example to type, in the person's units. */
+const lengthExample = (): string => {
+  const u = settings.unit;
+  if (u === 'mm') return '2540 or 8\' 4"';
+  if (u === 'cm') return '254 or 2.5 m';
+  if (u === 'm') return '2.54 or 254 cm';
+  if (u === 'ft') return '8.5 or 10\' 6"';
+  return showFractions() ? '12\' 6" or 150.5' : '12\' 6.5" or 150.5';
+};
 
 /** 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 };
+  const text = spec.initial || '';
+  kps.cur = { spec, text, fresh: !!spec.selectAll, host, exact: spec.value !== undefined && text ? { v: spec.value, text } : undefined };
 }
 
 /** Whether the open keypad is the host's own. */
@@ -99,6 +113,7 @@ export function keypadDeleteLast(): void {
 export function keypadSetReading(v: number): void {
   if (!kps.cur) return;
   kps.cur.text = fmtLen(v);
+  kps.cur.exact = { v, text: kps.cur.text };
   kps.cur.fresh = true;
   kps.cur.error = undefined;
 }
@@ -120,7 +135,9 @@ export function keypadTakeLaser(v: number, capture?: unknown): boolean {
 /** 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));
+// (a length shown rounded, left as it is, applies as the exact value it stands for)
+const parse = (k: Kp): number | null =>
+  k.spec.numeric ? parseNum(k.text) : k.exact && k.exact.text === k.text ? k.exact.v : parseLen(k.text);
 
 /** The value currently typed, or null if none/unreadable (for live previews on the canvas). */
 export function keypadTyped(): number | null {
@@ -134,7 +151,7 @@ export function keypadPreview(): { text: string; bad: boolean } {
   const k = kps.cur;
   if (!k) return { text: '', bad: false };
   if (k.error) return { text: k.error, bad: true };
-  if (!k.text.trim()) return { text: k.spec.numeric ? 'Type a number' : 'Try 12\' 6 1/2" or 150.5', bad: false };
+  if (!k.text.trim()) return { text: k.spec.numeric ? 'Type a number' : 'Try ' + (showFractions() && !isMetricUnit() ? '12\' 6 1/2" or 150.5' : lengthExample()), bad: false };
   const v = parse(k);
   if (v == null) return { text: 'Can’t read that yet', bad: true };
   return { text: '= ' + (k.spec.numeric ? fmtAng(v) : fmtLen(v)), bad: false };
@@ -143,7 +160,7 @@ export function keypadPreview(): { text: string; bad: boolean } {
 /** Apply: the value, or the message to show when it can't be read. The caller closes the keypad and runs onDone. */
 export function keypadValue(): { v: number } | { error: string } {
   const v = kps.cur ? parse(kps.cur) : null;
-  return v == null ? { error: 'Enter a length like 12\' 6" or 150.5' } : { v };
+  return v == null ? { error: 'Enter a length like ' + lengthExample() } : { 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. */

package/src/editor/ports.ts

@@ -26,6 +26,8 @@ export interface KeypadSpec {
   title: string;
   sub?: string;
   initial?: string;
+  /** the exact value `initial` shows (inches): applied as it is while the text isn't changed, so a value shown rounded doesn't move */
+  value?: number;
   /** typing replaces the initial value */
   selectAll?: boolean;
   /** degrees keypad instead of lengths */

package/src/editor/project.ts

@@ -215,7 +215,7 @@ export function setDefaultWallHeight(v: number): boolean {
 /** Settings → Wall height → Custom: any height, on the keypad. */
 export function editDefaultWallHeight(): void {
   openKeypad({
-    title: 'Wall height', sub: 'Walls without their own height', initial: fmtLen(settings.wallH), selectAll: true, laser: true,
+    title: 'Wall height', sub: 'Walls without their own height', initial: fmtLen(settings.wallH), value: settings.wallH, selectAll: true, laser: true,
     onDone: v => { setDefaultWallHeight(v); },
   });
 }
@@ -224,16 +224,17 @@ export type UnitChoice = 'account' | Unit;
 const UNITS_KEY = 'boldr-cad-units';
 
 /**
- * Settings → Units: the editor's own units (ft-in, in, mm), or 'account' — the host's (BOLDR: the person's account
- * settings). Remembered in this browser, so it sticks from drawing to drawing.
+ * Settings → Units: the editor's own units (ft-in, in, ft, mm, cm, m), or 'account' — the host's (BOLDR: the person's
+ * account settings). Remembered in this browser, so it sticks from drawing to drawing.
  */
 export function setUnits(choice: UnitChoice): void {
   const host = hostUnits();
   if (choice === 'account') {
-    if (host) { settings.unit = host.unit; settings.denom = host.denom; }
+    if (host) { settings.unit = host.unit; settings.denom = host.denom; settings.fractions = host.fractions; }
     setOwnUnits(false);
   } else {
     settings.unit = choice;
+    settings.fractions = undefined; // (the editor's own units read with fractions where that's their way)
     setOwnUnits(!!host);
   }
   rememberUnits();
@@ -259,8 +260,9 @@ export function restoreUnits(): void {
   if (!hostUnits()) return;
   try {
     const v = JSON.parse(localStorage.getItem(UNITS_KEY) || 'null') as 'account' | { unit?: string; denom?: number } | null;
-    if (!v || v === 'account' || !['ftin', 'in', 'mm'].includes(v.unit ?? '')) return;
+    if (!v || v === 'account' || !['ftin', 'in', 'ft', 'mm', 'cm', 'm'].includes(v.unit ?? '')) return;
     settings.unit = v.unit as Unit;
+    settings.fractions = undefined;
     if (v.denom === 4 || v.denom === 8 || v.denom === 16) settings.denom = v.denom;
     setOwnUnits(true);
   } catch { /* nothing remembered */ }

package/src/index.ts

@@ -6,10 +6,11 @@
 
 export { CadEditor, type CadEditorProps } from './react/CadEditor';
 export { openCadDrawing, measurementOf, NotACadDrawing, type CadSync, type CadSyncOptions } from './data/sync';
-export type { CadDataProvider, CadFileMeta, CadMeasurements, CadMeasurementValue, CadPageDoc } from './data/provider';
+export type { CadDataProvider, CadFileMeta, CadMeasurements, CadMeasurementValue, CadPageDoc, CadSnapshotMeta } from './data/provider';
+export type { Unit } from './units';
 export { memoryProvider } from './data/memory';
 export { setFileSaver } from './react/ports';
-export { laserReading, setLaserConnected } from './react/host';
+export { laserReading, setLaserConnected, 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';

package/src/model/planGeom.ts

@@ -3,7 +3,7 @@ import { roomGeom } from './rooms';
 import { frameMemo, roomValid } from './sketch';
 import type { Arc, Constraint, LineKind, Sketch, XY } from './types';
 import { faceCorner } from './wallfaces';
-import { getUnitPrefs, type Unit } from '../units';
+import { getUnitPrefs, isMetric, type Unit } from '../units';
 
 /*
   Plan geometry shared by drawing, hit testing, snapping and the tools: grid steps, where a door/window sits on
@@ -23,7 +23,7 @@ const MM = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000,
 const MM_MAJOR = [10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000].map(v => v / 25.4);
 
 export function gridSteps(s: number, unit: Unit = getUnitPrefs().unit): { minor: number; major: number } {
-  const metric = unit === 'mm', list = metric ? MM : IMPERIAL;
+  const metric = isMetric(unit), list = metric ? MM : IMPERIAL;
   const minor = list.find(v => v * s >= GRID_MIN_PX) || list[list.length - 1];
   const major = (metric ? MM_MAJOR : IMPERIAL_MAJOR).find(v => v >= minor * 4 - 1e-9) || minor * 5;
   return { minor, major };

package/src/react/CadEditor.tsx

@@ -8,7 +8,7 @@ import { settings } from '../model/settings';
 import { load, saveNow, setPersistence, store } from '../model/store';
 import { renderThumbnail } from './thumbnail';
 import type { CadSync } from '../data/sync';
-import { setLengthFormatter } from '../units';
+import { setLengthFormatter, type Unit } from '../units';
 import { CANVAS_THEMES, setCanvasTheme } from '../render/theme';
 import { requestDraw, setImageResolver } from '../render/view';
 import { registerTools } from '../tools';
@@ -62,8 +62,12 @@ export interface CadEditorProps {
   theme?: 'light' | 'dark';
   /** The drawing, opened with openCadDrawing (saved there as it changes). Without it, the drawing lives in this browser. */
   sync?: CadSync;
-  /** Lengths the host's way: how to write one (inches in), and whether bare numbers mean millimetres. Hides Units in Settings. */
-  units?: { format: (inches: number) => string; metric: boolean; denom?: number };
+  /**
+   * Lengths the host's way: how to write one (inches in), the unit a bare number is typed in (`unit`; without it,
+   * `metric` alone means millimetres), whether lengths are typed with fractions (the fraction keys; unset: feet-inches
+   * and inches are), and the fraction precision. Settings' Units then offers Account beside the editor's own units.
+   */
+  units?: { format: (inches: number) => string; metric: boolean; unit?: Unit; fractions?: boolean; denom?: number };
   /** Developer conveniences in Settings (reset to the demo, open and save project files). Default on. */
   devTools?: boolean;
   /** View only: pan and zoom, no tools, nothing saved (for people who can't edit the job). */
@@ -129,10 +133,11 @@ export function CadEditor({ onBack, headerRight, pickImage = pickImageInBrowser,
         : sync.persistence)
       : null);
     if (units) {
-      settings.unit = units.metric ? 'mm' : 'ftin';
+      settings.unit = units.unit ?? (units.metric ? 'mm' : 'ftin');
+      settings.fractions = units.fractions;
       if (units.denom) settings.denom = units.denom;
     }
-    setLengthFormatter(units ? units.format : null, { unit: settings.unit, denom: settings.denom });
+    setLengthFormatter(units ? units.format : null, { unit: settings.unit, denom: settings.denom, fractions: settings.fractions });
     setSkiaFonts(fonts ?? null);
     setFileSaver(saveFile ?? null);
     setImageResolver(sync?.imageUrl ?? null);

package/src/react/Popovers.tsx

@@ -8,7 +8,7 @@ import {
 import { page } from '../model/store';
 import { fitView } from '../render/view';
 import { command3d, is3d } from '../editor/view3dState';
-import { fmtLen, followingHostUnits } from '../units';
+import { fmtLen, followingHostUnits, showFractions } from '../units';
 import { settings } from '../model/settings';
 import { Toggle } from './Buttons';
 import { FitScroll } from './FitScroll';
@@ -90,11 +90,11 @@ function MoreMenu({ open, style, accountUnits, devTools, themeChoice, pickText,
         <MRow label="Units">
           <Seg<UnitChoice>
             value={accountUnits && followingHostUnits() ? 'account' : settings.unit}
-            opts={[...(accountUnits ? [['account', 'Account'] as [UnitChoice, string]] : []), ['ftin', 'ft-in'], ['in', 'in'], ['mm', 'mm']]}
+            opts={[...(accountUnits ? [['account', 'Account'] as [UnitChoice, string]] : []), ['ftin', 'ft-in'], ['in', 'in'], ['ft', 'ft'], ['mm', 'mm'], ['cm', 'cm'], ['m', 'm']]}
             onPick={setUnits}
           />
         </MRow>
-        {!(accountUnits && followingHostUnits()) && settings.unit !== 'mm' && (
+        {!(accountUnits && followingHostUnits()) && showFractions() && (
           <MRow label="Precision"><Seg value={settings.denom} opts={[[16, '1/16"'], [8, '1/8"'], [4, '1/4"']]} onPick={setPrecision} /></MRow>
         )}
         {/* 8', 9', 10' in a tap; Custom (showing the height when it's one) opens the keypad */}

package/src/react/host.ts

@@ -1,10 +1,12 @@
 import { applyReading, laser } from '../editor/laser';
 import { store } from '../model/store';
+import { takeSurveyPoint } from '../tools/survey';
 import { notify } from './store';
 
 /*
   For the host app's measuring devices (BOLDR's Bluetooth lasers and tapes): say when one is connected, and pass its
-  readings in. A reading goes into an open keypad, onto the one selected wall or line, or into the tray.
+  readings in. A reading goes into an open keypad, onto the one selected wall or line, or into the tray. A templating
+  device's points (surveyPoint) build the drawing itself.
 */
 
 /** Whether an editor is on screen (CadEditor sets it): readings that arrive after it closed are left to the host. */
@@ -30,3 +32,19 @@ export function laserReading(inches: number, capture?: unknown): boolean {
   notify();
   return true;
 }
+
+/**
+ * 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
+ * clockwise (the T1R's does) has to negate y, or every template is drawn mirrored. Each point joins the last, with its length and the
+ * corner's angle held (src/tools/survey.ts). The first one on a page lands at the middle of the screen, and the rest
+ * keep their true place relative to it for the session. False when no drawing is open to take it, or it can't now
+ * (a wall view or keypad open: the editor says so). `capture`: the host's record of the point, kept with the
+ * dimensions it sets and handed back on Save to group, as laserReading's is.
+ */
+export function surveyPoint(x: number, y: number, capture?: unknown): boolean {
+  if (!editorHost.open || !store.project || !Number.isFinite(x) || !Number.isFinite(y)) return false;
+  const ok = takeSurveyPoint(x, y, capture);
+  notify();
+  return ok;
+}

package/src/tools/chamfer.ts

@@ -35,7 +35,7 @@ export function chamferPrompt(pid: string): void {
   if (!k) { toast('Select a corner where two lines meet to cut it off.', { warn: true }); return; }
   const most = Math.min(k.len1, k.len2), start = Math.round(Math.min(6, most * 0.5) * 16) / 16;
   openKeypad({
-    title: 'Chamfer', sub: 'Back from the corner along each side — up to ' + fmtLen(most), initial: fmtLen(start), selectAll: true, laser: true,
+    title: 'Chamfer', sub: 'Back from the corner along each side — up to ' + fmtLen(most), initial: fmtLen(start), value: start, selectAll: true, laser: true,
     extras: () => [{ label: 'Unequal', ariaLabel: 'Unequal: a distance for each side', onPress: () => { closeKeypad(); unequal(pid); } }],
     onDone: d => { chamferCorner(pid, d, d); },
   });
@@ -48,12 +48,12 @@ function unequal(pid: string): void {
   const back = ed.sel;
   showSide(k.l1);
   openKeypad({
-    title: 'Chamfer · first side', sub: 'Along the selected line — up to ' + fmtLen(k.len1), initial: fmtLen(Math.round(Math.min(6, k.len1 * 0.5) * 16) / 16), selectAll: true, laser: true,
+    title: 'Chamfer · first side', sub: 'Along the selected line — up to ' + fmtLen(k.len1), initial: fmtLen(Math.round(Math.min(6, k.len1 * 0.5) * 16) / 16), value: Math.round(Math.min(6, k.len1 * 0.5) * 16) / 16, selectAll: true, laser: true,
     onClose: () => { if (ed.sel.length === 1 && ed.sel[0].id === k.l1) { ed.sel = back; updateCtx(); requestDraw(); } },
     onDone: d1 => {
       showSide(k.l2);
       openKeypad({
-        title: 'Chamfer · second side', sub: 'Along the selected line — up to ' + fmtLen(k.len2), initial: fmtLen(Math.round(Math.min(6, k.len2 * 0.5) * 16) / 16), selectAll: true, laser: true,
+        title: 'Chamfer · second side', sub: 'Along the selected line — up to ' + fmtLen(k.len2), initial: fmtLen(Math.round(Math.min(6, k.len2 * 0.5) * 16) / 16), value: Math.round(Math.min(6, k.len2 * 0.5) * 16) / 16, selectAll: true, laser: true,
         onClose: () => { if (ed.sel.length === 1 && ed.sel[0].id === k.l2) { ed.sel = back; updateCtx(); requestDraw(); } },
         onDone: d2 => { chamferCorner(pid, d1, d2); },
       });

package/src/tools/dim.ts

@@ -190,7 +190,7 @@ export function dimLine(lid: string, print: boolean, side?: 1 | -1): void {
   const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(lid, face) }] : [{ type: 'line', id: lid }]; requestDraw(); };
   show();
   const spec: KeypadSpec = {
-    title: 'Length', sub: wall ? lengthSub(sk, lid, face) : '', initial: fmtLen(len()), selectAll: true, laser: true,
+    title: 'Length', sub: wall ? lengthSub(sk, lid, face) : '', initial: fmtLen(len()), value: len(), selectAll: true, laser: true,
     extras: wall ? () => lengthChoices(sk, lid).map(ch => ({
       label: ch.label!, on: ch.face === face,
       onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, lid, face); show(); if (keypadFresh()) keypadSetReading(len()); },
@@ -423,7 +423,7 @@ export function dimPoints(a: string, b: string, print: boolean): void {
   requestDraw();
   openKeypad({
     onClose: () => { ed.preview = null; requestDraw(); },
-    title: 'Distance', initial: fmtLen(L), selectAll: true, laser: true,
+    title: 'Distance', initial: fmtLen(L), value: L, selectAll: true, laser: true,
     onDone: (v, capture) => {
       pushHistory();
       const r = tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: v, driving: true, off: 0, ...(capture !== undefined ? { capture } : {}) });
@@ -492,7 +492,7 @@ export function dimPointLine(p: string, lid: string, opts: { keepParallel?: stri
   const spec: KeypadSpec = {
     onClose: () => { ed.preview = null; requestDraw(); },
     // (which faces it's measured between: the choices beside the keys)
-    title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', initial: fmtLen(measure(sk, c)), selectAll: true,
+    title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', initial: fmtLen(measure(sk, c)), value: measure(sk, c), selectAll: true,
     extras: choices.length ? () => choices.map(ch => ({
       label: ch.label!, on: onChoice(c, ch),
       onPress: () => { applyFace(c, ch); requestOverlayDraw(); if (keypadFresh()) keypadSetReading(measure(sk, c)); },
@@ -525,7 +525,7 @@ export function dimCurve(id: string, side?: 1 | -1): void {
   const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(id, face) }] : [{ type, id }]; requestDraw(); };
   show();
   const spec: KeypadSpec = {
-    title: 'Diameter', sub: wall ? lengthSub(sk, id, face) : '', initial: fmtLen(now()), selectAll: true,
+    title: 'Diameter', sub: wall ? lengthSub(sk, id, face) : '', initial: fmtLen(now()), value: now(), selectAll: true,
     extras: wall ? () => curveChoices(sk, id).map(ch => ({
       label: ch.label!, on: ch.face === face,
       onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, id, face); show(); if (keypadFresh()) keypadSetReading(now()); },

package/src/tools/elevation.ts

@@ -25,7 +25,7 @@ export function editSill(opId: string): void {
   if (!l) return;
   const { sill, head } = openingHeights(o), h = head - sill, H = wallHeight(l);
   openKeypad({
-    title: Name(o) + ' sill height', sub: 'Floor to the bottom of the ' + nameOf(o) + ' — locks its height above the floor', initial: fmtLen(sill), selectAll: true, laser: true,
+    title: Name(o) + ' sill height', sub: 'Floor to the bottom of the ' + nameOf(o) + ' — locks its height above the floor', initial: fmtLen(sill), value: sill, selectAll: true, laser: true,
     onDone: v => {
       if (v < 0) return;
       if (v + h > H + 1e-6) {
@@ -46,7 +46,7 @@ export function editOpeningHeight(opId: string): void {
   if (!l) return;
   const { sill, head } = openingHeights(o), H = wallHeight(l);
   openKeypad({
-    title: Name(o) + ' height', sub: 'Bottom to top of the ' + nameOf(o), initial: fmtLen(head - sill), selectAll: true, laser: true,
+    title: Name(o) + ' height', sub: 'Bottom to top of the ' + nameOf(o), initial: fmtLen(head - sill), value: head - sill, selectAll: true, laser: true,
     onDone: v => {
       if (v <= 0) return;
       if (sill + v > H + 1e-6) {
@@ -67,7 +67,7 @@ export function editWallHeight(lid: string): void {
   if (!l) return;
   const tallest = Math.max(0, ...Object.values(sk.openings).filter(o => o.line === lid).map(o => openingHeights(o).head));
   openKeypad({
-    title: 'Wall height', sub: 'Floor to ceiling, this wall only', initial: fmtLen(wallHeight(l)), selectAll: true, laser: true,
+    title: 'Wall height', sub: 'Floor to ceiling, this wall only', initial: fmtLen(wallHeight(l)), value: wallHeight(l), selectAll: true, laser: true,
     onDone: v => {
       if (v <= 0) return;
       if (v < tallest - 1e-6) { toast('A door or window here reaches ' + fmtLen(tallest) + '. Enter ' + fmtLen(tallest) + ' or more, or lower it first.', { warn: true }); return; }
@@ -96,7 +96,7 @@ export function editElevationPosition(opId: string, edge: OpeningEdge, ref: Open
   const d: OpeningDim = { id: uid('od'), edge, ref, value: cur, sign: e >= r ? 1 : -1, driving: true };
   openKeypad({
     title, sub: 'Locks the ' + nameOf(o) + '’s position',
-    initial: fmtLen(cur), selectAll: true, laser: true,
+    initial: fmtLen(cur), value: cur, selectAll: true, laser: true,
     onDone: v => {
       if (v < 0) return;
       if (!fits(o, d, v)) return;

package/src/tools/fillet.ts

@@ -35,7 +35,7 @@ export function filletPrompt(pid: string): void {
   if (!cornerAt(sk, pid)) { toast('Select a corner where two lines meet to round it off.', { warn: true }); return; }
   const most = maxFillet(sk, pid), start = Math.min(6, most * 0.5);
   openKeypad({
-    title: 'Fillet radius', sub: 'Up to ' + fmtLen(most) + ' fits this corner', initial: fmtLen(Math.round(start * 16) / 16), selectAll: true, laser: true,
+    title: 'Fillet radius', sub: 'Up to ' + fmtLen(most) + ' fits this corner', initial: fmtLen(Math.round(start * 16) / 16), value: Math.round(start * 16) / 16, selectAll: true, laser: true,
     onDone: r => { filletCorner(pid, r); },
   });
 }

package/src/tools/index.ts

@@ -10,10 +10,12 @@ import { ed } from '../app/state';
 import { tools } from './registry';
 import { selectTool } from './select';
 import { arcTool, circleTool, rectTool } from './shapes';
+import { surveyTool } from './survey';
 import { cabinetTool, heightTool, wallDoorTool, wallWindowTool } from '../editor/elevation';
 
 export { tools, setTool, cancelTool } from './registry';
 export type { LineTool } from './line';
+export type { SurveyTool } from './survey';
 
 /** Register every tool. Called once from main (not at import time, so import cycles stay harmless). */
 export function registerTools(): void {
@@ -31,6 +33,8 @@ export function registerTools(): void {
     door: Object.assign({}, openingTool, { enter() { ed.openingType = 'door'; } }),
     window: Object.assign({}, openingTool, { enter() { ed.openingType = 'window'; } }),
     room: roomTool,
+    // the templator: not on the rail — a point from the host's device picks it up (see react/host.ts surveyPoint)
+    survey: surveyTool,
     aselect: makeAselectTool(),
     // markup tools: a press on a handle of the just-drawn markup reshapes it instead of drawing new
     pen: withHandles(penTool),

package/src/tools/openings.ts

@@ -90,7 +90,7 @@ export function addOpeningDim(opId: string, edge: OpeningEdge, ref: OpeningRef,
     onClose: () => { ed.preview = null; requestDraw(); },
     title: title || 'Distance to ' + name.toLowerCase(),
     sub: d.driving ? 'Locks the ' + name.toLowerCase() + '’s position' : 'Already set by other dimensions — this one can only be a reference',
-    initial: fmtLen(cur), selectAll: true, laser: true,
+    initial: fmtLen(cur), value: cur, selectAll: true, laser: true,
     onDone: v => {
       if (v < 0) return;
       if (!d.driving) {
@@ -125,7 +125,7 @@ export function editOpeningDim(id: string, part: OpeningDimPart): void {
   focusOpening(id);
   const name = nameOf(o);
   openKeypad({
-    title: name + ' width', sub: 'Edge to edge, along the wall', initial: fmtLen(g.w), selectAll: true, laser: true,
+    title: name + ' width', sub: 'Edge to edge, along the wall', initial: fmtLen(g.w), value: g.w, selectAll: true, laser: true,
     onDone: v => {
       if (v <= 0) return;
       if (v > g.L + 1e-9) { toast('That’s wider than the wall (' + fmtLen(g.L) + '). Enter ' + fmtLen(g.L) + ' or less.', { warn: true }); return; }
@@ -148,7 +148,7 @@ export function editPlacedOpeningDim(opId: string, dimId: string): void {
   openKeypad({
     title: 'Distance to ' + name,
     sub: d.driving ? 'Driving — locks the ' + name + '’s position' : 'Reference — a value makes it lock the ' + name,
-    initial: fmtLen(cur), selectAll: true, laser: true,
+    initial: fmtLen(cur), value: cur, selectAll: true, laser: true,
     // (no Reference or Delete here: they're the bar's, for the dimension selected)
     onDone: v => {
       if (v < 0) return;

package/src/tools/survey.ts

@@ -0,0 +1,216 @@
+import { afterEdit, analyze, tryAddConstraint } from '../app/edit';
+import { ed } from '../app/state';
+import { measure } from '../model/constraints';
+import { hyp } from '../model/geom';
+import { pushHistory } from '../model/history';
+import { maybeRoom, roomGeom } from '../model/rooms';
+import { onSessionReset, sessionState } from '../model/session';
+import { addLine, addPoint, gc, lineBetween, pinnedPoints } from '../model/sketch';
+import { page, SK, store } from '../model/store';
+import type { Constraint } from '../model/types';
+import { requestDraw, requestOverlayDraw, S, V } from '../render/view';
+import { fmtArea, fmtLen } from '../units';
+import { elevOpen } from '../editor/elevation';
+import { keypadOpen } from '../editor/keypad';
+import type { KeyIn } from '../editor/keys';
+import { drawsWalls, setMode } from '../editor/mode';
+import { toast, updateCtx, updateHint } from '../editor/ports';
+import { close3d } from '../editor/view3d';
+import { is3d } from '../editor/view3dState';
+import { anchorMark, setTool, type Tool } from './registry';
+
+/*
+  The templator: points measured by a device in the host app (BOLDR's T1R) build the drawing directly. Each point joins
+  the last with a line (or a wall, with the Walls toggle on), and the drawing holds what was measured: a driving
+  length on every edge, and a driving angle at every corner. That fixes the shape's FORM — a later drag moves it
+  whole, it doesn't flex it — while leaving it free to be moved and turned into place. On a closed shape the last
+  edge and the corners either side of it are already set by the rest, so they come out as reference dimensions
+  (grey, in parentheses) rather than being refused: rule 3, and the closing edge's length still shows.
+
+  Where it lands: the device measures from itself, not from the page. The first point taken on a page puts its frame
+  there — that point at the middle of the screen — and every later point keeps its true place relative to it, for
+  the rest of the session. Kept per page and not per run on purpose: a cutout taken after its outline, from the same
+  setup, has to land where it really is relative to the outline, or templating it was pointless.
+
+  Points come in on the plan's own axes — x to the right, y up (render/view.ts's S) — and are placed as given. Which
+  way a device's angle turns is the host's business, not the editor's: the host turns its device's frame into this
+  one, and that's where a mirror gets in or doesn't. BOLDR's T1R turns clockwise, so the app negates y
+  (templatorPlanInches); passing its x = r·cos θ, y = r·sin θ straight in drew every template mirrored (seen on a device,
+  2026-10-28).
+*/
+
+/** How close a point has to land to the first one to close the shape: about 50 mm, inside the device's own error. */
+export const SURVEY_CLOSE_IN = 2;
+/** A point this close to the last one is the same point taken twice (a double press), not a new corner. */
+export const SURVEY_SAME_IN = 1 / 16;
+
+interface SurveyState {
+  /** the run's points, in order */
+  chain: string[];
+  /** each point's host record (surveyPoint's `capture`), kept with the dimensions it sets */
+  captures: Record<string, unknown>;
+}
+
+export interface SurveyTool extends Tool {
+  st: SurveyState;
+  closeShape(): void;
+  finish(): void;
+}
+
+/** Each page's frame for the session: what's added to a device point to place it on the plan. */
+const frames = sessionState(() => ({ byPage: {} as Record<string, { dx: number; dy: number }> }));
+
+const fresh = (): SurveyState => ({ chain: [], captures: {} });
+const withCapture = (capture: unknown) => (capture !== undefined ? { capture } : {});
+
+/** A driving length on line `lid`, as the two points it joins are now (so nothing moves). */
+function holdLength(lid: string, a: string, b: string, capture: unknown): void {
+  const sk = SK(), pa = sk.points[a], pb = sk.points[b];
+  if (!pa || !pb) return;
+  tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: hyp(pb.x - pa.x, pb.y - pa.y), line: lid, driving: true, off: 0, ...withCapture(capture) }, { silent: true });
+}
+
+/**
+ * A corner this close to dead straight (or folded right back) is held as Collinear, not as an angle: the angle's
+ * equation turns on |cross|, whose slope vanishes there, so the solver reads a 180° angle as adding nothing (a
+ * reference dimension) and the corner is left as a hinge. Collinear says the same thing and holds it. 1e-4° is far
+ * outside where that happens (about 2e-6°) and far inside any real capture's spread, so a measured corner is never
+ * squared off by it — over a 30" edge it's a micrometre.
+ */
+const STRAIGHT_DEG = 1e-4;
+
+/** A driving angle at the corner where `l1` and `l2` meet, as it is now (Collinear, if it's straight). */
+function holdAngle(l1: string | undefined, l2: string | undefined, capture: unknown): void {
+  if (!l1 || !l2 || l1 === l2) return;
+  const c: Constraint = { type: 'angle', l1, l2, value: 0, driving: true };
+  c.value = measure(SK(), c);
+  if (c.value < STRAIGHT_DEG || c.value > 180 - STRAIGHT_DEG) { tryAddConstraint({ type: 'col', l1, l2 }, { silent: true }); return; }
+  tryAddConstraint({ ...c, ...withCapture(capture) }, { silent: true });
+}
+
+export const surveyTool: SurveyTool = {
+  st: fresh(),
+  /** Picked up (by a point arriving with another tool in hand): a new run. */
+  enter() { this.st = fresh(); },
+  /**
+   * Put down by cancelTool. Deliberately NOT the end of the run: undo cancels the tool in hand before it steps back,
+   * and ending the run there would leave a gap after every bad point undone. The run ends on Finish, Close shape,
+   * Esc or Enter (key, below) — which also put the templator down — or when another tool is picked up; either way the
+   * next point starts a new run (enter).
+   */
+  reset() { ed.preview = null; },
+  busy() { return false; },
+  /** Esc and Enter finish the run here, before the generic Esc (which can't tell itself from undo's cancel). */
+  key(e: KeyIn) {
+    if ((e.key === 'Escape' || e.key === 'Enter') && this.st.chain.length) { this.finish(); return true; }
+    return false;
+  },
+  /**
+   * End the run: the shape stays as drawn, and the templator is put down (back to Select). Left in hand it would
+   * swallow every tap — it has no pointer handling, its points come from the device — so the shape just made couldn't
+   * be selected, and a phone's bar, which drops the "Templator" label, wouldn't even say why. The next point picks it
+   * up again, in the same frame. A run of one point leaves nothing (a point on its own isn't a shape).
+   */
+  finish() {
+    const first = this.st.chain[0];
+    if (first) pinnedPoints.delete(first);
+    this.st = fresh();
+    ed.preview = null;
+    if (store.project) { gc(SK()); analyze(); }
+    if (ed.tool === 'survey') setTool('select');
+    updateCtx(); updateHint(); requestDraw();
+  },
+  /** Close the run back to its first point (the bar's Close shape, or a point taken there). */
+  closeShape() {
+    if (liveChain().length < 3) return;
+    pushHistory();
+    closeRun(undefined);
+    afterEdit();
+  },
+  hint() {
+    return this.st.chain.length
+      ? 'Take the next point with your templator. Take one back at the first point to close the shape.'
+      : 'Take points with your templator: each one joins the last.';
+  },
+};
+
+/** The run's points that are still in the drawing (an undo since can have taken the last few back). */
+function liveChain(): string[] {
+  const sk = SK(), st = surveyTool.st;
+  const keep = st.chain.filter(id => sk.points[id]);
+  if (keep.length !== st.chain.length) st.chain = keep;
+  return keep;
+}
+
+/** The run's first and last points, marked: where the next point joins, and where one would close the shape. */
+function showRun(): void {
+  const sk = SK(), ch = surveyTool.st.chain;
+  const ends = [ch[0], ch[ch.length - 1]].filter((id, i, a) => id && sk.points[id] && a.indexOf(id) === i);
+  ed.preview = ends.length ? (c, T) => { for (const id of ends) { const p = sk.points[id]; if (p) { const [x, y] = S(T, p.x, p.y); anchorMark(c, x, y); } } } : null;
+  requestOverlayDraw();
+}
+
+/** Close the run: the last edge back to the first point, its length, the two corners it makes, and a space. */
+function closeRun(capture: unknown): void {
+  const sk = SK(), st = surveyTool.st, ch = st.chain;
+  const first = ch[0], last = ch[ch.length - 1];
+  const lid = addLine(sk, last, first, { kind: drawsWalls() ? 'wall' : 'line', constr: !drawsWalls() && ed.drawConstr });
+  // (already set by the rest of the shape: these come out as reference dimensions)
+  holdLength(lid, last, first, capture ?? st.captures[first]);
+  holdAngle(lineBetween(sk, ch[ch.length - 2], last), lid, st.captures[last]);
+  holdAngle(lid, lineBetween(sk, first, ch[1]), st.captures[first]);
+  const n = ch.length, rid = drawsWalls() || !ed.drawConstr ? maybeRoom(sk, ch.slice()) : null;
+  surveyTool.finish();
+  toast(rid ? sk.rooms[rid].name + ' added — ' + fmtArea(roomGeom(sk, sk.rooms[rid]).area) : 'Closed shape, ' + n + ' sides');
+}
+
+/**
+ * A point from the host's device, in inches, on the plan's axes — y up (see the note at the top). Starts the
+ * templator if it isn't in hand, and the run's frame on a page with none yet. False when the drawing can't take it
+ * now (the toast says why).
+ */
+export function takeSurveyPoint(x: number, y: number, capture?: unknown): boolean {
+  if (ed.readOnly) return false;
+  if (elevOpen()) { toast('Back out of the wall view to take templator points on the plan.', { warn: true }); return false; }
+  if (keypadOpen()) { toast('Close the keypad, then take the point again.', { warn: true }); return false; }
+  // (the templator works on the plan: from the 3D tab or Annotate, back to Draft)
+  if (is3d()) close3d();
+  if (ed.mode !== 'draft') setMode('draft');
+  if (ed.tool !== 'survey') setTool('survey');
+
+  const sk = SK(), st = surveyTool.st, ch = liveChain();
+  const pg = page().id;
+  if (!frames.byPage[pg]) { const v = V(); frames.byPage[pg] = { dx: v.cx - x, dy: v.cy - y }; }
+  const f = frames.byPage[pg], wx = x + f.dx, wy = y + f.dy;
+
+  const last = ch.length ? sk.points[ch[ch.length - 1]] : null;
+  if (last && hyp(wx - last.x, wy - last.y) < SURVEY_SAME_IN) { toast('Same point as the last one — move the templator, then take the next.', { warn: true }); return false; }
+  if (ch.length >= 3) {
+    const p0 = sk.points[ch[0]];
+    if (hyp(wx - p0.x, wy - p0.y) < SURVEY_CLOSE_IN) { pushHistory(); closeRun(capture); afterEdit(); return true; }
+  }
+
+  pushHistory();
+  const id = addPoint(sk, wx, wy);
+  if (capture !== undefined) st.captures[id] = capture;
+  if (!ch.length) {
+    // (on its own until the next point, garbage collection would take it: kept until the run ends)
+    pinnedPoints.add(id);
+  } else {
+    const prev = ch[ch.length - 1];
+    const lid = addLine(sk, prev, id, { kind: drawsWalls() ? 'wall' : 'line', constr: !drawsWalls() && ed.drawConstr });
+    holdLength(lid, prev, id, capture);
+    if (ch.length >= 2) holdAngle(lineBetween(sk, ch[ch.length - 2], prev), lid, st.captures[prev]);
+  }
+  st.chain.push(id);
+  ed.sel = [];
+  afterEdit();
+  showRun();
+  updateHint();
+  const n = st.chain.length, a = sk.points[st.chain[n - 2]];
+  toast(n === 1 ? 'Templator: point 1, at the middle of the screen' : 'Point ' + n + ' · ' + fmtLen(hyp(wx - a.x, wy - a.y)));
+  return true;
+}
+
+// a new session (another drawing): every page's frame and the run start again
+onSessionReset(() => { surveyTool.st = fresh(); });