@weasel-js/labkit 1.6.0 → 1.7.0

package/dist/undo/index.d.ts

@@ -1,9 +1,9 @@
-export { au as UndoCapability } from '../_dts/frac-DTRq7Xpb.js';
+export { az as UndoCapability } from '../_dts/types-CSm9jgol.js';
+import '@weasel-js/core';
 import 'react';
-import '../_dts/PrefsRow.d-DFpPIeIC.js';
+import '../_dts/PrefsRow.d-TOZ7BgD9.js';
 import '@weasel-js/theme';
-import '@weasel-js/core';
-import '../_dts/types-B7y8hX1D.js';
+import '../_dts/types-CRPSGFAp.js';
 import '../_dts/types-DJ79Tg5J.js';
 
 /** A subscriber to a named event. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/labkit",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "React widgets for building self-contained interactive lab pages",
   "license": "MIT",
   "author": "orochi235",
@@ -74,6 +74,10 @@
       "types": "./dist/job/index.d.ts",
       "import": "./dist/job/index.js"
     },
+    "./overview": {
+      "types": "./dist/overview/index.d.ts",
+      "import": "./dist/overview/index.js"
+    },
     "./weasel-ui": {
       "types": "./dist/passthrough/weasel-ui.d.ts",
       "import": "./dist/passthrough/weasel-ui.js"
@@ -111,28 +115,29 @@
     "dev:3d": "LABKIT_EXAMPLE=3d-lab vite"
   },
   "peerDependencies": {
-    "@weasel-js/core": "1.6.0",
-    "@weasel-js/theme": "1.6.0",
+    "@weasel-js/core": "1.7.0",
+    "@weasel-js/theme": "1.7.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "dependencies": {
-    "@weasel-js/geom": "1.6.0",
-    "@weasel-js/kernel3d": "1.6.0",
-    "@weasel-js/loupe": "1.6.0",
-    "@weasel-js/svg": "1.6.0",
-    "@weasel-js/ui": "1.6.0",
-    "earcut": "2.2.4",
+    "@weasel-js/geom": "1.7.0",
+    "@weasel-js/kernel3d": "1.7.0",
+    "@weasel-js/loupe": "1.7.0",
+    "@weasel-js/quantity": "1.7.0",
+    "@weasel-js/svg": "1.7.0",
+    "@weasel-js/ui": "1.7.0",
+    "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7",
     "react-aria-components": "^1.5.0",
-    "windease": "^1.3.0",
+    "windease": "^2.0.0",
     "zustand": "^5.0.12"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
     "@rollup/plugin-alias": "^6.0.0",
-    "@testing-library/jest-dom": "^6.6.0",
-    "@weasel-js/modes": "1.6.0",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@weasel-js/modes": "1.7.0",
     "less": "^4.2.0",
     "rollup-plugin-dts": "^6.4.1",
     "tsx": "^4.19.0",

package/src/annotations/AnnotationOverlay.tsx

@@ -236,11 +236,11 @@ export function AnnotationOverlay({
         style={box}
       />
       {canvas && input ? (
-        // One scope per pane: a shared <ActionsProvider> lets only the newest
-        // canvas under it respond to input, and the rest go silently dead.
+        // Isolated so each pane keeps its own selection and tool.
         <WeaselProvider isolate>
           <ToolBridge toolId={annotationToolInfo(activeToolId)?.weaselTool ?? 'select'} />
           <SceneCanvas<AnnotationData, 'marks', WorldRect>
+            features={['pick', 'move', 'transform', 'edit']}
             ref={attachSceneCanvas}
             scene={scene}
             width={rect.w}

package/src/annotations/Annotations.less

@@ -59,16 +59,6 @@
 
 .lk-mark-list__drop {
   margin-left: auto;
-  background: none;
-  border: 0;
-  color: var(--wzl-fg-muted);
-  cursor: pointer;
-}
-
-// Box and typography come from <Input>. This only says how the field shares
-// the row.
-.lk-mark-list__title {
-  width: 100%;
 }
 
 // The export panel: a target to export, how, and at what resolution. Held in

package/src/annotations/MarkList.tsx

@@ -1,4 +1,4 @@
-import { Input } from '../passthrough/weasel-ui';
+import { CloseButton, Input } from '../passthrough/weasel-ui';
 import { useAnnotations } from './AnnotationsContext';
 import type { AnnotationMeaning } from './types';
 
@@ -35,17 +35,13 @@ export function MarkList({ meaning, config }: MarkListProps) {
               <span className="lk-mark-list__kind">{a.kind}</span>
               <span className="lk-mark-list__target">{a.target}</span>
               {stale ? <span className="lk-mark-list__stale">stale</span> : null}
-              <button
-                type="button"
+              <CloseButton
                 className="lk-mark-list__drop"
-                aria-label={`Remove ${a.kind} on ${a.target}`}
+                ariaLabel={`Remove ${a.kind} on ${a.target}`}
                 onClick={() => marks.remove(a.id)}
-              >
-                ×
-              </button>
+              />
             </div>
             <Input
-              className="lk-mark-list__title"
               aria-label={`Title of ${a.kind} on ${a.target}`}
               value={a.title ?? ''}
               placeholder="Untitled"

package/src/annotations/index.ts

@@ -28,6 +28,7 @@ export type {
   AnnotationsCapability,
   AnnotationTarget,
   AnnotationTargetInfo,
+  AnnotationToolId,
   CaptureOptions,
   CaptureResult,
   CaptureSource,

package/src/annotations/paint.test.ts

@@ -48,23 +48,12 @@ describe('markCommands', () => {
     ]);
   });
 
-  it('makes an arrow the same line, plus the head as its own command', () => {
+  it('makes an arrow the same line, carrying an end marker', () => {
     const cmds = markCommands(mark('arrow', { points: ENDS }), CONTENT);
+    expect(cmds).toHaveLength(1);
     const stroke = (cmds[0] as { stroke?: { markerEnd?: unknown } }).stroke;
     expect(stroke?.markerEnd).toBe('arrow');
-    expect(anchors([cmds[0]])).toEqual([0.1 * 200, 0.2 * 100, 0.6 * 200, 0.9 * 100]);
-
-    // The head has to be geometry, not just a field: `markerEnd` alone is
-    // inert outside the kit's own node painter, which is what shipped an
-    // arrow with no head.
-    expect(cmds).toHaveLength(2);
-    const head = anchors([cmds[1]]);
-    expect(head.length).toBeGreaterThan(0);
-    // Its vertex is the line's far end — computed, not eyeballed.
-    const near = (v: number, t: number) => Math.abs(v - t) < 1;
-    const xs = head.filter((_, i) => i % 2 === 0);
-    const ys = head.filter((_, i) => i % 2 === 1);
-    expect(xs.some((x, i) => near(x, 120) && near(ys[i] as number, 90))).toBe(true);
+    expect(anchors(cmds)).toEqual([0.1 * 200, 0.2 * 100, 0.6 * 200, 0.9 * 100]);
   });
 
   it('threads a freehand stroke through every point', () => {

package/src/annotations/paint.ts

@@ -1,20 +1,12 @@
 import type { DrawCommand, Path, Stroke } from '@weasel-js/core';
-import {
-  ellipsePath,
-  linePath,
-  markerDrawCommands,
-  PathBuilder,
-  rectPath,
-  textCommand,
-} from '@weasel-js/core';
+import { ellipsePath, linePath, PathBuilder, rectPath, textCommand } from '@weasel-js/core';
 import type { WorldRect } from './frac';
 import type { AnnotationData, FracPoint } from './types';
 
 /** One loud color, not a themed one: a mark sits over the instrument's own
  *  picture and has to be legible against whatever that picture is. */
 const MARK_COLOR = '#e5484d';
