@things-factory/figure-ui 10.1.75 → 10.1.77

package/client/modeller/{v3-links.ts → links.ts}

@@ -1,9 +1,9 @@
-import { V3_FACES, v3ShapeFaces, v3PartsExtentOf, compileV3Asset, compileV3Graph, v3FollowOf, proposeV3Proportion, defaultInstanceSizeRange, foldInstanceSizeRange, v3AttachmentsOf, v3BindingsOf, v3InstanceSizeLimitsOf } from '@hatiolab/figure-model'
-import type { V3Follow, V3SizeRange } from '@hatiolab/figure-model'
-import type { V3Asset, V3BindingPlace, V3Face, V3Joint } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, compileFigureGraph, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf } from '@hatiolab/figure-model'
+import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureBindingPlace, FigureFace, FigureJoint } from '@hatiolab/figure-model'
 
 /*
- * What a V3 part is tied to — the readers behind the parts' size response, fastening and motion sections. Kept apart from the element so they can be tested without a browser.
+ * What a part is tied to — the readers behind the parts' size response, fastening and motion sections. Kept apart from the element so they can be tested without a browser.
  */
 
 export type Axis = 'x' | 'y' | 'z'
@@ -15,11 +15,11 @@ interface Node {
   args: string[]
   outputs: Record<string, string>
 }
-const modelOf = (asset: V3Asset) =>
+const modelOf = (asset: FigureAsset) =>
   asset.document.model as unknown as { nodes: Node[]; inputs: Array<{ id: string; role?: string; unit?: string; min?: number; max?: number }>; constants: Array<{ id: string; value: number }> }
 
-/** What one dimension of a part is worked out from (figure-model's `V3Follow`). */
-export type Follow = V3Follow
+/** What one dimension of a part is worked out from (figure-model's `FigureFollow`). */
+export type Follow = FigureFollow
 
 /**
  * `link-dimension` routes a part's dimension through `<part>.dimension.<axis>` and points its first argument at the
@@ -27,16 +27,16 @@ export type Follow = V3Follow
  * instance size (`size.<axis>`), another part's dimension (`<part>.dimension.<axis>.value`) or a declared input.
  */
 /** What one measure of a part is worked out from, read back from the graph (figure-model's reader, one copy). */
