@reekon-tools/boldr-cad 1.5.0 → 1.7.0

package/src/editor/linkActions.ts

@@ -3,20 +3,20 @@ import { ed } from '../app/state';
 import { clamp } from '../model/geom';
 import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
-import { isLink, LINK_COLOR, LINK_MAX_IN, LINK_MIN_IN, LINK_TILE_PX, linkInfoOf, linkName, linkSide, linkSnapshot } from '../model/links';
+import { 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 { askConfirm } from './confirm';
 import { imageById } from '../model/images';
 import { settings } from '../model/settings';
 import { page, SK, store } from '../model/store';
-import type { LinkTarget, Note, Underlay } from '../model/types';
+import type { LinkTarget, Note, 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';
 import { elevOpen } from './elevation';
 import { is3d } from './view3dState';
-import { canLink, linksHost, openLink, pickLinks } from './links';
+import { besideOpen, canLink, canOpenBeside, linksHost, openLink, openLinkBeside, pickLinks } from './links';
 import { toast } from './ports';
 
 /*
@@ -68,6 +68,8 @@ export async function addLinks(): Promise<void> {
   let k = 0;
   while (k < 40 && spots.some(([x, y]) => taken(x + k * step, y - k * step))) k++;
   pushHistory();
+  // (the page's first tiles: the size they're placed at is their 100%)
+  if (pageLinkSize(sk) == null) sk.tileRef = ts;
   const ids = picked.map((t, i) => {
     const n: Note = { id: uid('lk'), type: 'link', x: spots[i][0] + k * step, y: spots[i][1] - k * step, ts, color: LINK_COLOR, link: linkSnapshot(t) };
     sk.notes.push(n);
@@ -83,7 +85,9 @@ const LINK_GAP_PX = 16;
 
 /*
   Every tile on a page is one size, on the drawing (so it zooms with the plan and prints at that size): the Tile size
-  slider above the bar, shown while a tile is selected, sizes them all together.
+  slider above the bar, shown while a tile is selected, sizes them all together. It says how big in percent of the size
+  they were first placed at (the user's call, 2026-11-03): a tile has no real size, and before the page's first length
+  its inches are only placeholders, so feet and metres said nothing true.
 */
 
 /** The size of the page's tiles, inches on the drawing (null: it has none). */
@@ -99,21 +103,44 @@ export function linkSizeVisible(): boolean {
   return ed.sel.some(x => x.type === 'note' && sk.notes.find(n => n.id === x.id)?.type === 'link');
 }
 
+/** What the page's tiles call 100%, inches on the drawing: the size they were first placed at (a page from before: theirs now). */
+const tileRef = (sk: Sketch): number => sk.tileRef ?? pageLinkSize(sk) ?? LINK_SIDE_IN;
+
+/** How big the page's tiles are, in percent of the size they were first placed at (null: it has none). */
+export function pageTilePct(sk = SK()): number | null {
+  const s = pageLinkSize(sk);
+  return s == null ? null : Math.round((s / tileRef(sk)) * 100);
+}
+
+/** The slider's range, percent. */
+export const TILE_PCT_MIN = 10, TILE_PCT_MAX = 1000;
+
 /**
- * Size every tile on the page (inches, to the quarter, from LINK_MIN_IN to LINK_MAX_IN), drawn at once — for the slider
- * as it moves. The caller makes the undo step before, and finishes the edit after.
+ * Size every tile on the page to `pct` percent (TILE_PCT_MIN to TILE_PCT_MAX; and never past LINK_HARD_MIN_IN to
+ * LINK_HARD_MAX_IN on the drawing — placing's 6"–40' bounds would cut the range short), drawn at once — for the slider as
+ * it moves. The caller makes the undo step before, and finishes the edit after. (A page from before keeps its 100% from
+ * here on.)
  */
-export function setLinkSize(inches: number): void {
-  const v = Math.round(clamp(inches, LINK_MIN_IN, LINK_MAX_IN) * 4) / 4;
-  for (const n of SK().notes) if (isLink(n)) n.ts = v;
+export function setTilePct(pct: number): void {
+  const sk = SK(), ref = tileRef(sk), v = clamp((ref * clamp(pct, TILE_PCT_MIN, TILE_PCT_MAX)) / 100, LINK_HARD_MIN_IN, LINK_HARD_MAX_IN);
+  sk.tileRef = ref;
+  for (const n of sk.notes) if (isLink(n)) n.ts = v;
   requestDraw();
 }
 
-/** The slider runs along a log scale (a few inches to many feet, each step as noticeable as the last): 0 to SIZE_STEPS. */
+/**
+ * The slider runs along a log scale (each step as noticeable as the last), 0 to SIZE_STEPS, 100% in the middle; it
+ * catches at 100%, so the size they came in at is easy to find again, and says round numbers: whole percents to 200%,
+ * then fives, then tens from 500%.
+ */
 export const SIZE_STEPS = 1000;
-const LOG_MIN = Math.log(LINK_MIN_IN), LOG_SPAN = Math.log(LINK_MAX_IN) - LOG_MIN;
-export const sizeToStep = (inches: number): number => Math.round(((Math.log(clamp(inches, LINK_MIN_IN, LINK_MAX_IN)) - LOG_MIN) / LOG_SPAN) * SIZE_STEPS);
-export const stepToSize = (step: number): number => Math.exp(LOG_MIN + (clamp(step, 0, SIZE_STEPS) / SIZE_STEPS) * LOG_SPAN);
+const LOG_MIN = Math.log(TILE_PCT_MIN), LOG_SPAN = Math.log(TILE_PCT_MAX) - LOG_MIN;
+export const pctToStep = (pct: number): number => Math.round(((Math.log(clamp(pct, TILE_PCT_MIN, TILE_PCT_MAX)) - LOG_MIN) / LOG_SPAN) * SIZE_STEPS);
+export function stepToPct(step: number): number {
+  const p = Math.exp(LOG_MIN + (clamp(step, 0, SIZE_STEPS) / SIZE_STEPS) * LOG_SPAN);
+  if (Math.abs(p - 100) < 4) return 100;
+  return p >= 500 ? Math.round(p / 10) * 10 : p >= 200 ? Math.round(p / 5) * 5 : Math.round(p);
+}
 
 /** A tile's leader on or off. On, it points out beside the tile (to the right, or the left near the screen's edge). */
 export function toggleLeader(id: string): void {
@@ -129,27 +156,57 @@ export function toggleLeader(id: string): void {
   afterEdit();
 }
 
+/*
+  Open, for what a link is for: the host's own way (another screen, a sheet over the drawing), or — the user's call,
+  2026-10-30 — in a pane beside the drawing, a split view, where the host has one (CadLinks.openBeside). The bar's Open
+  asks which while no pane is open (opensWithChoice); once one is, Open goes to it.
+*/
+
+/** How Open opens: `here`, the host's own way; `beside`, in a pane beside the drawing; `auto`, beside if one's open. */
+export type OpenHow = 'auto' | 'here' | 'beside';
+
 /** Open what the selected tile, or the selected expanded photo, is for. */
-export function openSelectedLink(): void {
+export function openSelectedLink(how: OpenHow = 'auto'): void {
+  const t = selectedLink()?.link ?? selectedLinkedImage()?.link;
+  if (t) openLinkTarget(t, how);
+}
+
+/** What the bar's Open is for: the selected tile's or expanded photo's link, or the selected linked dimension's. */
+export function selectedOpenTarget(): LinkTarget | null {
   const t = selectedLink()?.link ?? selectedLinkedImage()?.link;
-  if (t) openTarget(t);
+  if (t) return t;
+  const s = ed.sel;
+  return s.length === 1 && s[0].type === 'dim' ? SK().cons[s[0].id]?.measurementRef ?? null : null;
+}
+
+/** Whether Open asks how to open `t`: the host can show it beside the drawing, and no pane's open yet. */
+export function opensWithChoice(t: LinkTarget): boolean {
+  return canOpenLink(t) && canOpenBeside(t) && !besideOpen();
 }
 
-function openTarget(t: LinkTarget): void {
-  if (!canOpenLink(t)) { toast(linkInfoOf(t)?.exists === false ? 'That’s been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
-  openLink(t);
+/** Open what `t` is for, `how` it's asked to (see OpenHow); one that's gone, or can't be, says so instead. */
+export function openLinkTarget(t: LinkTarget, how: OpenHow = 'auto'): void {
+  if (!canOpenLink(t)) {
+    const gone = linkInfoOf(t)?.exists === false;
+    toast(!gone ? 'That can’t be opened from here.'
+      : t.kind === 'measurement' ? 'That measurement has been removed from the job, so it can’t be opened.'
+      : 'That’s been removed from the job, so it can’t be opened.', { warn: true });
+    return;
+  }
+  if ((how === 'beside' || (how === 'auto' && besideOpen())) && canOpenBeside(t)) openLinkBeside(t);
+  else openLink(t);
 }
 
-/** An expanded photo's badge, tapped: what it's for opens. */
+/** An expanded photo's badge, tapped: what it's for opens (beside the drawing, if a pane's open there). */
 export function openImageLink(id: string): void {
   const t = imageById(id)?.link;
-  if (t) openTarget(t);
+  if (t) openLinkTarget(t);
 }
 
 /*
   A photo's tile expands into the photo whole, and back (the user's call, 2026-10-26: "for image objects … you should
   be able to expand and condense the tile … this is how skia works, it expands the image to full size + shows a link
-  icon in the corner"). Expanded, it's one of the page's images — moved, sized, stretched, turned, faded and locked as
+  icon in the corner"). Expanded, it's one of the page's images — moved, sized, cropped, turned, faded and locked as
   any is — with the link's badge in its corner; Expand in the bar (on) folds it back into its tile where it is. An image
   from the computer has no link, so none of this. Each way is one undo step, and what was selected stays selected.
 */
@@ -198,6 +255,8 @@ export function collapseLink(id: string): void {
   const n: Note = { ...(was ?? { id: '', type: 'link', color: LINK_COLOR }), type: 'link', x: m.x, y: m.y, ts, link: u.link };
   if (!n.id || sk.notes.some(x => x.id === n.id)) n.id = uid('lk');
   pushHistory();
+  // (the page's only tile, back: its size is the 100%, unless the page already has one)
+  if (pageLinkSize(sk) == null && sk.tileRef == null) sk.tileRef = ts;
   page().underlays.splice(page().underlays.indexOf(u), 1);
   sk.notes.push(n);
   ed.sel = [{ type: 'note', id: n.id }];
@@ -220,7 +279,11 @@ export function readOnlyTap(sx: number, sy: number, touch: boolean): void {
   askConfirm({
     title: 'Open ' + linkName(t) + '?',
     msg: where ? 'It’s in ' + where + '.' : undefined,
-    choices: [{ label: 'Open', run: () => openLink(t) }, { label: 'Cancel', run: () => {} }],
+    choices: [
+      { label: 'Open', run: () => openLinkTarget(t, 'here') },
+      ...(canOpenBeside(t) ? [{ label: 'Open side by side', run: () => openLinkTarget(t, 'beside') }] : []),
+      { label: 'Cancel', run: () => {} },
+    ],
   });
 }
 
@@ -234,11 +297,9 @@ export function unlinkDim(id: string): void {
 }
 
 /** Open the measurement a dimension is linked to. */
-export function openDimLink(id: string): void {
+export function openDimLink(id: string, how: OpenHow = 'auto'): void {
   const t = SK().cons[id]?.measurementRef;
-  if (!t) return;
-  if (!canOpenLink(t)) { toast(linkInfoOf(t)?.exists === false ? 'That measurement has been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
-  openLink(t);
+  if (t) openLinkTarget(t, how);
 }
 
 /**

package/src/editor/links.ts

@@ -1,4 +1,4 @@
-import { linkInfo, linkKey, linkTargets } from '../model/links';
+import { linkInfo, linkInfoOf, linkKey, linkTargets } from '../model/links';
 import { onSessionReset } from '../model/session';
 import { store } from '../model/store';
 import type { LinkInfo, LinkTarget } from '../model/types';
@@ -67,6 +67,13 @@ export interface CadLinks {
   subscribe(targets: LinkTarget[], cb: (info: Record<string, LinkInfo>) => void): () => void;
   /** Open what `target` is for (another screen, or a sheet over the drawing). */
   open(target: LinkTarget): void;
+  /**
+   * Open what `target` is for in a pane beside the drawing (a split view), the drawing staying as it is. With this, the
+   * bar's Open asks how — Open, or Open side by side — until a pane is open (besideOpen), when Open goes to it.
+   */
+  openBeside?(target: LinkTarget): void;
+  /** Whether a pane is open beside the drawing now (with openBeside). */
+  besideOpen?(): boolean;
   /** Change a linked measurement (micrometres, or degrees), the person having said to; `capture` as saveMeasurement's. */
   update?(target: LinkTarget, value: number, capture?: unknown): void;
   /** Save a dimension as a new measurement in the drawing's own group; resolves with it (null: not saved). */
@@ -179,3 +186,12 @@ export async function pickJobMeasurement(kind: MeasurementKind): Promise<LinkTar
 
 /** Open what a link is for. */
 export function openLink(t: LinkTarget): void { host?.open(t); }
+
+/** Open what a link is for in a pane beside the drawing (CadLinks.openBeside). */
+export function openLinkBeside(t: LinkTarget): void { host?.openBeside?.(t); }
+
+/** Whether the host can show `t` in a pane beside the drawing. */
+export function canOpenBeside(t: LinkTarget): boolean { return !!host?.openBeside && linkInfoOf(t)?.canOpenBeside !== false; }
+
+/** Whether a pane is open beside the drawing now. */
+export function besideOpen(): boolean { return !!host?.besideOpen?.(); }

package/src/editor/mode.ts

@@ -58,11 +58,12 @@ export const railIcon = (id: string): string => WALL_ICON[id] ?? id;
 /** The tool rail for each mode. 'toggle' items switch something on and off; 'act' items run an action. */
 export const RAIL: Record<Mode, RailItem[]> = {
   draft: [
-    // drawing; then the building (walls, what goes in them, spaces); then guides
-    ['select', 'Select', 'V'], ['line', 'Line', 'L'], ['freehand', 'Draw to shape', 'S'], ['rect', 'Rectangle', 'R'], ['circle', 'Circle', 'C'], ['arc', 'Arc', 'A'], '|',
+    // drawing, and Trim last of it (the user's call, 2026-11-03); then the building (walls, what goes in them, spaces);
+    // then guides
+    ['select', 'Select', 'V'], ['line', 'Line', 'L'], ['freehand', 'Draw to shape', 'S'], ['rect', 'Rectangle', 'R'], ['circle', 'Circle', 'C'], ['arc', 'Arc', 'A'], ['trim', 'Trim', 'T'], '|',
     ['door', 'Door', 'B'], ['window', 'Window', 'N'], ['room', 'Space', 'M'], '|',
-    // Trim (T), Offset (O) and Dimension (D) stay on the keyboard; Offset is also in the bar for a selected line, and
-    // measuring is the yellow + for what's selected (the user's call, 2026-10-24: no Dimension on the rail).
+    // Offset (O) and Dimension (D) stay on the keyboard; Offset is also in the bar for a selected line, and measuring is
+    // the yellow + for what's selected (the user's call, 2026-10-24: no Dimension on the rail).
     // The toggles together: what's drawn is walls, or guides (one or the other, never both)
     ['wall', 'Walls', 'W', 'toggle'], ['constr', 'Construction lines', 'X', 'toggle'], '|',
     ['undo', 'Undo', '⌘Z', 'act'], ['redo', 'Redo', '⇧⌘Z', 'act'],
@@ -79,7 +80,8 @@ export const RAIL: Record<Mode, RailItem[]> = {
 /**
  * Tools that share one place on a phone's rail, which has no room for each: a tap draws with the one used last (the
  * place shows it), and a long press opens a menu of them all (react/ShapeMenu.tsx) — Draft's Line, Rectangle, Circle
- * and Arc, and Annotate's markup shapes. A tablet's or a browser's rail shows every one in its own place.
+ * and Arc, and Annotate's markup shapes. A tablet's or a browser's rail shows every one in its own place. (Trim isn't
+ * one of them: on a phone it has its own place, under Draw to shape — the user's call, 2026-11-03.)
  */
 export const SHAPE_TOOLS = ['line', 'rect', 'circle', 'arc'];
 export const SHAPES_GROUP = 'shapes';

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/selection.ts

@@ -103,7 +103,7 @@ export function selectionHint(): string {
   if (s.n === 1 && s.image) {
     // (a photo of the job's, expanded from its tile: its link opens it, and Expand folds it back)
     const u = imageById(ed.sel[0].id), what = u?.link ? '<b>Photo</b>' : '<b>Image</b>', link = u?.link ? ' · its link opens it' : '';
-    return u?.locked ? what + ' · locked — tap Unlock to move or resize it' + link : what + ' · drag to move · corners scale, side handles stretch' + link;
+    return u?.locked ? what + ' · locked — tap Unlock to move or resize it' + link : what + ' · drag to move · corners scale, side handles crop' + link;
   }
   if (s.n === 1 && s.notes.length && SK().notes.find(n => n.id === s.notes[0])?.type === 'link') return '<b>Link</b> · drag to move · open it, or point it at the drawing with a leader, below · Size sizes every tile on the page';
   if (s.notes.length) return 'Drag to move. Turn a pen stroke into lines below.';

package/src/editor/tooltips.ts

@@ -15,6 +15,7 @@ const TIPS: Record<string, string> = {
   rect: 'Tap or drag corner to corner.',
   circle: 'Tap the center, then the edge.',
   arc: 'Tap both ends, then drag to bend.',
+  trim: 'Tap or drag across the pieces to cut away.',
   door: 'Tap a wall to add a 3\'-0" door.',
   window: 'Tap a wall to add a 3\'-0" window.',
   room: 'Tap inside a closed shape.',

package/src/index.ts

@@ -10,8 +10,8 @@ export type { CadDataProvider, CadFileMeta, CadMeasurements, CadMeasurementValue
 export type { Unit } from './units';
 export { memoryProvider } from './data/memory';
 export { setFileSaver } from './react/ports';
-export { laserReading, setLaserConnected, surveyClose, surveyCursor, surveyPoint } from './react/host';
-export type { HostKeypad, HostKeypadExtra, HostKeypadRequest, MeasurementList, MeasurementListPage } from './react/hostKeypad';
+export { BESIDE as CAD_BESIDE } from './react/pageLock';
+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/constraints.ts

@@ -16,6 +16,7 @@ export function consLabel(c: Constraint): string {
   if (c.type === 'dist' || c.type === 'pldist') return (c.type === 'dist' ? (c.line ? 'Length ' : 'Distance ') : 'Offset ') + fmtLen(c.value!);
   if (c.type === 'diam') return c.rad ? 'Radius ' + fmtLen(c.value! / 2) : 'Diameter ' + fmtLen(c.value!);
   if (c.type === 'angle') return 'Angle ' + fmtAng(c.value!);
+  if (c.type === 'online' && c.face) return 'Point on face';
   return CONS_LABEL[c.type] || c.type;
 }
 

package/src/model/geom.ts

@@ -34,6 +34,16 @@ export function lineCircleT(A: XY, B: XY, c: XY, r: number): number[] {
   return [(-b - s) / (2 * a), (-b + s) / (2 * a)].filter(t => t > 1e-6 && t < 1 - 1e-6);
 }
 
+/** Where circle (c1, r1) crosses circle (c2, r2): none, one where they touch, or two. */
+export function circleCircle(c1: XY, r1: number, c2: XY, r2: number): XY[] {
+  const dx = c2.x - c1.x, dy = c2.y - c1.y, d = hyp(dx, dy);
+  if (d < 1e-12 || d > r1 + r2 + 1e-9 || d < Math.abs(r1 - r2) - 1e-9) return [];
+  const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d), h2 = r1 * r1 - a * a, h = h2 > 0 ? Math.sqrt(h2) : 0;
+  const mx = c1.x + (dx * a) / d, my = c1.y + (dy * a) / d;
+  if (h < 1e-12) return [{ x: mx, y: my }];
+  return [{ x: mx - (dy * h) / d, y: my + (dx * h) / d }, { x: mx + (dy * h) / d, y: my - (dx * h) / d }];
+}
+
 /** Circumcenter of three points, or null if they are collinear. */
 export function circum(a: XY, b: XY, c: XY): XY | null {
   const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));

package/src/model/links.ts

@@ -22,8 +22,13 @@ export const isLink = (n: Note): n is Note & { link: LinkTarget } => n.type ===
 
 /** How big a tile is on the screen as it's placed (points): its side on the drawing is what that is at the zoom then. */
 export const LINK_TILE_PX = 96;
-/** How big a tile can be on the drawing, inches; unset (never, once placed), this. */
+/** How big a tile can be on the drawing as it's placed, inches; unset (never, once placed), this. */
 export const LINK_MIN_IN = 6, LINK_MAX_IN = 480, LINK_SIDE_IN = 24;
+/**
+ * How big the Tile size slider can make one, inches: wide enough that its 10%–1000% of the size tiles came in at is
+ * there to reach, and inside what the tile's drawing clips to (render/linkTile.ts: clipToBar).
+ */
+export const LINK_HARD_MIN_IN = 1, LINK_HARD_MAX_IN = 2400;
 /**
  * On the screen, points: from LINK_FULL_PX across a tile shows its picture or icon and its name; under LINK_PIN_PX it's
  * a pin of that size, however far out the drawing is.

package/src/model/scale.ts

@@ -47,6 +47,8 @@ export function scaleSketch(sk: Sketch, k: number): void {
     // (a note's letters and a tile's side are inches on the drawing: they zoom with it, so they scale with it)
     if (n.ts != null) n.ts *= k;
   }
+  // (and what the tiles' 100% is, so their percent holds)
+  if (sk.tileRef != null) sk.tileRef *= k;
   for (const c of Object.values(sk.cons)) {
     if (c.off != null) c.off *= k;
     // (none should be here before the first length; one that is keeps measuring what it measures, met as it was)

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/sketch.ts

@@ -321,23 +321,30 @@ export function restorePos(sk: Sketch, s: PosSnapshot): void {
   for (const id in s.r) if (sk.circles[id]) sk.circles[id].r = s.r[id];
 }
 
-/** Every line and arc joined end to end with the given ones (through shared points), including them. */
+/**
+ * Every line and arc joined end to end with the given ones (through shared points), including them. Guides join only
+ * guides, and walls and lines only walls and lines: a guide drawn off a shape's corner isn't part of the shape, nor the
+ * shape part of the guides (the user's call, 2026-11-02).
+ */
 export function connectedGeometry(sk: Sketch, lineIds: string[], arcIds: string[] = []): { lines: string[]; arcs: string[] } {
+  // the points reached by walls and lines [0], and by guides [1]
+  const pts = [new Set<string>(), new Set<string>()], lines = new Set(lineIds), arcs = new Set(arcIds);
+  type End = { a: string; b: string; constr?: boolean };
   // on a wall face, the plan's corners and edges aren't part of a shape: nothing joins through them
-  const pts = new Set<string>(), lines = new Set(lineIds), arcs = new Set(arcIds);
-  const join = (p: string) => { if (!sk.points[p]?.anchor) pts.add(p); };
-  lineIds.forEach(id => { const l = sk.lines[id]; if (l) { join(l.a); join(l.b); } });
-  arcIds.forEach(id => { const a = sk.arcs[id]; if (a) { join(a.a); join(a.b); } });
+  const join = (o: End) => { for (const p of [o.a, o.b]) if (!sk.points[p]?.anchor) pts[+!!o.constr].add(p); };
+  const meets = (o: End) => pts[+!!o.constr].has(o.a) || pts[+!!o.constr].has(o.b);
+  lineIds.forEach(id => { const l = sk.lines[id]; if (l) join(l); });
+  arcIds.forEach(id => { const a = sk.arcs[id]; if (a) join(a); });
   let grow = true;
   while (grow) {
     grow = false;
     for (const id in sk.lines) {
       const l = sk.lines[id];
-      if (!lines.has(id) && !l.anchor && !l.cab && (pts.has(l.a) || pts.has(l.b))) { lines.add(id); join(l.a); join(l.b); grow = true; }
+      if (!lines.has(id) && !l.anchor && !l.cab && meets(l)) { lines.add(id); join(l); grow = true; }
     }
     for (const id in sk.arcs) {
       const a = sk.arcs[id];
-      if (!arcs.has(id) && (pts.has(a.a) || pts.has(a.b))) { arcs.add(id); join(a.a); join(a.b); grow = true; }
+      if (!arcs.has(id) && meets(a)) { arcs.add(id); join(a); grow = true; }
     }
   }
   return { lines: [...lines], arcs: [...arcs] };