-/** World units, so a mark thickens with the picture it annotates — and so the
- *  marker geometry can be resolved here, which needs a resolved width. */
+/** World units, so a mark thickens with the picture it annotates. */
 const MARK_WIDTH = 2;
 const TEXT_SIZE = 14;
 const POINT_RADIUS = 4;
@@ -97,15 +89,7 @@ export function markCommands(
     case 'arrow': {
       const [a, b] = vertices(m, content);
       // The spec's arrow: a line carrying an end marker, not its own geometry.
-      // Markers are separate commands — a stroke's `markerEnd` is inert unless
-      // something turns it into geometry, and only the kit's own node painter
-      // does that, for the nodes it owns.
-      const marked: Stroke = { ...stroke, markerEnd: 'arrow' };
-      const path = linePath(a, b);
-      return [
-        { kind: 'path', path, stroke: marked },
-        ...markerDrawCommands(path, marked, MARK_WIDTH, undefined),
-      ];
+      return [{ kind: 'path', path: linePath(a, b), stroke: { ...stroke, markerEnd: 'arrow' } }];
     }
     case 'stroke':
       return [{ kind: 'path', path: polyline(vertices(m, content)), stroke }];

package/src/annotations/store.test.ts

@@ -294,3 +294,29 @@ describe('the annotation store', () => {
     expect(svg).toContain('#222222');
   });
 });