-export function followOf(asset: V3Asset, part: string, axis: Axis): Follow {
-  return v3FollowOf(asset, part, axis)
+export function followOf(asset: FigureAsset, part: string, axis: Axis): Follow {
+  return figureFollowOf(asset, part, axis)
 }
 
 /** Whether the asset declares an instance size on an axis — only then can a dimension follow it. */
-export const hasInstanceSize = (asset: V3Asset, axis: Axis) => modelOf(asset).inputs.some(i => i.id === `size.${axis}` && i.role === 'design')
+export const hasInstanceSize = (asset: FigureAsset, axis: Axis) => modelOf(asset).inputs.some(i => i.id === `size.${axis}` && i.role === 'design')
 
 /** The part this one is fastened to, or `null`. The mounting plane counts as fastened (the model names no part). */
-export function fastenedTo(asset: V3Asset, part: string): string | null {
-  return v3AttachmentsOf(asset)[part] ?? null
+export function fastenedTo(asset: FigureAsset, part: string): string | null {
+  return figureAttachmentsOf(asset)[part] ?? null
 }
 
 /**
@@ -44,7 +44,7 @@ export function fastenedTo(asset: V3Asset, part: string): string | null {
  * it; a part standing on the plane had read as fastened to nothing, so the form offered no way to move it and sent
  * no replace -- the fastening was refused as already made (the door's post, 2026-09-25).
  */
-export function heldBy(asset: V3Asset, part: string): { part: string } | { plane: true } | null {
+export function heldBy(asset: FigureAsset, part: string): { part: string } | { plane: true } | null {
   const record = asset.joints?.find(j => j.body1.part === part)
   if (record) return 'plane' in record.body0 ? { plane: true } : { part: record.body0.part }
   const to = fastenedTo(asset, part)
@@ -52,7 +52,7 @@ export function heldBy(asset: V3Asset, part: string): { part: string } | { plane
 }
 
 /** Whether a dimension of this part can follow something — box-shaped, whose three sizes are X, Y and Z. */
-export function canFollow(asset: V3Asset, part: string): boolean {
+export function canFollow(asset: FigureAsset, part: string): boolean {
   return followableAxes(asset, part).length > 0
 }
 
@@ -60,7 +60,7 @@ export function canFollow(asset: V3Asset, part: string): boolean {
  * The axes whose size can follow something, by the shape's own measures: a box's X · Y · Z; a cylinder's radius (read
  * as X) and length (Y) -- its shape takes those two, so it has no Z of its own.
  */
-export function followableAxes(asset: V3Asset, part: string): Axis[] {
+export function followableAxes(asset: FigureAsset, part: string): Axis[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
   if (!shape) return []
   /* A door frame's first three measures are its width, height and depth, as a box's (figure-model portal-profile@2). */
@@ -70,12 +70,12 @@ export function followableAxes(asset: V3Asset, part: string): Axis[] {
 }
 
 /** 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: V3Asset, part: string, axis: Axis): number | undefined {
+export function dimensionNow(asset: FigureAsset, part: string, axis: Axis): number | undefined {
   const m = modelOf(asset)
   const ref = m.nodes.find(n => n.id === `${part}.shape`)?.args[AXES.indexOf(axis)]
   if (!ref) return undefined
   try {
-    const values = compileV3Graph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
+    const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
     const value = values[ref]
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined
   } catch {
@@ -87,19 +87,19 @@ export function dimensionNow(asset: V3Asset, part: string, axis: Axis): number |
  * The flat faces a part's shape declares, by name -- figure-model's shape definitions are the one place they are
  * written (a portal's opening sides as well as its outer faces). A sphere has none.
  */
-export function facesOf(asset: V3Asset, part: string): string[] {
+export function facesOf(asset: FigureAsset, part: string): string[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return Object.keys((shape && v3ShapeFaces(shape.op)) ?? {})
+  return Object.keys((shape && figureShapeFaces(shape.op)) ?? {})
 }
 
 /** The axis a face of a part faces along, from the same definitions. */
-export function faceAxisOf(asset: V3Asset, part: string, face: string): Axis | undefined {
+export function faceAxisOf(asset: FigureAsset, part: string, face: string): Axis | undefined {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return (shape && v3ShapeFaces(shape.op)?.[face]?.axis) as Axis | undefined
+  return (shape && figureShapeFaces(shape.op)?.[face]?.axis) as Axis | undefined
 }
 
 /** Whether `attach` can take this part: any part whose shape has a flat face. */
-export function canFasten(asset: V3Asset, part: string): boolean {
+export function canFasten(asset: FigureAsset, part: string): boolean {
   return facesOf(asset, part).length > 0
 }
 
@@ -110,16 +110,16 @@ const OUTER: Record<Axis, [string, string]> = { x: ['left', 'right'], y: ['botto
  * it is fastened fixed to another part and holds nothing. None for a part that is loose, moves, stands on the floor or
  * already repeats -- the command would refuse those, so they are not offered.
  */
-export function rowAxesOf(asset: V3Asset, part: string): Axis[] {
+export function rowAxesOf(asset: FigureAsset, part: string): Axis[] {
   const joints = asset.joints ?? []
   const j = joints.find(o => o.body1.part === part)
   if (!j || j.type !== 'fixed' || j.repeat || !('part' in j.body0)) return []
   if (joints.some(o => 'part' in o.body0 && o.body0.part === part)) return []
-  return AXES.filter(axis => axis !== V3_FACES[j.body1.face])
+  return AXES.filter(axis => axis !== FIGURE_FACES[j.body1.face])
 }
 
 /** The row a part is made into, as its fastening's record keeps it. */
-export const rowOf = (asset: V3Asset, part: string) => asset.joints?.find(o => o.body1.part === part)?.repeat
+export const rowOf = (asset: FigureAsset, part: string) => asset.joints?.find(o => o.body1.part === part)?.repeat
 
 /** Where a part sits across the face it is fastened to, on one axis: centred, level with an edge, or a distance off centre. */
 /** `share`: the distance as a share of the figure's size on that axis, so it keeps its place when the figure is resized. */
@@ -134,11 +134,11 @@ export type Alignment = 'centre' | 'min' | 'max' | 'mm' | 'share'
  * The mounting plane of this figure, by its placement (ADR-0093): the floor or the ceiling is Y = 0 and a part stands
  * on it by its bottom or hangs from it by its top; a wall is Z = 0 and a part is fastened to it by its back.
  */
-export function mountingPlaneOf(asset: V3Asset): { normal: Axis; faces: V3Face[] } {
+export function mountingPlaneOf(asset: FigureAsset): { normal: Axis; faces: FigureFace[] } {
   return asset.occupancy?.placement === 'wall' ? { normal: 'z', faces: ['back'] } : { normal: 'y', faces: ['bottom', 'top'] }
 }
 
-export function alignAxesOf(asset: V3Asset, part: string, target: { part: string; face: string } | 'plane', twisted = false): { axis: Axis; edges: boolean }[] {
+export function alignAxesOf(asset: FigureAsset, part: string, target: { part: string; face: string } | 'plane', twisted = false): { axis: Axis; edges: boolean }[] {
   /* The plane has no edges, but a figure that declares its size has sides on it (figure-model 0.1.64). */
   if (target === 'plane') {
     const { normal } = mountingPlaneOf(asset)
@@ -153,7 +153,7 @@ export function alignAxesOf(asset: V3Asset, part: string, target: { part: string
 }
 
 /** The controls a part's showing can follow: the figure's state inputs, with their range and label. */
-export function visibilityControlsOf(asset: V3Asset): Array<{ id: string; unit: string; min: number; max: number; label: string }> {
+export function visibilityControlsOf(asset: FigureAsset): Array<{ id: string; unit: string; min: number; max: number; label: string }> {
   const labels = (asset as unknown as { stateInputs?: Record<string, { label?: string }> }).stateInputs ?? {}
   return modelOf(asset)
     .inputs.filter(input => input.role === 'state')
@@ -161,7 +161,7 @@ export function visibilityControlsOf(asset: V3Asset): Array<{ id: string; unit:
 }
 
 /** When the part is drawn (figure-model `set-visibility`): always (null), or while a control is at least a value. */
-export function shownWhenOf(asset: V3Asset, part: string): { input: string; atLeast: number } | null {
+export function shownWhenOf(asset: FigureAsset, part: string): { input: string; atLeast: number } | null {
   const look = asset.appearance.find(one => one.target === part) as { visibility?: string } | undefined
   if (!look?.visibility) return null
   const m = modelOf(asset)
@@ -171,11 +171,11 @@ export function shownWhenOf(asset: V3Asset, part: string): { input: string; atLe
 }
 
 /** Whether `part` hangs from `from`, through any number of fastenings. */
-export function hangsFrom(asset: V3Asset, part: string, from: string): boolean {
+export function hangsFrom(asset: FigureAsset, part: string, from: string): boolean {
   const seen = new Set<string>()
   for (let at: string | undefined = part; at && !seen.has(at); ) {
     seen.add(at)
-    const j = ((asset.joints ?? []) as V3Joint[]).find(o => o.body1.part === at)
+    const j = ((asset.joints ?? []) as FigureJoint[]).find(o => o.body1.part === at)
     at = j && 'part' in j.body0 ? (j.body0 as { part: string }).part : undefined
     if (at === from) return true
   }
@@ -189,7 +189,7 @@ export function hangsFrom(asset: V3Asset, part: string, from: string): boolean {
  * from there broke its turning in place (walk 1, 2026-09-26). Null for a part fastened to nothing.
  */
 export function fasteningOf(
-  asset: V3Asset,
+  asset: FigureAsset,
   part: string
 ): {
   face: string
@@ -238,7 +238,7 @@ 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: V3Asset,
+  asset: FigureAsset,
   part: string,
   target: { part: string; face: string } | 'plane',
   twisted = false
@@ -246,7 +246,7 @@ export function placeKeptOf(
   const kept = { align: {} as Partial<Record<Axis, Alignment>>, alignMm: {} as Partial<Record<Axis, number>> }
   let geometry
   try {
-    geometry = compileV3Asset(asset).evaluate().geometry as unknown as Array<{ id: string; pose?: { r: number[][]; t: number[] } }>
+    geometry = compileFigureAsset(asset).evaluate().geometry as unknown as Array<{ id: string; pose?: { r: number[][]; t: number[] } }>
   } catch {
     return kept
   }
@@ -272,7 +272,7 @@ export function placeKeptOf(
 
 /** The `align` of an attach command from the form's choices: only the axes across that face, and centred ones left out. */
 export function alignOf(
-  asset: V3Asset,
+  asset: FigureAsset,
   part: string,
   target: { part: string; face: string } | 'plane',
   how: Partial<Record<Axis, Alignment>>,
@@ -294,7 +294,7 @@ export function alignOf(
 /**
  * The axes on which the part's position is worked out from other values rather than being its own number. `fix-position` makes one its own number where it is now.
  */
-export function positionsWorkedOut(asset: V3Asset, part: string): Axis[] {
+export function positionsWorkedOut(asset: FigureAsset, part: string): Axis[] {
   const m = modelOf(asset)
   const pose = m.nodes.find(n => n.id === `${part}.pose`)
   if (!pose || pose.op !== 'rigid@1' || fastenedTo(asset, part)) return []
@@ -307,7 +307,7 @@ export function positionsWorkedOut(asset: V3Asset, part: string): Axis[] {
  * Whether the part's position on an axis is a share of the instance size (`scale-position`): `size.<axis> × share`.
  * Such a position is worked out too, but it already grows with the figure, so it is not offered again.
  */
-export function positionIsShare(asset: V3Asset, part: string, axis: Axis): boolean {
+export function positionIsShare(asset: FigureAsset, part: string, axis: Axis): boolean {
   const m = modelOf(asset)
   const ref = m.nodes.find(n => n.id === `${part}.pose`)?.args[AXES.indexOf(axis)]
   const writer = ref ? m.nodes.find(n => Object.values(n.outputs).includes(ref)) : undefined
@@ -325,7 +325,7 @@ export interface Motion {
   travel?: { part: string; axis: string; plus?: number }
 }
 
-export function motionOf(asset: V3Asset, part: string): Motion | undefined {
+export function motionOf(asset: FigureAsset, part: string): Motion | undefined {
   const m = modelOf(asset)
   const node = m.nodes.find(n => n.id === `${part}.motion`)
   if (!node) return undefined
@@ -377,7 +377,7 @@ export interface MotionForm {
  * travels by, what it follows -- rather than taken away and made again. Taking it away is refused while another joint
  * follows it, which left a leader's stroke fixed for good (the telescopic conveyor, 2026-09-25).
  */
-export function motionFormOf(joint: V3Joint): MotionForm {
+export function motionFormOf(joint: FigureJoint): MotionForm {
   const kind: MotionForm['kind'] = joint.type === 'prismatic' ? 'slide' : joint.lowerLimit === undefined && joint.upperLimit === undefined && !joint.mimic ? 'continuous' : 'turn'
   const travel = joint.travel?.source && 'part' in joint.travel.source ? `${joint.travel.source.part}:${joint.travel.source.axis}` : ''
   return {
@@ -398,7 +398,7 @@ export function motionFormOf(joint: V3Joint): MotionForm {
  * The joints a part's joint can move with (URDF's mimic): a joint that moves the same way — a slide follows a slide, a
  * turn a turn — and has a control of its own, since a follower follows the joint that is driven.
  */
-export function leadersFor(asset: V3Asset, part: string, kind: MotionForm['kind']): V3Joint[] {
+export function leadersFor(asset: FigureAsset, part: string, kind: MotionForm['kind']): FigureJoint[] {
   return (asset.joints ?? []).filter(j => j.body1.part !== part && j.type !== 'fixed' && !j.mimic && (j.type === 'prismatic') === (kind === 'slide'))
 }
 
@@ -407,7 +407,7 @@ export function leadersFor(asset: V3Asset, part: string, kind: MotionForm['kind'
  * a turn without end, as in USD) and a control; a follower gets the leader, the multiplier and the offset, and no
  * control or limits of its own — its range is the leader's times the multiplier.
  */
-export function motionJoint(joint: V3Joint, m: MotionForm, part: string): V3Joint {
+export function motionJoint(joint: FigureJoint, m: MotionForm, part: string): FigureJoint {
   const moving = {
     id: joint.id,
     body0: joint.body0,
@@ -441,7 +441,7 @@ export function choiceOf(follow: Follow): string {
 }
 
 /** The faces a place can sit on for this part: a box's six, a rounded box's top and bottom, none for a round body. */
-export function placeFacesOf(asset: V3Asset, part: string): V3Face[] {
+export function placeFacesOf(asset: FigureAsset, part: string): FigureFace[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
   if (shape?.op === 'box-shape@1') return ['left', 'right', 'bottom', 'top', 'back', 'front']
   if (shape?.op === 'rounded-box@1') return ['bottom', 'top']
@@ -449,12 +449,12 @@ export function placeFacesOf(asset: V3Asset, part: string): V3Face[] {
 }
 
 /** The places things are held that sit on this part. */
-export function placesOn(asset: V3Asset, part: string): V3BindingPlace[] {
-  return v3BindingsOf(asset).filter(one => one.part === part)
+export function placesOn(asset: FigureAsset, part: string): FigureBindingPlace[] {
+  return figureBindingsOf(asset).filter(one => one.part === part)
 }
 
 /** An id for a new place on this part, not yet taken: `<part>-<role>`, then `-2`, `-3`. */
-export function placeIdFor(asset: V3Asset, part: string, role: 'seat' | 'grip'): string {
+export function placeIdFor(asset: FigureAsset, part: string, role: 'seat' | 'grip'): string {
   const taken = new Set(asset.document.capabilities.bindings.map(b => b.id))
   const base = `${part}-${role}`
   if (!taken.has(base)) return base
@@ -467,7 +467,7 @@ export function placeIdFor(asset: V3Asset, part: string, role: 'seat' | 'grip'):
  * Whether a board will hand this figure anything: a place is a slot only on a figure that declares it holds things
  * (`Capacity`, or `FlowNode`, which includes it). Without it the places are declared and nothing arrives.
  */
-export const holdsThings = (asset: V3Asset) => (asset.document.capabilities.names ?? []).some(n => n === 'Capacity' || n === 'FlowNode')
+export const holdsThings = (asset: FigureAsset) => (asset.document.capabilities.names ?? []).some(n => n === 'Capacity' || n === 'FlowNode')
 
 /** What `accepts` a person typed: names split on commas, trimmed, blanks and repeats dropped. */
 export const acceptsOf = (typed: string) => [...new Set(typed.split(',').map(one => one.trim()).filter(Boolean))]
@@ -478,9 +478,9 @@ export const acceptsOf = (typed: string) => [...new Set(typed.split(',').map(one
  * A range measured when a part filled what the others left (ROBOT_ARM: Y from 1,854 mm) stays narrow after the part is
  * made to grow with the figure; measuring again gives the figure its whole range back. Nothing when no size is declared.
  */
-export function instanceRangeOf(asset: V3Asset): { declared: V3SizeRange; measured: V3SizeRange } | undefined {
+export function instanceRangeOf(asset: FigureAsset): { declared: FigureSizeRange; measured: FigureSizeRange } | undefined {
   const inputs = modelOf(asset).inputs
-  const declared = {} as V3SizeRange
+  const declared = {} as FigureSizeRange
   const authored = {} as Record<Axis, number>
   for (const axis of AXES) {
     const input = inputs.find(i => i.id === `size.${axis}` && i.role === 'design')
@@ -490,7 +490,7 @@ export function instanceRangeOf(asset: V3Asset): { declared: V3SizeRange; measur
     authored[axis] = at
   }
   const start = defaultInstanceSizeRange(authored)
-  const measured = foldInstanceSizeRange(start, v3InstanceSizeLimitsOf(asset, start)).range
+  const measured = foldInstanceSizeRange(start, figureInstanceSizeLimitsOf(asset, start)).range
   return { declared, measured }
 }
 
@@ -500,13 +500,13 @@ export function instanceRangeOf(asset: V3Asset): { declared: V3SizeRange; measur
  * size or has nothing to measure. Without a declared size a board cannot resize the figure, and no part is offered
  * to follow its size -- every figure made in the modeller was left there (user, 2026-09-25).
  */
-export function instanceRangeToDeclare(asset: V3Asset): { range: V3SizeRange; at: Record<Axis, number> } | undefined {
+export function instanceRangeToDeclare(asset: FigureAsset): { range: FigureSizeRange; at: Record<Axis, number> } | undefined {
   if (instanceRangeOf(asset) || !asset.appearance.length) return undefined
   /* The parts as they rest -- not the room their joints swing them through, which declared a door 8208 mm every way. */
-  const at = v3PartsExtentOf(asset) as Record<Axis, number>
+  const at = figurePartsExtentOf(asset) as Record<Axis, number>
   if (AXES.some(axis => !(at[axis] > 0))) return undefined
   const start = defaultInstanceSizeRange(at)
-  return { range: foldInstanceSizeRange(start, v3InstanceSizeLimitsOf(asset, start)).range, at }
+  return { range: foldInstanceSizeRange(start, figureInstanceSizeLimitsOf(asset, start)).range, at }
 }
 
 /** Whether measuring again would change the declared range (to a micrometre). */
@@ -515,7 +515,7 @@ export function instanceRangeToDeclare(asset: V3Asset): { range: V3SizeRange; at
  * product (a gantry spans metres, not 30 cm to 29 m), and measuring only ever widens them. Nothing when the typed
  * value is not a number; whether the figure holds there is the command's to say.
  */
-export function rangeWith(declared: V3SizeRange, axis: Axis, bound: 'min' | 'max', value: number): V3SizeRange | undefined {
+export function rangeWith(declared: FigureSizeRange, axis: Axis, bound: 'min' | 'max', value: number): FigureSizeRange | undefined {
   if (!Number.isFinite(value)) return undefined
   const next = structuredClone(declared)
   next[axis][bound] = value
@@ -526,10 +526,10 @@ export function rangeWith(declared: V3SizeRange, axis: Axis, bound: 'min' | 'max
  * For a figure that grows by one ratio: how many of its lengths would follow the ratio, and which it leaves with their
  * own number (not those that follow another length -- they grow with it). Nothing for a figure of another sizing.
  */
-export function proportionToFollow(asset: V3Asset): { count: number; kept: string[] } | undefined {
+export function proportionToFollow(asset: FigureAsset): { count: number; kept: string[] } | undefined {
   if (asset.sizing !== 'uniform') return undefined
   try {
-    const plan = proposeV3Proportion(asset)
+    const plan = proposeFigureProportion(asset)
     return { count: plan.dimensions.length + plan.lengths.length, kept: plan.skipped.filter(s => !s.follows).map(s => s.what) }
   } catch {
     return undefined
@@ -537,10 +537,10 @@ export function proportionToFollow(asset: V3Asset): { count: number; kept: strin
 }
 
 /** A value of the figure as it stands, by its graph reference. */
-export function valueNow(asset: V3Asset, ref: string | undefined): number | undefined {
+export function valueNow(asset: FigureAsset, ref: string | undefined): number | undefined {
   if (!ref) return undefined
   try {
-    const values = compileV3Graph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
+    const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
     const value = values[ref]
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined
   } catch {
@@ -548,7 +548,7 @@ export function valueNow(asset: V3Asset, ref: string | undefined): number | unde
   }
 }
 
-export function rangeDiffers(a: V3SizeRange, b: V3SizeRange): boolean {
+export function rangeDiffers(a: FigureSizeRange, b: FigureSizeRange): boolean {
   return AXES.some(axis => Math.abs(a[axis].min - b[axis].min) > 1e-3 || Math.abs(a[axis].max - b[axis].max) > 1e-3)
 }
 
@@ -556,7 +556,7 @@ export function rangeDiffers(a: V3SizeRange, b: V3SizeRange): boolean {
  * Whether the figure is a mechanism -- a part turns about a joint. Such a figure should grow by one ratio (chief
  * architect's ruling 2026-09-24); the modeller proposes it, the author declares it.
  */
-export function turnsAboutAJoint(asset: V3Asset): boolean {
+export function turnsAboutAJoint(asset: FigureAsset): boolean {
   return modelOf(asset).nodes.some(n => n.op === 'axis-turn@1')
 }
 

package/client/modeller/{v3-live.ts → live.ts}

@@ -1,7 +1,7 @@
-import { compileV3Asset, editV3Part } from '@hatiolab/figure-model'
-import type { V3Asset, V3PartEdit } from '@hatiolab/figure-model'
+import { compileFigureAsset, editFigurePart } from '@hatiolab/figure-model'
+import type { FigureAsset, FigurePartEdit } from '@hatiolab/figure-model'
 
-import { drawableV3Parts, type V3RenderPart } from './v3-renderer.js'
+import { drawableFigureParts, type FigureRenderPart } from './renderer.js'
 
 /*
  * The figure while a value is in hand: evaluated with the values being typed or dragged, drawn at once and written
@@ -18,13 +18,13 @@ export interface LiveValues {
   /** Input values in hand, design or state, by input id. */
   values: Record<string, number>
   /** A part edit in hand, not yet committed. */
-  edit?: V3PartEdit
+  edit?: FigurePartEdit
 }
 
 export const NOTHING_LIVE: LiveValues = { values: {} }
 
 /** Known inputs with a number, split by what they are. An id the figure does not declare is dropped. */
-export function liveOverridesOf(asset: V3Asset, values: Record<string, number>): { design: Record<string, number>; state: Record<string, number> } {
+export function liveOverridesOf(asset: FigureAsset, values: Record<string, number>): { design: Record<string, number>; state: Record<string, number> } {
   const roles = new Map(asset.document.model.inputs.map(i => [i.id, i.role]))
   const design: Record<string, number> = {},
     state: Record<string, number> = {}
@@ -48,13 +48,13 @@ export function isLive(live: LiveValues): boolean {
  * refuses): the canvas keeps the figure as it stands until the release, and the release reports why through the same
  * refusal every committed edit gets. A preview never invents a figure the commit would not make.
  */
-export function livePartsOf(asset: V3Asset, live: LiveValues): V3RenderPart[] | null {
+export function livePartsOf(asset: FigureAsset, live: LiveValues): FigureRenderPart[] | null {
   if (!isLive(live)) return null
   const { design, state } = liveOverridesOf(asset, live.values)
   try {
-    let next = live.edit ? editV3Part(asset, live.edit) : asset
+    let next = live.edit ? editFigurePart(asset, live.edit) : asset
     if (Object.keys(design).length) next = { ...next, designInputs: { ...next.designInputs, ...design } }
-    return drawableV3Parts(compileV3Asset(next).evaluate(state).geometry)
+    return drawableFigureParts(compileFigureAsset(next).evaluate(state).geometry)
   } catch {
     return null
   }
@@ -83,7 +83,7 @@ export function scrubbed(start: number, pixels: number, step: number): number {
  * 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: V3Asset, current: Record<string, number>, live: LiveValues): V3RenderPart[] | null {
+export function liveOverSession(asset: FigureAsset, current: Record<string, number>, live: LiveValues): FigureRenderPart[] | null {
   if (!isLive(live)) return null
   return livePartsOf(asset, { ...live, values: { ...current, ...live.values } })
 }