@things-factory/figure-ui 10.1.129 → 10.1.142

package/client/modeller/fasten-geometry.ts

@@ -3,6 +3,7 @@ import type { FigureAsset, FigureFace } from '@hatiolab/figure-model'
 
 import { boxOf } from './align.js'
 import { alignAxesOf, facesOf, faceAxisOf, hasInstanceSize, mountingPlaneOf, type Alignment } from './links.js'
+import type { FigureRevision } from './revision.js'
 
 /*
  * What the 붙이기 drawing reads (user 2026-10-01): the face a part is fastened to, seen from above, and where the part
@@ -19,11 +20,11 @@ export type FastenTarget = { part: string; face: string } | 'plane'
 const OPPOSITE: Record<FigureFace, FigureFace> = { left: 'right', right: 'left', bottom: 'top', top: 'bottom', back: 'front', front: 'back' }
 const NORMAL: Record<FigureFace, [Axis, 1 | -1]> = { left: ['x', -1], right: ['x', 1], bottom: ['y', -1], top: ['y', 1], back: ['z', -1], front: ['z', 1] }
 
-/** The world direction a part's face looks along now, turns and all; by its name when the face's outline is not read. */
-function directionOf(asset: FigureAsset, part: string, face: string): [Axis, 1 | -1] | undefined {
+/** The world direction a part's face looks along now, as drawn, turns and all; by its name when the face's outline is not read. */
+function directionOf(revision: FigureRevision, part: string, face: string): [Axis, 1 | -1] | undefined {
   const area = (() => {
     try {
-      return figurePartFaceOf(asset, part, face)
+      return figurePartFaceOf(revision.asset, part, face, revision.inputs)
     } catch {
       return undefined
     }
@@ -40,19 +41,20 @@ function directionOf(asset: FigureAsset, part: string, face: string): [Axis, 1 |
  * centre. Read from where each face looks now, so a part standing turned offers the face that is really there.
  * Undefined when the part has no such face.
  */
-export function myFaceFor(asset: FigureAsset, part: string, target: FastenTarget, mode: FastenMode): FigureFace | 'centre' | undefined {
+export function myFaceFor(revision: FigureRevision, part: string, target: FastenTarget, mode: FastenMode): FigureFace | 'centre' | undefined {
+  const asset = revision.asset
   if (mode === 'centre') return target === 'plane' ? undefined : 'centre'
   const want: [Axis, 1 | -1] | undefined =
     target === 'plane'
       ? /* The plane is met from above on a floor, from in front on a wall. */ [mountingPlaneOf(asset).normal, -1]
       : (() => {
-          const d = directionOf(asset, target.part, target.face)
+          const d = directionOf(revision, target.part, target.face)
           return d && [d[0], (mode === 'meet' ? -d[1] : d[1]) as 1 | -1]
         })()
   if (!want) return undefined
   const mine = facesOf(asset, part).filter((f): f is FigureFace => f in NORMAL)
   const hit = mine.find(f => {
-    const d = directionOf(asset, part, f)
+    const d = directionOf(revision, part, f)
     return d && d[0] === want[0] && d[1] === want[1]
   })
   return hit ?? (target !== 'plane' && mode === 'meet' && target.face in OPPOSITE ? OPPOSITE[target.face as FigureFace] : undefined)
@@ -72,17 +74,18 @@ export interface FaceView {
   edges: Record<Axis, boolean>
 }
 
-export function faceViewOf(asset: FigureAsset, part: string, target: FastenTarget): FaceView | undefined {
+export function faceViewOf(revision: FigureRevision, part: string, target: FastenTarget): FaceView | undefined {
+  const asset = revision.asset
   const across = alignAxesOf(asset, part, target)
   if (across.length !== 2) return undefined
-  const box = boxOf(asset, part)
+  const box = boxOf(revision, part)
   if (!box) return undefined
   const axes = [across[0]!.axis, across[1]!.axis] as [Axis, Axis]
   const face: Partial<Record<Axis, number>> = {}
   if (target === 'plane') {
     for (const a of axes) if (hasInstanceSize(asset, a)) face[a] = asset.designInputs[`size.${a}`]!
   } else {
-    const theirs = boxOf(asset, target.part)
+    const theirs = boxOf(revision, target.part)
     const normal = faceAxisOf(asset, target.part, target.face)
     for (const a of axes) if (theirs && a !== normal) face[a] = theirs.extent[a]
   }

package/client/modeller/figure-facts.ts

@@ -1,6 +1,8 @@
-import { compileFigureAsset, parseFigureAsset, figureOccupiedBoxesOf, figureWritersOf } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureFace } from '@hatiolab/figure-model'
 
+import { boxesOf } from './align.js'
+import { derivedOf, type FigureRevision } from './revision.js'
+
 /*
  * What the properties tab reads, kept apart from the element so it can be tested without a browser.
  */
@@ -29,16 +31,11 @@ export interface FigureFigureFacts {
  * records the face only as that node, so this is where the screen learns which one is chosen. Parts are the placed
  * bodies (`place@1`), in the order the model lists them.
  */
-let lastFacts: { source: string; facts: FigureFigureFacts } | undefined
-export function figureFigureFacts(source: string): FigureFigureFacts {
-  /* The panel renders more often than the figure changes; the same text says the same facts. */
-  if (lastFacts?.source === source) return lastFacts.facts
-  const facts = figureFactsOf(source)
-  lastFacts = { source, facts }
-  return facts
+export function figureFigureFacts(revision: FigureRevision): FigureFigureFacts {
+  return derivedOf(revision, 'figure-facts', () => figureFactsOf(revision))
 }
-function figureFactsOf(source: string): FigureFigureFacts {
-  const asset = parseFigureAsset(source) as FigureAsset & { document: { model: { nodes: Array<{ id: string; op: string }> } } }
+function figureFactsOf(revision: FigureRevision): FigureFigureFacts {
+  const asset = revision.asset as FigureAsset & { document: { model: { nodes: Array<{ id: string; op: string }> } } }
   const parts = asset.document.model.nodes.filter(node => node.op === 'place@1').map(node => node.id)
   const feature = (asset.occupancy?.contact as { surface?: { feature?: string } } | undefined)?.surface?.feature
   const found = feature?.match(/^(.+)\.mount\.(left|right|bottom|top|back|front)\.value$/)
@@ -48,16 +45,17 @@ function figureFactsOf(source: string): FigureFigureFacts {
     declared: !!asset.occupancy,
     placement: asset.placement as Placement | undefined,
     mounting: found ? { part: found[1], face: found[2] as FigureFace } : undefined,
-    suggested: suggestedMountOf(asset, parts)
+    suggested: suggestedMountOf(revision, parts)
   }
 }
 
-function suggestedMountOf(asset: FigureAsset, parts: string[]): { part: string; face: FigureFace } | undefined {
-  const placement = (asset.placement ?? 'floor') as Placement
+/* As the parts are drawn now. */
+function suggestedMountOf(revision: FigureRevision, parts: string[]): { part: string; face: FigureFace } | undefined {
+  const placement = (revision.asset.placement ?? 'floor') as Placement
   if (placement === 'center' || !parts.length) return undefined
   let boxes
   try {
-    boxes = figureOccupiedBoxesOf(compileFigureAsset(asset).evaluate().geometry, figureWritersOf(asset)).filter(b => parts.includes(b.part))
+    boxes = boxesOf(revision).filter(b => parts.includes(b.part))
   } catch {
     return undefined
   }

package/client/modeller/figure-links.ts

@@ -55,6 +55,8 @@ import { SidePanelStyles } from './side-panel-styles.js'
 import './figure-fasten-drawing.js'
 import type { FastenChange } from './figure-fasten-drawing.js'
 import { faceViewOf, modeOf, myFaceFor, turnsInPlace, type FastenMode } from './fasten-geometry.js'
+import { boxOf } from './align.js'
+import type { FigureRevision } from './revision.js'
 import { HelpToggles } from './help.js'
 import { jointAxisWord } from './joint-axis.js'
 
@@ -149,12 +151,13 @@ export class FigureLinks extends localize(i18next)(LitElement) {
     }
   `]
 
-  /** The asset being edited. */
-  @property({ attribute: false }) asset?: FigureAsset
+  /** The figure at the version on screen. */
+  @property({ attribute: false }) revision?: FigureRevision
+  private get asset(): FigureAsset | undefined {
+    return this.revision?.asset
+  }
   /** The selected part. */
   @property() partId = ''
-  /** The part's own extent along its axes now, in mm — what a dimension is fixed at when it stops following. */
-  @property({ attribute: false }) dims?: [number, number, number]
   @property({ type: Boolean }) locked = false
   /** Which ties this shows: the part's shape (size and placement, in 속성), its places (자리·능력) or its motion (움직임). */
   @property() section: 'shape' | 'places' | 'motion' = 'shape'
@@ -201,7 +204,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
     if (this.asset && this.partId && this.partId !== this.loadedFor) {
       this.loadedFor = this.partId
       /* A part's own fastening is not another part's choices: the form opens on it (walk 1, 2026-09-26). */
-      const own = this.asset && this.partId ? fasteningOf(this.asset, this.partId) : null
+      const own = this.revision && this.partId ? fasteningOf(this.revision, this.partId) : null
       this.fasten = own ? ({ ...freshFasten(), ...own } as ReturnType<typeof freshFasten>) : freshFasten()
       this.motion = freshMotion()
       this.place = freshPlace()
@@ -339,7 +342,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
         const now = followOf(asset, this.partId, axis)
         const following = now.of === 'instance' && now.axis === axis
         const custom = now.of !== 'own' && !following
-        const mm = measureNow(asset, this.partId, axis)
+        const mm = measureNow(this.revision!, this.partId, axis)
         return html`<div row>
           <b>${word(axis)}</b>
           <span measure>${mm === undefined ? '—' : `${Math.round(mm)} mm`}</span>
@@ -422,7 +425,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
   }
 
   private async openFastening(asset: FigureAsset) {
-    const own = fasteningOf(asset, this.partId)
+    const own = fasteningOf(this.revision!, this.partId)
     this.fasten = own ? ({ ...freshFasten(), ...own } as ReturnType<typeof freshFasten>) : freshFasten()
     this.spotlit = true
     await this.updateComplete
@@ -477,7 +480,8 @@ export class FigureLinks extends localize(i18next)(LitElement) {
   private follow(asset: FigureAsset, axis: Axis, choice: string, now: Follow) {
     const following = now.of !== 'own'
     /* The measure as it stands: a dimension stops following at it, and a share is taken of it. */
-    const current = dimensionNow(asset, this.partId, axis) ?? this.dims?.[AXES.indexOf(axis)] ?? 100
+    /* The part's own extent along the axis now, as drawn: what a dimension is fixed at when it stops following. */
+    const current = dimensionNow(this.revision!, this.partId, axis) ?? boxOf(this.revision!, this.partId)?.dims[AXES.indexOf(axis)] ?? 100
     if (choice === 'own') {
       if (!following) return
       this.command({ kind: 'unlink-dimension', part: this.partId, axis, mm: Math.max(1, Math.round(current)) })
@@ -524,13 +528,13 @@ export class FigureLinks extends localize(i18next)(LitElement) {
     const theirFaces = f.target ? facesOf(asset, f.target) : FACES
     const targetFace = theirFaces.includes(f.targetFace) ? f.targetFace : theirFaces[0]!
     const aim = f.toPlane ? ('plane' as const) : f.target ? { part: f.target, face: targetFace } : undefined
-    this.fasten = { ...f, ...(aim ? placeKeptOf(asset, this.partId, aim, !!f.twist) : { align: {}, alignMm: {}, alignInput: {} }) }
+    this.fasten = { ...f, ...(aim ? placeKeptOf(this.revision!, this.partId, aim, !!f.twist) : { align: {}, alignMm: {}, alignInput: {} }) }
   }
 
   private renderFastening(asset: FigureAsset) {
     const held = heldBy(asset, this.partId)
     /* Placed by an origin (ADR-0107 decision 4): attach writes faces, so the form would move it off its origin. Said, and taken off only. */
-    if (fasteningOf(asset, this.partId)?.atOrigin) {
+    if (fasteningOf(this.revision!, this.partId)?.atOrigin) {
       this.fastenCandidate = undefined
       return html`<div fastened fasten-at-origin>
         <p>${this.heldWords(asset)}</p>
@@ -559,7 +563,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
     const aim = f.toPlane ? ('plane' as const) : { part: f.target, face: targetFace }
     /* The part's own face is not chosen: the target's face and how give it (user 2026-10-01; the kernel takes no other). */
     const mode: FastenMode = f.toPlane ? 'meet' : modeOf(f.face, f.facing)
-    const derived = f.toPlane || f.target ? myFaceFor(asset, this.partId, aim, mode) : undefined
+    const derived = f.toPlane || f.target ? myFaceFor(this.revision!, this.partId, aim, mode) : undefined
     const myFace = derived ?? (mineFaces.includes(f.face) ? f.face : mineFaces[0]!)
     const align = f.target || f.toPlane ? alignOf(asset, this.partId, aim, f.align, f.alignMm, !!f.twist, f.alignInput) : undefined
     const action =
@@ -587,7 +591,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
       ...(f.twist ? [i18next.t('figure.text.fasten-summary-twist', { degrees: String(f.twist) })] : [])
     ]
     /* Across the face, a row only where the drawing cannot set it: no drawing of the face, or a share or a field to follow. */
-    const view = f.toPlane || f.target ? faceViewOf(asset, this.partId, aim) : undefined
+    const view = f.toPlane || f.target ? faceViewOf(this.revision!, this.partId, aim) : undefined
     const alignRows = (f.toPlane || f.target ? alignAxesOf(asset, this.partId, aim, !!f.twist) : []).filter(
       ({ axis }) => !view || !view.axes.includes(axis) || !!f.alignInput?.[axis] || hasInstanceSize(asset, axis)
     )

package/client/modeller/figure-preview.ts

@@ -8,6 +8,7 @@ import { create, registerFigure, unregisterFigure } from '@hatiolab/things-scene
 
 import { DEFAULT_VIEW, previewBoardDepth, sceneLook, WORKBENCH, type ViewSettings } from './figure-view.js'
 import { dialShape } from './angle-dial.js'
+import { derivedOf, type FigureRevision } from './revision.js'
 import { authoredSizeOf, PREVIEW_FACTOR, PREVIEW_WAYS, previewClampsOf, previewInstances, setupPartOf } from './preview-model.js'
 
 /**
@@ -170,7 +171,15 @@ export class FigurePreview extends localize(i18next)(LitElement) {
   `
 
   /** The figure being authored, as the editor holds it now. */
-  @property({ attribute: false }) asset?: FigureAsset
+  @property({ attribute: false }) revision?: FigureRevision
+  private get asset(): FigureAsset | undefined {
+    return this.revision?.asset
+  }
+  /** The size the figure was made at, once per version: without a declared size it is measured by evaluating the figure. */
+  private authoredSize(): { x: number; y: number; z: number } {
+    const shown = this.revision!
+    return derivedOf(shown, 'authored-size', () => authoredSizeOf(shown.asset))
+  }
   /** Which figure: the type it is registered under here is this one's own, never a real type a board uses. */
   @property() context = ''
   /**
@@ -209,7 +218,7 @@ export class FigurePreview extends localize(i18next)(LitElement) {
     const clips = asset ? [...new Set((asset.drivers ?? []).map(d => d.clip))] : []
     let clampsByWay: ReturnType<typeof previewClampsOf> = {}
     try {
-      clampsByWay = asset ? previewClampsOf(asset, authoredSizeOf(asset)) : {}
+      clampsByWay = asset ? previewClampsOf(asset, this.authoredSize()) : {}
     } catch {
       clampsByWay = {}
     }
@@ -322,7 +331,7 @@ export class FigurePreview extends localize(i18next)(LitElement) {
       this.standUp()
       return
     }
-    if (changed.has('asset') || changed.has('context')) {
+    if (changed.has('revision') || changed.has('context')) {
       this.standUp()
       return
     }
@@ -368,7 +377,7 @@ export class FigurePreview extends localize(i18next)(LitElement) {
     try {
       /* Registered as a board registers it, under a type of this preview's own: a real type's drawings stay as they are. */
       const type = `figure-preview-${this.context || 'new'}`
-      const size = authoredSizeOf(asset)
+      const size = this.authoredSize()
       /*
         The figure changed under a scene that is standing: the same type is registered again and the content made again
         inside the same 3D scene. Making a scene anew costs about a third of a second and its first drawing compiles the

package/client/modeller/figure-properties.ts

@@ -10,6 +10,7 @@ import type { FigureAuthoringAction, FigureFace } from '@hatiolab/figure-model'
 
 import { occupancyFromParts } from './occupancy.js'
 import { tagsOf, figureFigureFacts, type Placement, type FigureFigureFacts } from './figure-facts.js'
+import type { FigureRevision } from './revision.js'
 import { SidePanelStyles } from './side-panel-styles.js'
 import { ScrollbarStyles } from '@operato/styles'
 
@@ -58,8 +59,8 @@ export class FigureProperties extends localize(i18next)(LitElement) {
     }
   `]
 
-  /** The source being edited. */
-  @property({ type: String }) source?: string
+  /** The figure at the version on screen. */
+  @property({ attribute: false }) revision?: FigureRevision
   /** The saved row, if any. Category and tags live on it. */
   @property({ type: String }) figureId?: string
   @property({ type: String }) figureCategory?: string
@@ -70,7 +71,7 @@ export class FigureProperties extends localize(i18next)(LitElement) {
 
   private facts(): FigureFigureFacts | undefined {
     try {
-      return this.source ? figureFigureFacts(this.source) : undefined
+      return this.revision ? figureFigureFacts(this.revision) : undefined
     } catch {
       /* A source the format refuses has no facts to show; the verdict tab says why. */
       return undefined
@@ -252,8 +253,8 @@ export class FigureProperties extends localize(i18next)(LitElement) {
   }
 
   private declare(placement: Placement) {
-    if (!this.source) return
-    this.command(occupancyFromParts(this.source, placement))
+    if (!this.revision) return
+    this.command(occupancyFromParts(this.revision.asset, placement))
   }
 
   private command(action: FigureAuthoringAction) {

package/client/modeller/figure-verdict.ts

@@ -5,12 +5,13 @@ import { customElement, property, state } from 'lit/decorators.js'
 
 import { i18next, localize } from '@operato/i18n'
 import { ScrollbarStyles } from '@operato/styles'
-import { LIMITS, parseFigureAsset, FIGURE_PER_INSTANCE, figureCostOf } from '@hatiolab/figure-model'
+import { LIMITS, FIGURE_PER_INSTANCE, figureCostOf } from '@hatiolab/figure-model'
 
 import { inspectFigureDraft } from '../graphql/index.js'
 import type { FigureInspection } from '../types.js'
 import { gateFindingStyles, renderGateFinding } from './gate-findings.js'
 import { MEASURED } from './scene-budget.js'
+import type { FigureRevision } from './revision.js'
 import { SidePanelStyles } from './side-panel-styles.js'
 import { budgetOf, CURVE_SIZE, curveLayout, GRADE_SCALE, shortNumber, figureReportOf } from './maturity.js'
 import type { FigureBudgetUse, FigureMaturityAxis, FigureReport } from './maturity.js'
@@ -378,8 +379,10 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
     `
   ]
 
-  /** The source being edited, serialised. Every change of it is a new question. */
-  @property({ type: String }) source?: string
+  /** The figure at the version on screen. A version whose text is another is a new question. */
+  @property({ attribute: false }) revision?: FigureRevision
+  /* The text last judged: a save hands out the same version again as a new object, which asks nothing new. */
+  private judged?: string
   /** The saved row, if any — the server reads its type and last release from it. */
   @property({ type: String }) figureId?: string
   /** Changing the type changes the verdict (a temporary type is refused), so it is a reason to ask again. */
@@ -408,19 +411,22 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
   /** The report is measured once the figure has settled: it is read beside the work, and each measure compiles the figure several times. */
   private measureTimer?: ReturnType<typeof setTimeout>
   updated(changes: Map<string, unknown>) {
-    if (changes.has('source')) {
+    const text = changes.has('revision') ? this.revision?.text : this.judged
+    const changed = text !== this.judged
+    if (changed) {
+      this.judged = text
       clearTimeout(this.measureTimer)
       if (this.report === undefined && !this.measureTimer) this.measure()
       else this.measureTimer = setTimeout(() => this.measure(), MEASURE_SETTLE_MS)
     }
-    if (changes.has('source') || changes.has('figureId') || changes.has('figureType')) this.schedule()
+    if (changed || changes.has('figureId') || changes.has('figureType')) this.schedule()
   }
 
   private measure() {
     let report: FigureReport | undefined
     let bodies = 0
     try {
-      const asset = this.source ? parseFigureAsset(this.source) : undefined
+      const asset = this.revision?.asset
       const cost = asset ? figureCostOf(asset) : undefined
       bodies = cost ? cost.groups + cost.hidden : 0
       report = asset ? figureReportOf(asset) : undefined
@@ -436,7 +442,7 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
 
   private schedule() {
     clearTimeout(this.timer)
-    if (!this.source) {
+    if (!this.revision) {
       this.inspection = undefined
       return
     }
@@ -445,7 +451,7 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
 
   private async ask() {
     const question = ++this.asked
-    const source = this.source!
+    const source = this.revision!.text
     this.asking = true
     try {
       const inspection = await inspectFigureDraft(source, this.figureId)

package/client/modeller/joint-fan.ts

@@ -4,7 +4,7 @@ import type { FigureAsset } from '@hatiolab/figure-model'
 import type { FigureRenderPart } from './renderer.js'
 import { sectionShape } from './drawn-shapes.js'
 import { jointAxisUnit } from './joint-axis.js'
-import { evaluatedGeometryOf } from './evaluated.js'
+import { derivedOf, graphValuesOf, type FigureRevision } from './revision.js'
 
 /*
  * Where the selected part turns, and how far -- a translucent fan on the editing board. An axis name says nothing about which way a part swings; on a six-axis arm the author went to the preview and
@@ -183,29 +183,32 @@ function turnOf(asset: FigureAsset, part: string, values: Record<string, unknown
 }
 
 /**
- * The fan for the part, as a body to stand on the board, or null when the part does not turn. `values` are the
- * inputs the figure is drawn with now (a pose in hand included), so the fan follows the arm as it is posed.
+ * The fan for the part, as a body to stand on the board, or null when the part does not turn. Drawn at the version as it
+ * is drawn; with a value in hand, `live` gives the values in hand and the bodies drawn with them, so the fan follows the
+ * arm as it is posed.
  */
-export function jointFanOf(asset: FigureAsset, part: string, values: Record<string, number> = {}): FigureRenderPart | null {
+export function jointFanOf(revision: FigureRevision, part: string, live?: { values: Record<string, number>; geometry: readonly unknown[] }): FigureRenderPart | null {
   if (!part) return null
+  const asset = revision.asset
   let graph: ReturnType<typeof compileFigureGraph>
   try {
-    graph = compileFigureGraph(asset.document.model as never)
+    graph = derivedOf(revision, 'graph', () => compileFigureGraph(asset.document.model as never))
   } catch {
     return null
   }
-  const inputs = { ...asset.designInputs, ...asset.stateDefaults, ...values }
+  const inputs = { ...revision.inputs, ...live?.values }
   const at = (over: Record<string, number>) => graph.evaluate({ ...inputs, ...over }).values as Record<string, unknown>
+  const geometry = (live?.geometry ?? revision.geometry) as readonly { id: string }[]
   let now: Record<string, unknown>
   try {
-    now = at({})
+    now = live ? at({}) : (graphValuesOf(revision) as Record<string, unknown>)
   } catch {
     return null
   }
   let box: WorldBox | undefined
   try {
     box = figureWorldBoxesOf(
-      evaluatedGeometryOf(asset, values).filter(g => g.id === part),
+      geometry.filter(g => g.id === part) as never,
       figureWritersOf(asset)
     )[0]
   } catch {
@@ -225,7 +228,7 @@ export function jointFanOf(asset: FigureAsset, part: string, values: Record<stri
     Sized from what the joint turns, not from the selected part: selecting the elbow housing or the forearm
     shows the elbow's one fan, not a smaller one for the smaller part (user, 2026-09-24).
   */
-  const radius = Math.max(60, Math.round(Math.max(largestMeasureOf(asset, turn.turnedPart, inputs), Math.hypot(...inPlane)) * 0.6))
+  const radius = Math.max(60, Math.round(Math.max(largestMeasureOf(geometry, turn.turnedPart), Math.hypot(...inPlane)) * 0.6))
   const edge = turn.pivot.map((v, i) => v + d[i]! * radius)
 
   const { min, max } = turn.control
@@ -265,15 +268,10 @@ export function jointFanOf(asset: FigureAsset, part: string, values: Record<stri
   } as unknown as FigureRenderPart
 }
 
-/** The values in hand that belong to a record's keys (design inputs, or state defaults). */
-function pick(values: Record<string, number>, of: Record<string, number>): Record<string, number> {
-  return Object.fromEntries(Object.entries(values).filter(([id]) => id in of))
-}
-
-/** A part's largest own measure (a box side, a diameter, a length) at the inputs given; 0 when it cannot be read. */
-function largestMeasureOf(asset: FigureAsset, part: string, inputs: Record<string, number>): number {
+/** A part's largest own measure (a box side, a diameter, a length) as drawn; 0 when it cannot be read. */
+function largestMeasureOf(geometry: readonly { id: string }[], part: string): number {
   try {
-    const body = evaluatedGeometryOf(asset, inputs).find(g => g.id === part) as { shape?: { dimensions?: Record<string, number> } } | undefined
+    const body = geometry.find(g => g.id === part) as { shape?: { dimensions?: Record<string, number> } } | undefined
     const dims = Object.entries(body?.shape?.dimensions ?? {}).map(([k, v]) => (k.startsWith('radius') ? v * 2 : v))
     return dims.length ? Math.max(...dims) : 0
   } catch {

package/client/modeller/links.ts

@@ -1,8 +1,8 @@
-import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, compileFigureGraph, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf } from '@hatiolab/figure-model'
 import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureBindingPlace, FigureFace, FigureJoint } from '@hatiolab/figure-model'
 import { startingShapeKindOf } from './starting-shape.js'
-import { evaluatedGeometryOf } from './evaluated.js'
+import { graphValuesOf, type FigureRevision } from './revision.js'
 import { jointAxisToken, jointAxisVectorOf, type JointAxisVector } from './joint-axis.js'
 
 /*
@@ -163,16 +163,15 @@ export function fieldWordsOf(id: string, say: (key: string) => string): string {
 }
 
 /** What a part's own measure on an axis is now (a box's side, a cylinder's radius or length), at the design as it stands. */
-export function dimensionNow(asset: FigureAsset, part: string, axis: Axis): number | undefined {
-  const m = modelOf(asset)
+export function dimensionNow(revision: FigureRevision, part: string, axis: Axis): number | undefined {
+  const m = modelOf(revision.asset)
   /* The argument the shape names for this axis (figure-model's provider), not its place among the arguments. */
   const shape = m.nodes.find(n => n.id === `${part}.shape`)
   const edit = shape && figureShapeProviderOf(shape as never)?.edit[axis]
   const ref = edit && !('refused' in edit) ? shape!.args[edit.arg] : undefined
   if (!ref) return undefined
   try {
-    const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
-    const value = values[ref]
+    const value = graphValuesOf(revision)[ref]
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined
   } catch {
     return undefined
@@ -183,13 +182,12 @@ export function dimensionNow(asset: FigureAsset, part: string, axis: Axis): numb
  * How long a part is along one axis now, as it is drawn: the shape's own measure through figure-model's provider (a
  * cylinder's width is twice its radius), read after any rule it follows -- so a linked measure still says its size.
  */
-export function measureNow(asset: FigureAsset, part: string, axis: Axis): number | undefined {
-  const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
+export function measureNow(revision: FigureRevision, part: string, axis: Axis): number | undefined {
+  const shape = modelOf(revision.asset).nodes.find(n => n.id === `${part}.shape`)
   const edit = shape && figureShapeProviderOf(shape as never)?.edit[axis]
   if (!shape || !edit || 'refused' in edit) return undefined
   try {
-    const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
-    const value = values[shape.args[edit.arg]!]
+    const value = graphValuesOf(revision)[shape.args[edit.arg]!]
     return typeof value === 'number' && Number.isFinite(value) ? value * edit.k : undefined
   } catch {
     return undefined
@@ -329,7 +327,7 @@ export function hangsFrom(asset: FigureAsset, part: string, from: string): boole
  * from there broke its turning in place (walk 1, 2026-09-26). Null for a part fastened to nothing.
  */
 export function fasteningOf(
-  asset: FigureAsset,
+  revision: FigureRevision,
   part: string
 ): {
   face: string
@@ -344,7 +342,7 @@ export function fasteningOf(
   /** Placed by a part's origin (ADR-0107 decision 4): no face to fasten by, and the form does not write it. */
   atOrigin?: true
 } | null {
-  const record = asset.joints?.find(j => j.body1.part === part)
+  const record = revision.asset.joints?.find(j => j.body1.part === part)
   if (!record) return null
   const toPlane = 'plane' in record.body0
   const target = 'part' in record.body0 ? record.body0.part : ''
@@ -352,7 +350,7 @@ export function fasteningOf(
   const atOrigin = !('plane' in record.body0) && (!('face' in record.body0) || !('face' in record.body1))
   const twist = record.origin?.twist ?? 0
   /* Where across the face: as the record says it, and where it says nothing, where the part stands now. */
-  const kept = placeKeptOf(asset, part, toPlane ? 'plane' : { part: target, face: targetFace }, !!twist)
+  const kept = placeKeptOf(revision, part, toPlane ? 'plane' : { part: target, face: targetFace }, !!twist)
   for (const [axis, how] of Object.entries(record.origin?.align ?? {}) as Array<[Axis, unknown]>) {
     if (how === 'min' || how === 'max' || how === 'centre') {
       kept.align[axis] = how
@@ -387,18 +385,15 @@ export function fasteningOf(
  * its frame slid into it (2026-09-26). Left centred where it already is, and where the target stands turned.
  */
 export function placeKeptOf(
-  asset: FigureAsset,
+  revision: FigureRevision,
   part: string,
   target: { part: string; face: string } | 'plane',
   twisted = false
 ): { align: Partial<Record<Axis, Alignment>>; alignMm: Partial<Record<Axis, number>>; alignInput: Partial<Record<Axis, string>> } {
   const kept = { align: {} as Partial<Record<Axis, Alignment>>, alignMm: {} as Partial<Record<Axis, number>>, alignInput: {} as Partial<Record<Axis, string>> }
-  let geometry
-  try {
-    geometry = evaluatedGeometryOf(asset) as unknown as Array<{ id: string; pose?: { r: number[][]; t: number[] } }>
-  } catch {
-    return kept
-  }
+  const asset = revision.asset
+  /* Where it stands as drawn: the pose the command that fastens it sees. */
+  const geometry = revision.geometry as unknown as Array<{ id: string; pose?: { r: number[][]; t: number[] } }>
   const poseOf = (id: string) => geometry.find(g => g.id === id)?.pose
   const mine = poseOf(part)
   if (!mine) return kept
@@ -730,11 +725,10 @@ export function proportionToFollow(asset: FigureAsset): { count: number; kept: s
 }
 
 /** A value of the figure as it stands, by its graph reference. */
-export function valueNow(asset: FigureAsset, ref: string | undefined): number | undefined {
+export function valueNow(revision: FigureRevision, ref: string | undefined): number | undefined {
   if (!ref) return undefined
   try {
-    const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
-    const value = values[ref]
+    const value = graphValuesOf(revision)[ref]
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined
   } catch {
     return undefined

package/client/modeller/live.ts

@@ -2,6 +2,7 @@ import { applyFigureAuthoring, compileFigureAsset, editFigurePart } from '@hatio
 import type { FigureAsset, FigureAuthoringAction, FigurePartEdit } from '@hatiolab/figure-model'
 
 import { drawableFigureParts, type FigureRenderPart } from './renderer.js'
+import type { FigureRevision } from './revision.js'
 
 /*
  * The figure while a value is in hand: evaluated with the values being typed or dragged, drawn at once and written
@@ -62,6 +63,8 @@ export function livePartsOf(asset: FigureAsset, live: LiveValues): FigureRenderP
      * point's coordinate before it was moved, a corner's radius before it was typed again) and would put it back.
      */
     for (const id of Object.keys(design)) if (next.designInputs[id] !== asset.designInputs[id]) delete design[id]
+    /* A value the figure already holds changes nothing: a pose in hand alone is drawn from the figure as it is, not a copy. */
+    for (const id of Object.keys(design)) if (design[id] === next.designInputs[id]) delete design[id]
     if (Object.keys(design).length) next = { ...next, designInputs: { ...next.designInputs, ...design } }
     return drawableFigureParts(compileFigureAsset(next).evaluate(state).geometry)
   } catch {
@@ -88,12 +91,12 @@ export function scrubbed(start: number, pixels: number, step: number): number {
 }
 
 /**
- * The bodies to draw while a value is in hand, over every input as the session holds it now (`current`): the pose the
+ * The bodies to draw while a value is in hand, over every input of the version as the session holds it now: the pose the
  * author has already set with the other controls, and the design values. Drawing over the asset's saved defaults put
  * every other joint back to its saved angle while one slider moved (user, 2026-09-24: the arm jumped on release).
  */
-export function liveOverSession(asset: FigureAsset, current: Record<string, number>, live: LiveValues): FigureRenderPart[] | null {
+export function liveOverSession(revision: FigureRevision, live: LiveValues): FigureRenderPart[] | null {
   if (!isLive(live)) return null
-  return livePartsOf(asset, { ...live, values: { ...current, ...live.values } })
+  return livePartsOf(revision.asset, { ...live, values: { ...revision.inputs, ...live.values } })
 }