+
+describe('paintedMarks', () => {
+  it("hands over a target's marks in world units with their resolved style", () => {
+    let config: Record<string, string> = { angle: 'iso', shading: 'outline' };
+    const store = createAnnotationStore({
+      targets: () => TARGETS,
+      meaning: { statuses: [{ id: 'open', label: 'Open', color: '#123456' }] },
+      config: () => config,
+    });
+    store.add(RING, config);
+    const [painted] = store.paintedMarks('naive');
+    expect(painted?.mark.data.kind).toBe('rect');
+    expect(painted?.mark.pose.x).toBeCloseTo(0.3322 * 256);
+    expect(painted?.style).toEqual({ color: '#123456', stale: false });
+
+    // A config the mark no longer describes draws it dashed, as the pane does.
+    config = { angle: 'top', shading: 'outline' };
+    expect(store.paintedMarks('naive')[0]?.style.stale).toBe(true);
+  });
+
+  it('answers nothing for a target with no marks or no declaration', () => {
+    const store = makeStore();
+    expect(store.paintedMarks('occt')).toEqual([]);
+    expect(store.paintedMarks('nowhere')).toEqual([]);
+  });
+});

package/src/annotations/store.ts

@@ -6,6 +6,7 @@ import {
   sceneFromJSON,
 } from '@weasel-js/core';
 import { captureTarget } from './capture';
+import { type MarkDrawOptions, resolveMarkStyle } from './drawOne';
 import type { WorldRect } from './frac';
 import { fracContains, fracEncloses, fracToWorld, roundFrac, worldToFrac } from './frac';
 import { MarkHistory } from './history';
@@ -123,6 +124,14 @@ export function createAnnotationStore(opts: AnnotationStoreOptions): Annotations
     targets().find((t) => t.id === id);
 
   const contentOf = (id: string) => targetOf(id)?.content ?? NO_CONTENT;
+  /** How a target's marks are drawn right now — one answer for the pane, an
+   *  export and an overview, so none can disagree on a color or a dash. */
+  const drawOptionsFor = (info: AnnotationTargetInfo): MarkDrawOptions => ({
+    content: info.content,
+    positionDependsOn: info.positionDependsOn,
+    config: opts.config?.(),
+    meaning: typeof opts.meaning === 'function' ? opts.meaning() : opts.meaning,
+  });
 
   const project = (target: string, node: string): Annotation | undefined => {
     const found = scenes.get(target)?.get(asNodeId(node));
@@ -304,6 +313,21 @@ export function createAnnotationStore(opts: AnnotationStoreOptions): Annotations
       if (found) found.scene.remove(asNodeId(found.node.id));
     },
 
