@things-factory/figure-ui 10.1.204 → 10.1.206

package/client/modeller/links.ts

@@ -1,6 +1,6 @@
-import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion } from '@hatiolab/figure-model'
-import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureFacing, FigureJoint } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeRangeOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion, figureSurfaceOf } from '@hatiolab/figure-model'
+import type { FigureFollow, FigureInstanceSizeRange } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureFacing, FigureJoint, FigureSurfacePlace } from '@hatiolab/figure-model'
 import { startingShapeKindOf } from './starting-shape.js'
 import { boxOf } from './align.js'
 import { graphValuesOf, type FigureRevision } from './revision.js'
@@ -35,6 +35,23 @@ export function followOf(asset: FigureAsset, part: string, axis: Axis): Follow {
   return figureFollowOf(asset, part, axis)
 }
 
+/**
+ * The parts whose size follows the figure's size on some axis, in the model's order: the ones that change when the
+ * figure is resized on a drawing. Read by figure-model's own follow (`figureFollowOf`), not worked out again here.
+ */
+export function sizeFollowersOf(asset: FigureAsset): string[] {
+  const parts = (modelOf(asset).nodes as Array<{ id: string; op: string }>).filter(n => n.op === 'place@1').map(n => n.id)
+  return parts.filter(part =>
+    AXES.some(axis => {
+      try {
+        return figureFollowOf(asset, part, axis).of === 'instance'
+      } catch {
+        return false
+      }
+    })
+  )
+}
+
 /** Whether the asset declares an instance size on an axis — only then can a dimension follow it. */
 export const hasInstanceSize = (asset: FigureAsset, axis: Axis) => modelOf(asset).inputs.some(i => i.id === `size.${axis}` && i.role === 'design')
 
@@ -224,7 +241,14 @@ export function measureNow(revision: FigureRevision, part: string, axis: Axis):
  */
 export function facesOf(asset: FigureAsset, part: string): string[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return inScreenOrder(Object.keys((shape && figureShapeFaces(shape as never)) ?? {}))
+  const faces = (shape && figureShapeFaces(shape as never)) ?? {}
+  /* A cylinder's curved side is no face: a part is fastened to a point on it (ADR-0140 3.9, `surfaceOf`). */
+  return inScreenOrder(Object.keys(faces).filter(f => faces[f]!.contact !== 'line'))
+}
+
+/** The curved surface a part offers to be fastened to at a point: a cylinder's side or a sphere's round (ADR-0140 3.9). */
+export function surfaceOf(asset: FigureAsset, part: string): { form: 'around' | 'toward'; axis: Axis } | undefined {
+  return figureSurfaceOf(asset, part)
 }
 
 /** Faces in the order the screen lists them: the six outer ones left to front, then the rest as the shape gives them. */
@@ -242,7 +266,7 @@ export function faceAxisOf(asset: FigureAsset, part: string, face: string): Axis
 
 /** Whether `attach` can take this part: any part whose shape has a flat face. */
 export function canFasten(asset: FigureAsset, part: string): boolean {
-  return facesOf(asset, part).length > 0
+  return facesOf(asset, part).length > 0 || !!surfaceOf(asset, part)
 }
 
 const OUTER: Record<Axis, [string, string]> = { x: ['left', 'right'], y: ['bottom', 'top'], z: ['back', 'front'] }
@@ -267,13 +291,15 @@ export function rowAxesOf(asset: FigureAsset, part: string): Axis[] {
  * Why a part cannot be made into a row here, in the terms `rowAxesOf` refuses it: said, not hidden (ADR-0097 §5.5).
  * Nothing when it can, or when it already is a row (that row is shown where it stands).
  */
-export function rowBlockOf(asset: FigureAsset, part: string): 'unfastened' | 'on-plane' | 'holds-parts' | 'at-origin' | undefined {
+export function rowBlockOf(asset: FigureAsset, part: string): 'unfastened' | 'on-plane' | 'holds-parts' | 'at-origin' | 'on-surface' | undefined {
   const joints = asset.joints ?? []
   const j = joints.find(o => o.body1.part === part)
   if (!j) return 'unfastened'
   if (j.repeat) return undefined
   if (!('part' in j.body0)) return 'on-plane'
   if (joints.some(o => 'part' in o.body0 && o.body0.part === part)) return 'holds-parts'
+  /* On a point of a curved surface a row has no face to run across (ADR-0140 3.9): the kernel refuses it. */
+  if ('surface' in j.body0) return 'on-surface'
   if (!('face' in j.body0) || 'at' in j.body1) return 'at-origin'
   return undefined
 }
@@ -372,13 +398,29 @@ export function fasteningOf(
   alignMm: Partial<Record<Axis, number>>
   /** Placed by a part's origin (ADR-0107 decision 4): no face to fasten by, and the form does not write it. */
   atOrigin?: true
+  /** On a point of the target's curved surface (ADR-0140 3.9), as the record says it. */
+  surface?: FigureSurfacePlace
 } | null {
   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 : ''
+  const surface = 'surface' in record.body0 ? record.body0.surface : undefined
   const targetFace = 'face' in record.body0 ? record.body0.face : 'top'
-  const atOrigin = !('plane' in record.body0) && (!('face' in record.body0) || 'at' in record.body1)
+  const atOrigin = !('plane' in record.body0) && ((!('face' in record.body0) && !surface) || 'at' in record.body1)
+  if (surface)
+    return {
+      toPlane,
+      target,
+      targetFace,
+      facing: record.origin?.facing ?? 'meet',
+      gap: typeof record.origin?.gap === 'number' ? record.origin.gap : 0,
+      ...(record.origin?.gap !== undefined && typeof record.origin.gap !== 'number' ? { gapKept: record.origin.gap } : {}),
+      align: {},
+      alignMm: {},
+      surface,
+      ...(atOrigin ? { atOrigin: true as const } : {})
+    }
   /* Where across the face: as the record says it, and where it says nothing, where the part stands now. */
   const kept = placeKeptOf(revision, part, toPlane ? 'plane' : { part: target, face: targetFace })
   for (const [axis, how] of Object.entries(record.origin?.align ?? {}) as Array<[Axis, unknown]>) {
@@ -691,53 +733,48 @@ export const holdsThings = (asset: FigureAsset) => (asset.document.capabilities.
 export const acceptsOf = (typed: string) => [...new Set(typed.split(',').map(one => one.trim()).filter(Boolean))]
 
 /**
- * The sizes a board may give this figure: the range it declares now, and the range measured afresh -- the default
- * (1 mm to ten times the authored size) narrowed only where the figure cannot follow, by figure-model's own functions.
- * 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: FigureAsset): { declared: FigureSizeRange; measured: FigureSizeRange } | undefined {
-  const inputs = modelOf(asset).inputs
-  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')
-    const at = asset.designInputs[`size.${axis}`]
-    if (!input || typeof at !== 'number') return undefined
-    declared[axis] = { min: input.min ?? 0, max: input.max ?? Infinity }
-    authored[axis] = at
-  }
-  const start = defaultInstanceSizeRange(authored)
-  const measured = foldInstanceSizeRange(start, figureInstanceSizeLimitsOf(asset, start)).range
-  return { declared, measured }
+ * The sizes a board may give this figure, per axis: the ends its author narrowed, and the rest as far as its parts
+ * allow, computed by figure-model (`figureInstanceSizeRangeOf`, ADR-0087 decision 6) -- the screen does not measure
+ * on its own. Nothing when no size is declared.
+ */
+export function instanceRangeOf(asset: FigureAsset): Record<Axis, FigureInstanceSizeRange> | undefined {
+  const range = figureInstanceSizeRangeOf(asset)
+  return AXES.every(axis => range[axis]) ? (range as Record<Axis, FigureInstanceSizeRange>) : undefined
 }
 
 /**
- * The size range to declare for a figure that has none yet: its parts' extent now as the size it is authored at, and
- * as wide as its parts allow around it (the same measure 「다시 재기」 uses). Undefined when the figure already has a
- * 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).
+ * The size to declare for a figure that has none yet: its parts' extent now, the size it is authored at. Undefined when
+ * the figure already has a 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: FigureAsset): { range: FigureSizeRange; at: Record<Axis, number> } | undefined {
+export function instanceSizeToDeclare(asset: FigureAsset): { 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 = figurePartsExtentOf(asset) as Record<Axis, number>
   if (AXES.some(axis => !(at[axis] > 0))) return undefined
-  const start = defaultInstanceSizeRange(at)
-  return { range: foldInstanceSizeRange(start, figureInstanceSizeLimitsOf(asset, start)).range, at }
+  return { at }
 }
 
-/** Whether measuring again would change the declared range (to a micrometre). */
 /**
- * The declared range with one end typed by the author: the sizes a figure may be placed at are a claim about the
- * 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.
+ * The ends the author narrowed, with one end typed or cleared: a number narrows that end, an empty field opens it
+ * again to what the parts allow. Whether the figure holds there is the command's to say.
  */
-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
-  return next
+export function rangeWith(
+  range: Record<Axis, FigureInstanceSizeRange>,
+  axis: Axis,
+  bound: 'min' | 'max',
+  value: number
+): Partial<Record<Axis, { min?: number; max?: number }>> {
+  const out: Partial<Record<Axis, { min?: number; max?: number }>> = {}
+  for (const a of AXES) {
+    const ends: { min?: number; max?: number } = {}
+    for (const b of ['min', 'max'] as const) {
+      const typed = a === axis && b === bound
+      if (typed ? Number.isFinite(value) : range[a].narrowed[b]) ends[b] = typed ? value : range[a][b]
+    }
+    if (Object.keys(ends).length) out[a] = ends
+  }
+  return out
 }
 
 /**
@@ -765,10 +802,6 @@ export function valueNow(revision: FigureRevision, ref: string | undefined): num
   }
 }
 
-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)
-}
-
 /**
  * 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.

package/client/modeller/palette.ts

@@ -16,7 +16,7 @@ export function paletteRecipe(kind: FigurePaletteKind, id: string): FigurePrimit
     case 'rounded-box':
       return { ...standing(100), kind, dimensions: { width: 100, height: 100, depth: 100, round: 10 } }
     case 'sphere':
-      return { ...standing(100), kind, dimensions: { radiusX: 50, radiusY: 50, radiusZ: 50 } }
+      return { ...standing(100), kind, dimensions: { radius: 50, radiusY: 50 } }
     case 'frustum':
       return { ...standing(100), kind, dimensions: { radiusTop: 0, radiusBottom: 50, height: 100 } }
     case 'polygon':

package/client/modeller/product-session.ts

@@ -5,6 +5,8 @@ import {
   createFigureEditorWorkspace,
   serializeFigureAsset,
   parseFigureAsset,
+  figureSizeRangeFitsOf,
+  type FigureSizeRangeFit,
   type FigureInputChange,
   type FigurePrimitiveCreation,
   type FigurePartEdit,
@@ -71,10 +73,14 @@ export function createFigureProductSession(store: FigureProductStore) {
   */
   let done: Array<string | undefined> = [],
     undone: Array<string | undefined> = []
-  function tracked<T>(kind: 'do' | 'undo' | 'redo', run: () => T, tag?: string): T {
-    const before = workspace.read().revision
+  /* The author's size ends the last step moved without being asked (ADR-0087 decision 6), told once. */
+  let fitted: FigureSizeRangeFit[] = []
+  function tracked<T>(kind: 'do' | 'undo' | 'redo', run: () => T, tag?: string, setsRange = false): T {
+    const was = workspace.read()
     const result = run()
-    if (workspace.read().revision === before) return result
+    const now = workspace.read()
+    if (now.revision === was.revision) return result
+    fitted = kind === 'do' && !setsRange && was.asset && now.asset ? figureSizeRangeFitsOf(was.asset, now.asset) : []
     if (kind === 'do') {
       done.push(tag)
       undone = []
@@ -250,7 +256,13 @@ export function createFigureProductSession(store: FigureProductStore) {
     },
     /** One authoring command — what a person means, not a graph edit — as one step of the same history. */
     command(action: FigureAuthoringAction) {
-      return tracked('do', () => workspace.command({ ...writable(), action, ...consented() }))
+      return tracked('do', () => workspace.command({ ...writable(), action, ...consented() }), undefined, action.kind === 'declare-instance-size')
+    },
+    /** The ends of the size on a drawing the last step moved in to what the parts allow, once: then nothing until the next. */
+    takeSizeRangeFits(): FigureSizeRangeFit[] {
+      const out = fitted
+      fitted = []
+      return out
     },
     /**
      * The first edit made inside `run` may let go of exactly these clips -- the ones a CLIPS_DROPPED refusal named and

package/client/modeller/refusal-teller.ts

@@ -2,29 +2,23 @@ import type { PropertyValues } from 'lit'
 import { i18next } from '@operato/i18n'
 import { notify } from '@operato/layout'
 import { OxPrompt } from '@operato/popup'
-import type { FigureAuthoringAction, FigureClipLoss } from '@hatiolab/figure-model'
+import type { FigureClipLoss } from '@hatiolab/figure-model'
 import type { FigureProductSession } from './product-session.js'
 import { clipLossOf } from './refusals.js'
 
-/** The same link offered again with the size range narrowed, after a link the declared range could not hold. */
-export type Retry = { label: string; action?: FigureAuthoringAction; run?: () => void }
-
 /** What the teller reads of the editor, and what it asks of it. */
 export interface RefusalHost {
   session(): FigureProductSession | undefined
   error(): string
   notice(): string
-  retry(): Retry | undefined
   /** Said as the editor's refusal. */
   refuse(message: string): void
-  /** A narrowed link, confirmed: run as the editor runs a command. */
-  command(action: FigureAuthoringAction): void
 }
 
 /**
  * Refusals and notices go to the app's shared surfaces, as every screen's do (user, 2026-09-27: 「왜 모두가 사용하는
  * notification 오류 표현 방법을 사용하지 않고」 · 「혹은 oxprompt 에서 확인하고 진행하던지」). A refusal with a way on --
- * delete and fit the space again, narrow the range -- asks in the app's prompt and goes on when confirmed; any
+ * delete and fit the space again, let a clip go -- asks in the app's prompt and goes on when confirmed; any
  * other refusal is the app's notification, which stays until it is closed.
  */
 export class RefusalTeller {
@@ -35,11 +29,7 @@ export class RefusalTeller {
   /** After the editor's update: what changed in its refusal and notice, and the session's own error, said once. */
   tell(changed: PropertyValues) {
     const error = this.of.error()
-    if (changed.has('error') && error) {
-      const retry = this.of.retry()
-      if (retry) this.ask(error, retry)
-      else notify({ level: 'error', message: error })
-    }
+    if (changed.has('error') && error) notify({ level: 'error', message: error })
     const notice = this.of.notice()
     if (changed.has('notice') && notice) notify({ level: 'info', message: notice })
     const viewError = this.of.session()?.read()?.error ?? ''
@@ -91,16 +81,4 @@ export class RefusalTeller {
     }
     asked.session.withConsent({ dropClips: clips.map(c => c.id), context: asked.context, revision: asked.revision }, again)
   }
-
-  private async ask(message: string, retry: Retry) {
-    const agreed = await OxPrompt.open({
-      type: 'question',
-      text: message,
-      confirmButton: { text: retry.label },
-      cancelButton: { text: i18next.t('figure.button.keep-editing') }
-    })
-    if (!agreed) return
-    if (retry.run) retry.run()
-    else this.of.command(retry.action!)
-  }
 }

package/client/modeller/refusals.ts

@@ -7,7 +7,7 @@
  * English is for logs and readers of the kernel, and a screen that read it went quiet whenever a sentence changed or a
  * new one came under the same code (ADR-0054). A refusal with no details the screen knows is said with its code.
  */
-import { FIGURE_INSTANCE_SIZE_INPUTS, type FigureClipLoss, type FigureRefusalDetails } from '@hatiolab/figure-model'
+import { FIGURE_INSTANCE_SIZE_INPUTS, type FigureClipLoss, type FigureRefusalDetails, type FigureSizeRangeFit } from '@hatiolab/figure-model'
 
 type Say = (key: string, params: Record<string, string>) => string
 type Reason = FigureRefusalDetails['reason']
@@ -23,36 +23,29 @@ const numberOf = (value: number) => value.toLocaleString(undefined, { maximumFra
 /** Bytes in KiB, rounded up: a figure a few bytes over its limit is not said to be at it. */
 const kibOf = (bytes: number) => Math.ceil(bytes / 1024).toLocaleString()
 
-/** A size range the figure cannot be drawn over, or one that leaves out its own size, in words; nothing for any other refusal. */
+/**
+ * The ends an author typed for the size on a drawing, refused: they leave out the size the figure is drawn at, or start
+ * at zero. The only refusals the size range has left (ADR-0087 decision 6); nothing for any other refusal.
+ */
 export function sizeRangeRefusalOf(error: unknown, say: Say): string | null {
   if (codeOf(error) !== 'INSTANCE_SIZE_RANGE') return null
-  const reach = detailsOf(error, 'size-cannot-reach')
-  if (reach)
-    return say(reach.bound === 'min' ? 'figure.text.size-range-too-small' : 'figure.text.size-range-too-large', { axis: reach.axis.toUpperCase(), mm: mmOf(reach.need), part: reach.part ?? '' })
   const outside = detailsOf(error, 'size-outside-range')
-  if (outside) return say('figure.text.size-range-leaves-out-size', { axis: outside.axis.toUpperCase(), at: mmOf(outside.at), min: mmOf(outside.min), max: mmOf(outside.max) })
+  if (outside)
+    return say('figure.text.size-range-leaves-out-size', {
+      axis: say(`figure.label.resize-${outside.axis}`, {}),
+      range: `${mmOf(outside.min ?? 0)} – ${outside.max === undefined ? '∞' : mmOf(outside.max)}`,
+      at: mmOf(outside.at)
+    })
   const zero = detailsOf(error, 'size-min-not-positive')
-  if (zero) return say('figure.text.size-range-from-zero', { axis: zero.axis.toUpperCase() })
-  const gone = detailsOf(error, 'size-already-gone')
-  if (gone) return say('figure.text.size-range-part-gone', { axis: gone.axis.toUpperCase(), at: mmOf(gone.at) })
+  if (zero) return say('figure.text.size-range-from-zero', { axis: say(`figure.label.resize-${zero.axis}`, {}) })
   return null
 }
 
-/**
- * A link refused because the size range it would leave cannot hold: measuring again cannot help (the link is not there
- * to measure), so the author is offered the same link that narrows the range to what the figure then allows.
- */
-export function narrowingRetryOf<A extends { kind: string }>(action: A, error: unknown, say: Say): { message: string; label: string; retry: A & { narrowRange: true } } | null {
-  if (action.kind !== 'link-dimension' || codeOf(error) !== 'INSTANCE_SIZE_RANGE') return null
-  const reach = detailsOf(error, 'size-cannot-reach')
-  if (!reach) return null
-  const words = { axis: reach.axis.toUpperCase(), mm: mmOf(reach.need), part: reach.part ?? '' }
-  const below = reach.bound === 'min'
-  return {
-    message: say(below ? 'figure.text.link-needs-smaller-range' : 'figure.text.link-needs-larger-range', words),
-    label: say(below ? 'figure.button.narrow-range-from' : 'figure.button.narrow-range-to', words),
-    retry: { ...action, narrowRange: true }
-  }
+/** What a command did to the ends the author typed, in one line each: what moved, from what to what. */
+export function sizeRangeFitsOf(fits: readonly FigureSizeRangeFit[], say: Say): string {
+  return fits
+    .map(f => say(`figure.text.size-range-moved-${f.bound}`, { axis: say(`figure.label.resize-${f.axis}`, {}), from: mmOf(f.from), to: mmOf(f.to) }))
+    .join(' ')
 }
 
 /**
@@ -297,7 +290,7 @@ export function dataMotionRefusalOf(error: unknown, say: Say): string | null {
   const setting = detailsOf(error, 'motion-setting')
   if (setting) return say('figure.text.motion-setting-' + setting.why, { group: setting.group, clip: setting.clip ?? '' })
   const key = codeOf(error) === 'MOTION_GROUP' ? detailsOf(error, 'value-outside-range') : undefined
-  if (key) return say('figure.text.motion-key-outside-range', { input: key.input, value: numberOf(key.value), min: numberOf(key.min), max: numberOf(key.max) })
+  if (key) return say('figure.text.motion-key-outside-range', { input: key.input, value: numberOf(key.value), min: numberOf(key.min!), max: numberOf(key.max!) })
   return null
 }
 
@@ -310,7 +303,7 @@ export function inputRangeRefusalOf(error: unknown, say: Say): string | null {
   const range = detailsOf(error, 'value-outside-range')
   if (!range) return null
   const axis = (Object.entries(FIGURE_INSTANCE_SIZE_INPUTS) as Array<[string, string]>).find(([, id]) => id === range.input)?.[0]
-  const params = { value: numberOf(range.value), min: numberOf(range.min), max: numberOf(range.max) }
+  const params = { value: numberOf(range.value), min: range.min === undefined ? '−∞' : numberOf(range.min), max: range.max === undefined ? '∞' : numberOf(range.max) }
   return axis ? say('figure.text.input-range-size', { ...params, axis: axis.toUpperCase() }) : say('figure.text.input-range', params)
 }
 

package/client/modeller/section-drawing.ts

@@ -1,6 +1,5 @@
 import { FIGURE_SECTION_PLANE, FIGURE_SECTION_POINT_LIMIT, checkFigureSection, figureExtrusionFeaturesOf, figureSectionSidesOf } from '@hatiolab/figure-model'
 import type { FigureAuthoringAction, FigureCavityRequest, FigureEvaluatedShape, FigureSection, FigureSectionIssue, FigureSectionMeasure, FigureSectionPoint } from '@hatiolab/figure-model'
-import { END_FACE } from './section-controls.js'
 
 /*
  * What the section editor does to a drawn section's points, and how it says what is wrong with them (ADR-0100 §3.2).
@@ -218,14 +217,15 @@ export function sectionActionOf(part: string, kind: FigureSection['kind'] | unde
 }
 
 /**
- * What a measure's field says under it: that it follows another value, or -- given where along the push a length
- * change keeps the part (1 its start, -1 its end, 0 its centre) -- the face it keeps; null when there is nothing to say.
+ * What a measure's field says under it: that it follows another value, or what a measure typed keeps -- the part's
+ * middle, or its fastening (ADR-0140 4.1, figure-model's `figureSizeEditOf`); null when there is nothing to say.
  */
-export function measureNoteOf(measure: FigureSectionMeasure | undefined, kept: -1 | 0 | 1 | undefined, axis: Axis): { key: string; face?: string } | null {
+export function measureNoteOf(measure: FigureSectionMeasure | undefined, kept: 'centre' | 'relation' | 'none' | undefined): { key: string } | null {
   if (measure === 'linked') return { key: 'figure.text.section-editor-linked' }
-  if (kept === undefined) return null
-  if (kept === 0) return { key: 'figure.text.section-editor-keeps-centre' }
-  return { key: 'figure.text.section-editor-keeps', face: END_FACE(axis, kept === 1 ? 'start' : 'end') }
+  if (kept === 'centre') return { key: 'figure.text.size-keeps-centre' }
+  if (kept === 'relation') return { key: 'figure.text.size-keeps-fastening' }
+  if (kept === 'none') return { key: 'figure.text.size-keeps-none' }
+  return null
 }
 
 /** The words beside a drawn section's edit button: how many points it has, and the apex when its end is one point. */

package/client/modeller/size-drag.ts

@@ -0,0 +1,112 @@
+import { compileFigureDocument, figurePlacementOf, figureShapeReachOf, figureSizeEditOf, figureSizeEditorOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureSizeKeep } from '@hatiolab/figure-model'
+
+import { ownerOf } from './fields.js'
+import type { FigureRenderPart } from './renderer.js'
+
+/*
+ * A size drag drawn from figure-model, frame by frame (ADR-0140 4.4). The gizmo says only which handle and how far; the
+ * one size function (`figureSizeEditorOf`) turns the sizes into the changes a commit writes, and the instance evaluator
+ * the figure is compiled into once, when the drag begins, steps to them (`advance`). What is drawn while dragging is
+ * what the release writes: the same function, the same sizes, the same keep. Nothing drawn goes back into what the
+ * gizmo computes (2026-09-24: the gizmo fought the modeller when evaluations were written back onto it).
+ */
+
+export interface SizeDragFrame {
+  /** What a release now would write: the sizes and, for a free part, its own position. */
+  changes: FigureInputChange[]
+  /**
+   * Every body moved or reshaped since the drag began, by id: its pose and shape at this frame as figure-model evaluates
+   * them. The evaluator tells only what changed since the frame before; a body that moved and then stood still is kept.
+   */
+  moved: Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>
+}
+
+export interface SizeDrag {
+  part: string
+  keep: FigureSizeKeep
+  frame(sizes: readonly FigureInputChange[]): SizeDragFrame
+}
+
+type Pose = FigureRenderPart['pose']
+
+/** The drag of `part`'s size from `inputs` (the figure's inputs as it is drawn), keeping what `keep` says. */
+export function startSizeDrag(asset: FigureAsset, part: string, inputs: Record<string, number>, keep: FigureSizeKeep): SizeDrag {
+  const edit = figureSizeEditorOf(asset, part)
+  const evaluator = compileFigureDocument(asset.document).evaluator({ changes: true })
+  const base = { ...asset.designInputs, ...asset.stateDefaults, ...inputs }
+  /* The bodies as the evaluator numbers its slots: the order of this first evaluation. */
+  let ids = evaluator.evaluate(base).geometry.map(g => (g as { id: string }).id)
+  const moved = new Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>()
+  return {
+    part,
+    keep,
+    frame(sizes) {
+      const { changes } = edit(sizes, keep)
+      const next = { ...base }
+      for (const c of changes) next[c.input] = c.value as number
+      const step = evaluator.advance(next)
+      if (step.kind === 'changes' && step.structure) ids = step.structure.ids
+      for (let k = 0; k < step.bodies.length; k++) {
+        const id = ids[step.bodies[k]!]
+        const p = step.poses.subarray(k * 12, k * 12 + 12)
+        if (id === undefined || Number.isNaN(p[0]!)) continue
+        const pose: Pose = { r: [[p[0]!, p[1]!, p[2]!], [p[3]!, p[4]!, p[5]!], [p[6]!, p[7]!, p[8]!]], t: [p[9]!, p[10]!, p[11]!] }
+        /* The evaluator's shapes are frozen; the scene's builder writes into what it is given, so the canvas gets its own copy. */
+        const frozen = step.kind === 'changes' ? step.shapes[k] : undefined
+        const shape = frozen ? structuredClone(frozen) : undefined
+        const had = moved.get(id)
+        moved.set(id, { pose, ...(shape ? { shape: shape as unknown as FigureRenderPart['shape'] } : had?.shape ? { shape: had.shape } : {}) } as Pick<FigureRenderPart, 'pose' | 'shape'>)
+      }
+      return { changes, moved: new Map(moved) }
+    }
+  }
+}
+
+/**
+ * What a size typed for this part keeps, in figure-model's words: its middle (`centre`), its fastening (`relation`), or
+ * no point -- its position is worked out, and only the size changes (`none`). The words beside the size fields (ADR-0140
+ * 4.1, chief architect 10-20); nothing when the part cannot be asked.
+ */
+export function keptBySizeOf(asset: FigureAsset, part: string): 'centre' | 'relation' | 'none' | undefined {
+  try {
+    const kept = figureSizeEditOf(asset, part, [], { keep: 'centre' }).kept
+    return kept === 'opposite' ? undefined : kept
+  } catch {
+    return undefined
+  }
+}
+
+/** The words for what a size keeps, by `keptBySizeOf`'s answer. */
+export const SIZE_KEEPS_WORDS = { centre: 'figure.text.size-keeps-centre', relation: 'figure.text.size-keeps-fastening', none: 'figure.text.size-keeps-none' } as const
+
+/** The parts drawn this frame: each one the frame moved, with its new pose and shape; every other one as it was. */
+export function partsAtFrame(parts: readonly FigureRenderPart[], moved: SizeDragFrame['moved']): FigureRenderPart[] {
+  if (!moved.size) return parts as FigureRenderPart[]
+  return parts.map(part => {
+    const now = moved.get(part.id)
+    return now ? { ...part, pose: now.pose, ...(now.shape ? { shape: now.shape } : {}) } : part
+  })
+}
+
+/** The side of its mounting plane a figure uses (ADR-0097 4.2): up from a floor, down from a ceiling, out of a wall. */
+const USED: Record<string, [number, number, number] | undefined> = { floor: [0, 1, 0], ceiling: [0, -1, 0], wall: [0, 0, 1], center: undefined }
+
+/**
+ * How far a free part goes past its figure's mounting plane, in millimetres, as drawn: its real shape's extreme against
+ * the side the placement uses (figure-model's reach, the rule a fastening stands a part by). 0 when it does not, for a
+ * fastened part -- its fastening places it -- and for a figure placed by its centre (ADR-0140 5).
+ */
+export function throughPlaneOf(asset: FigureAsset, parts: readonly FigureRenderPart[], part: string): number {
+  const n = USED[figurePlacementOf(asset)]
+  if (!n || (asset.joints ?? []).some(j => j.body1.part === part)) return 0
+  let lowest = Infinity
+  for (const body of parts) {
+    if (ownerOf(body.id) !== part) continue
+    const { r, t } = body.pose
+    /* The side's direction in the body's own frame: rᵀ n. */
+    const d = [0, 1, 2].map(j => r[0]![j]! * n[0] + r[1]![j]! * n[1] + r[2]![j]! * n[2]) as [number, number, number]
+    lowest = Math.min(lowest, t[0]! * n[0] + t[1]! * n[1] + t[2]! * n[2] + figureShapeReachOf(body.shape as never, d).min)
+  }
+  return Number.isFinite(lowest) && lowest < 0 ? Math.round(-lowest * 10) / 10 : 0
+}

package/client/modeller/slot-layout-host.ts

@@ -66,14 +66,14 @@ export function anchorFacesOf(anchors: readonly SlotAnchor[], geometry: readonly
  * a one-anchor preset on the first, a twin fork on the first two. A single slot stands on a top and hangs from a bottom.
  * The editor's own controls then make it what the equipment is.
  */
-export function slotPresetsOf(anchors: readonly SlotAnchor[], say: (key: string) => string) {
+export function slotPresetsOf(anchors: readonly SlotAnchor[]) {
   const first = anchors[0]
   const on = { ...(first ? { anchor: first.id } : {}), ...(anchors.length >= 2 ? { forks: [anchors[0]!.id, anchors[1]!.id] as [string, string] } : {}) }
   const mount = first?.face === 'bottom' ? ('HANG' as const) : ('ON' as const)
   return SLOT_LAYOUT_PRESET_KEYS.map(key => ({
     key,
-    label: say(`figure.label.slot-preset-${key}`),
-    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, label: say(`figure.label.slot-preset-param-${p.key}`), integer: p.integer })),
+    /* The editor names a preset and its values from their keys (@operato/slot-layout-editor's own words). */
+    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, integer: p.integer })),
     build: (size: SlotPresetSize, params: Record<string, number>) => slotLayoutPreset(key, size, params, { ...on, mount })
   }))
 }

package/client/modeller/stage-model.ts

@@ -64,16 +64,13 @@ function colours(part: FigureRenderPart, palette: Record<string, string>) {
   return { color: palette[m.token] ?? '#9a9a9a', preset: m.preset, transparent: !!m.transparent, ...(glow ? { glow } : {}) }
 }
 
-/** Per axis of the body's own frame, the face a size drag keeps: 1 the low face, -1 the high face, 0 the centre. */
-export type ScaleAnchor = Record<'x' | 'y' | 'z', -1 | 0 | 1>
-
 /**
- * The component state that draws a body where figure-model put it. With `anchor` -- figure-model's
- * `figureScaleAnchorOf` for its part -- the scene's scale gizmo keeps that face while it is dragged, the face the model
- * keeps when the drag is written; without it the gizmo keeps the face across from the handle held, and the part jumped
- * on release (designer 2026-09-27). Body x · y · z are the component's width · depth · height, as the scene's axes are.
+ * The component state that draws a body where figure-model put it. A part the author edits is `owned`: while its size
+ * is dragged the scene does not move it and tells the handle held (`scaleGrab`), and the modeller draws where
+ * figure-model's size function puts it, every frame (ADR-0140 4.4). Body x · y · z are the component's width · depth ·
+ * height, as the scene's axes are.
  */
-export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, anchor?: ScaleAnchor): Record<string, unknown> | null {
+export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, owned = false): Record<string, unknown> | null {
   const frame = frameOf(part)
   if (!frame) return null
   const { centre, extent, rotation, origin } = frame
@@ -97,7 +94,7 @@ export function componentOf(part: FigureRenderPart, palette: Record<string, stri
     rotationX: round(euler.x),
     rotation: round(-euler.y),
     rotationY: round(euler.z),
-    ...(anchor ? { scaleAnchor: { ...anchor } } : {})
+    ...(owned ? { scalePlacement: 'owner' } : {})
   }
 }
 

package/client/pages/figure-modeller-page.ts

@@ -147,8 +147,6 @@ export class FigureModellerPage extends PageView {
   @state() private commandError = ''
   /** What the verdict says blocks release now, handed to the editor's bar. */
   @state() private releaseBlockers: FigureGateFinding[] = []
-  /** The verdict's count, handed to the editor's verdict tab. */
-  @state() private instances?: number
   @state() private budget?: FigureBudgetLine
   private wasDirty = false
   private titled?: string | null
@@ -532,7 +530,7 @@ export class FigureModellerPage extends PageView {
     if (this.error) return html`<p role="alert" class="error">${this.error}</p>`
     const view = this.session.read()
     /* A new figure's third way to start: the app's assistant dock, with a request put in its input for the author to finish and send (B, U04). */
-    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .instances=${this.instances} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
+    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
       ${this.commandError ? html`<p slot="notice" fit-error role="alert">${this.commandError}</p>` : ''}
       <figure-properties
         slot="figure"
@@ -562,7 +560,6 @@ export class FigureModellerPage extends PageView {
         .figureId=${view.id}
         .figureType=${this.row.type}
         @capacity-changed=${(event: CustomEvent) => {
-          this.instances = event.detail.instances
           this.budget = event.detail.budget
         }}
         @fit-base-to-parts=${this.fitToParts}