+    paintedMarks(target) {
+      const info = targetOf(target);
+      const scene = scenes.get(target);
+      if (!info || !scene) return [];
+      const draw = drawOptionsFor(info);
+      return [...scene.renderOrder()].flatMap((id) => {
+        const node = scene.get(asNodeId(String(id)));
+        if (!node) return [];
+        const data = node.data as AnnotationData;
+        return [
+          { mark: { pose: node.pose as MarkPose, data }, style: resolveMarkStyle(data, draw) },
+        ];
+      });
+    },
+
     async capture(target: string, captureOpts?: CaptureOptions) {
       const info = targetOf(target);
       if (!info) throw new Error(`[labkit] no annotation target called '${target}'`);
@@ -311,12 +335,7 @@ export function createAnnotationStore(opts: AnnotationStoreOptions): Annotations
         {
           target,
           scene: sceneFor(target),
-          draw: {
-            content: info.content,
-            positionDependsOn: info.positionDependsOn,
-            config: opts.config?.(),
-            meaning: typeof opts.meaning === 'function' ? opts.meaning() : opts.meaning,
-          },
+          draw: drawOptionsFor(info),
           base: info.base,
           onWarn: (message) => console.warn(`[labkit] capture: ${message}`),
         },

package/src/annotations/svgNodes.test.ts

@@ -51,16 +51,13 @@ describe('a mark as vector', () => {
     expect(node.stroke?.dash).toEqual([6, 4]);
   });
 
-  it("drops the arrow's marker reference, because its head is already a node", () => {
+  it("keeps the arrow's marker, so the export draws its head", () => {
     const nodes = markSvgNodes(mark('arrow'), CONTENT);
-    expect(nodes.length).toBeGreaterThan(1);
-    for (const node of nodes) {
-      if (node.kind !== 'path') throw new Error('expected path nodes');
-      // Keeping `markerEnd` would make the serializer emit a <marker> def as
-      // well, and the head would be drawn twice.
-      expect(node.stroke?.markerEnd).toBeUndefined();
-    }
-    expect(serializeSvg(nodes, { viewBox: { x: 0, y: 0, width: 100, height: 60 } })).not.toContain(
+    expect(nodes).toHaveLength(1);
+    const [node] = nodes;
+    if (node?.kind !== 'path') throw new Error('expected a path node');
+    expect(node.stroke?.markerEnd).toBe('arrow');
+    expect(serializeSvg(nodes, { viewBox: { x: 0, y: 0, width: 100, height: 60 } })).toContain(
       '<marker',
     );
   });

package/src/annotations/svgNodes.ts

@@ -16,9 +16,6 @@ function toSvgPaint(paint: FillStyle | undefined): SvgPaint {
   return { kind: 'gradient', paint };
 }
 
-/** Marker references are deliberately dropped: `markCommands` already resolves
- *  a marker into its own path command, and keeping the reference would make
- *  the serializer emit a `<marker>` def that draws the head a second time. */
 function toSvgStroke(stroke: Stroke): SvgStroke {
   return {
     paint: toSvgPaint(stroke.paint),
@@ -28,6 +25,9 @@ function toSvgStroke(stroke: Stroke): SvgStroke {
     ...(stroke.dash ? { dash: [...stroke.dash] } : {}),
     ...(stroke.miterLimit != null ? { miterLimit: stroke.miterLimit } : {}),
     ...(stroke.align ? { align: stroke.align } : {}),
+    ...(stroke.markerStart ? { markerStart: stroke.markerStart } : {}),
+    ...(stroke.markerMid ? { markerMid: stroke.markerMid } : {}),
+    ...(stroke.markerEnd ? { markerEnd: stroke.markerEnd } : {}),
   };
 }
 

package/src/annotations/toolMap.test.ts

@@ -1,7 +1,9 @@
 import { KIT_SHAPE_KINDS } from '@weasel-js/core';
 import { describe, expect, it } from 'vitest';
-import { ANNOTATION_TOOLS, annotationToolInfo } from './toolMap';
-import type { AnnotationKind } from './types';
+import type { InstrumentList } from '../instrument/types';
+import { resolveLabTool } from '../tools/labTool';
+import { ANNOTATION_TOOLS, annotationToolInfo, labAnnotationTools } from './toolMap';
+import type { AnnotationKind, AnnotationToolId } from './types';
 
 const KINDS: AnnotationKind[] = ['stroke', 'line', 'arrow', 'rect', 'ellipse', 'text'];
 
@@ -38,3 +40,36 @@ describe('the annotation tool table', () => {
     expect(annotationToolInfo('hand')).toBeUndefined();
   });
 });
+
+describe('the tools a lab rail carries', () => {
+  const ids = (instruments: InstrumentList) => labAnnotationTools(instruments).map((t) => t.id);
+  const inst = (annotations?: { tools?: AnnotationToolId[] }) =>
+    ({
+      annotations: annotations && { targets: () => [], ...annotations },
+    }) as unknown as InstrumentList[number];
+
+  it('carries none when no instrument annotates', () => {
+    expect(ids([inst()])).toEqual([]);
+  });
+
+  it('carries every tool for an instrument that names none', () => {
+    expect(ids([inst({})])).toEqual(ANNOTATION_TOOLS.map((t) => t.id));
+  });
+
+  it('carries only the named tools, in the kit order', () => {
+    expect(ids([inst({ tools: ['select', 'pointer'] })])).toEqual(['pointer', 'select']);
+  });
+
+  it('carries the union across annotating instruments', () => {
+    expect(ids([inst({ tools: ['pointer'] }), inst({ tools: ['rect'] }), inst()])).toEqual([
+      'pointer',
+      'rect',
+    ]);
+  });
+
+  it('starts the lab in pointer when the rail has it, else in its first tool', () => {
+    expect(resolveLabTool(null, [inst({ tools: ['select', 'pointer'] })])).toBe('pointer');
+    expect(resolveLabTool(null, [inst({ tools: ['text', 'select'] })])).toBe('select');
+    expect(resolveLabTool(null, [inst()])).toBeNull();
+  });
+});

package/src/annotations/toolMap.ts

@@ -9,6 +9,7 @@ import {
   SelectIcon,
   TextIcon,
 } from '@weasel-js/ui';
+import type { InstrumentList } from '../instrument/types';
 import type { TrialTool } from '../tools/types';
 import type { AnnotationKind } from './types';
 
@@ -46,6 +47,18 @@ export const ANNOTATION_TOOLS: readonly TrialTool[] = [
   { id: 'text', label: 'Text', icon: TextIcon, group: 'annotate' },
 ];
 
+/** The annotation tools a lab's rail carries for these instruments: none
+ *  without an annotating instrument, else the union of what each asks for. */
+export function labAnnotationTools(instruments: InstrumentList): readonly TrialTool[] {
+  const wanted = new Set<string>();
+  for (const i of instruments) {
+    if (i.annotations == null) continue;
+    if (i.annotations.tools == null) return ANNOTATION_TOOLS;
+    for (const id of i.annotations.tools) wanted.add(id);
+  }
+  return ANNOTATION_TOOLS.filter((t) => wanted.has(t.id));
+}
+
 /** What `id` drives, or undefined for a tool that is not one of these. */
 export function annotationToolInfo(id: string | null): AnnotationToolInfo | undefined {
   return id === null ? undefined : TOOLS[id];

package/src/annotations/types.ts

@@ -1,6 +1,7 @@
 import type { RefObject } from 'react';
 import type { ViewTransform } from '../instrument/types';
 import type { TrialInfo } from '../state/types';
+import type { MarkStyle, PaintableMark } from './paint';
 import type { MarkScene } from './store';
 
 /** A point in fractions of a target's content box. */
@@ -160,10 +161,25 @@ export interface AnnotationStorage {
 
 /** Declares that an instrument accepts marks: which regions take them,
  *  optionally what a mark is allowed to mean, and optionally where they live. */
+/** The annotation tools a lab's rail can carry. */
+export type AnnotationToolId =
+  | 'pointer'
+  | 'select'
+  | 'stroke'
+  | 'line'
+  | 'arrow'
+  | 'rect'
+  | 'ellipse'
+  | 'text';
+
 export interface AnnotationsCapability<TS = unknown, TC = unknown> {
   /** `trial` is which trial is asking: a declaration made once per instrument
    *  is called once per trial, and its targets are that trial's own. */
   targets: (state: TS, config: TC, trial: TrialInfo) => readonly AnnotationTarget[];
+  /** Which annotation tools the lab's rail offers. The rail is shared, so it
+   *  carries every tool any annotating instrument asks for, in the kit's own
+   *  order; an instrument that leaves this unset asks for all of them. */
+  tools?: readonly AnnotationToolId[];
   meaning?: AnnotationMeaning;
   /** An instrument replacing this one under a live trial must pass the same
    *  object: the trial keeps the marks it loaded from the first. */
@@ -183,6 +199,12 @@ export interface SerializedAnnotations {
   scenes: Record<string, unknown>;
 }
 
+/** One mark, as `AnnotationsApi.paintedMarks` hands it over. */
+export interface PaintedMark {
+  mark: PaintableMark;
+  style: MarkStyle;
+}
+
 /** Everything a host can ask or tell labkit about the marks on its targets. */
 export interface AnnotationsApi {
   /** The scene a target's marks live in, created on first ask. One per target
@@ -222,6 +244,11 @@ export interface AnnotationsApi {
   undo(): boolean;
   redo(): boolean;
 
+  /** A target's marks as its pane paints them, in scene order: geometry in
+   *  the target's content box, each with the style its status and staleness
+   *  resolve to. For a painter outside the pane — an overview. */
+  paintedMarks(target: string): PaintedMark[];
+
   /** Export a target's picture with its marks on it. Rejects on an id the
    *  instrument does not declare. */
   capture(target: string, opts?: CaptureOptions): Promise<CaptureResult>;

package/src/canvas/AGENTS.md

@@ -6,18 +6,17 @@ For a renderer labkit does not own — three.js, raw WebGL, anything with its ow
 render loop — see `src/surface/AGENTS.md` instead. `CanvasStack` is 2D and
 schedules its own layers; a foreign renderer wants rects and dirtiness only.
 
-`useOrbit` also lives here, as the 3D peer of `usePanZoom`. It produces a trial
-view (`{ yaw, pitch, distance, target }`) rather than a matrix — turning that
-into a camera is the host's job.
-
 ## Files
 
 | File | Role |
 |---|---|
-| `CanvasStack.tsx` | Layered `<canvas>` container; owns sizing, pan/zoom handlers, and per-layer canvas refs |
+| `CanvasStack.tsx` | Layered `<canvas>` container; owns sizing and per-layer canvas refs |
 | `CanvasStackContext.ts` | React context exposing the current `view` to descendants |
 | `useLayerScheduler.ts` | DPR-aware rAF scheduler; redraws dirty layers on view/state changes |
-| `usePanZoom.ts` | Pointer + wheel handlers that mutate `view` via `onViewChange` |
+| `CameraInput.tsx` | Pan, zoom and tap routed through weasel's gesture dispatcher; `CameraContext`; publishes the pointer |
+| `cameraRegistry.ts` | Cameras by trial id, so chrome outside a trial (the lab header's zoom) can drive the focused one |
+| `cameraView.ts` | The camera as a weasel `View` over frame-local coordinates, and the anchored zoom clamp |
+| `LinkedCursor.tsx` | The crosshair on the camera's element while the pointer is over another view |
 | `camera.ts` | `zoomAt` (fixed-point zoom) and `centerOn` (put a world point at a viewport's middle) |
 | `canvasCoords.ts` | Pure `screenToWorld` / `worldToScreen` helpers |
 | `worldSpec.ts` | The instrument's declared coordinate system, and the camera derived from it |
@@ -32,8 +31,8 @@ interface CanvasStackProps {
   onViewChange: (v: ViewTransform) => void;
   worldSpec?: WorldSpec;                // origin + y direction; default top-left, y down
   onResize?: (size: ViewportSize) => void;
-  minZoom?: number;                     // default 0.1, forwarded to usePanZoom
-  maxZoom?: number;                     // default 32, forwarded to usePanZoom
+  minZoom?: number;                     // default 0.1; the opening zoom stays reachable
+  maxZoom?: number;                     // default 32
   width?: number | string;              // default '100%'
   height?: number | string;             // default '100%'
   className?: string;
@@ -93,11 +92,11 @@ convention: origin at the element's top-left, y downward.
 `resolveFrame(spec, size)` turns a spec plus a measured viewport into a
 `WorldFrame` — `{ originPx, yDir }` — which is what the rest of the directory
 actually consumes. `CanvasStack` owns the measurement, so it owns the frame and
-hands it to `usePanZoom`, to the scheduler, and to every `render`.
+hands it to the camera (`useCameraView`), to the scheduler, and to every `render`.
 
 **Every world↔screen path must go through the frame.** There are four, and each
 one is a silent wrong answer if it is missed: `worldToScreen` / `screenToWorld`,
-the camera (`applyCamera`), the wheel anchor in `usePanZoom`, and
+the camera (`applyCamera`), the camera as a weasel `View` (`cameraView.ts`), and
 `DragDropRuntime`'s drop position. A miss produces geometry that is off by a
 constant, or a wheel that drifts — never an error.