@things-factory/figure-ui 10.1.205 → 10.1.207

package/client/modeller/figure-preview.ts

@@ -3,14 +3,14 @@ import { customElement, property, query, state } from 'lit/decorators.js'
 
 import { i18next, localize } from '@operato/i18n'
 import { compileFigureAsset } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureDataRow, FigureDataValue } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureDataRow, FigureDataValue, FigureGraphStateInput } from '@hatiolab/figure-model'
 import { create, registerFigure, unregisterFigure } from '@hatiolab/things-scene'
 
 import { DEFAULT_VIEW, previewBoardDepth, sceneLook, WORKBENCH, type ViewSettings } from '@things-factory/figure-viewer/dist-client/figure-view.js'
 import { dialShape } from './angle-dial.js'
 import { domainOf, motionWrittenByData, typedValueOf, valueRowsOf } from './data-interface.js'
 import { derivedOf, type FigureRevision } from './revision.js'
-import { authoredSizeOf, occupancyAtSize, PREVIEW_FACTOR, PREVIEW_WAYS, previewClampsOf, previewInstances, previewOneInstance, previewTypeOf, setupPartOf, sizeRangeOf, sizeWithinRange } from '@things-factory/figure-viewer/dist-client/preview-model.js'
+import { authoredSizeOf, bodyAtSize, PREVIEW_FACTOR, PREVIEW_WAYS, previewClampsOf, previewInstances, previewOneInstance, previewTypeOf, setupPartOf, sizeSpanOf, sizeWithinRange } from '@things-factory/figure-viewer/dist-client/preview-model.js'
 import { previewSizeWordsOf } from './preview-size.js'
 
 /**
@@ -331,11 +331,9 @@ export class FigurePreview extends localize(i18next)(LitElement) {
   /** The one figure's size: a slider per axis the figure lets change, and what it is at the size tried. */
   private renderSizes(asset: FigureAsset, size: { x: number; y: number; z: number }) {
     const say = (key: string, params?: Record<string, string>) => i18next.t(key, params)
-    /* A board sizes a figure by the space it takes: with none declared, its box folds and no size can be tried. */
-    if (!asset.occupancy) return html`<div sizes><p said>${i18next.t('figure.text.preview-needs-space')}</p></div>`
     return html`<div sizes>
       ${(['x', 'y', 'z'] as const).map(axis => {
-        const range = sizeRangeOf(asset, axis)
+        const range = sizeSpanOf(asset, axis)
         if (!range) return nothing
         return html`<label>
           <span>${i18next.t(`figure.label.measure-${axis}`)}</span>
@@ -364,8 +362,8 @@ export class FigurePreview extends localize(i18next)(LitElement) {
     if (used === undefined || !this.trying) return
     this.trying = { ...this.trying, [axis]: used }
     const instance = this.scene?.root?.components?.[0] as { model?: { width?: number; height?: number }; set(props: Record<string, unknown>): void } | undefined
-    /* The instance's box is the space the figure takes at the sizes tried, not the sizes (occupancyAtSize). */
-    const box = occupancyAtSize(asset!, this.trying) ?? this.trying
+    /* The instance's box is the body at the sizes tried, not the sizes (bodyAtSize). */
+    const box = bodyAtSize(asset!, this.trying) ?? this.trying
     instance?.set({ width: box.x, depth: box.y, height: box.z })
     const { width = 0, height = 0 } = instance?.model ?? {}
     instance?.set({ left: this.board.width / 2 - width / 2, top: this.board.height / 2 - height / 2 })
@@ -377,7 +375,7 @@ export class FigurePreview extends localize(i18next)(LitElement) {
     this.scene?.root?.fitCameraToModel?.()
   }
 
-  private renderDrivers(asset: FigureAsset, controls: FigureAsset['document']['model']['inputs'], clips: string[]) {
+  private renderDrivers(asset: FigureAsset, controls: FigureGraphStateInput[], clips: string[]) {
     const changed = controls.filter(c => this.giving[c.id] !== undefined && this.giving[c.id] !== asset.stateDefaults[c.id])
     return html`<div clips>
       ${changed.length
@@ -600,8 +598,8 @@ export class FigurePreview extends localize(i18next)(LitElement) {
       this.valuing = {}
       registerFigure(type, asset)
       this.registered = type
-      /* Each instance stands in the space the figure takes at the size it is asked (occupancyAtSize), as a board reads it. */
-      const boxOf = (asked: { x: number; y: number; z: number }) => occupancyAtSize(asset, asked) ?? asked
+      /* Each instance stands in its body at the size it is asked (bodyAtSize), as a board reads it. */
+      const boxOf = (asked: { x: number; y: number; z: number }) => bodyAtSize(asset, asked) ?? asked
       const { components, board } = this.way === 'one' ? previewOneInstance(type, boxOf(size)) : previewInstances(type, size, boxOf)
       this.board = board
       this.trying = this.way === 'one' ? { ...size } : undefined
@@ -609,8 +607,8 @@ export class FigurePreview extends localize(i18next)(LitElement) {
         type: 'model-layer',
         width: board.width,
         height: board.height,
-        /* As tall as the figure may grow: twice for the eight, the declared height range's top for the one. */
-        depth: previewBoardDepth({ placement: asset.placement, base: { y: size.y } }, view.ceilingHeight, this.way === 'one' ? Math.max(1, (sizeRangeOf(asset, 'y')?.max ?? size.y) / size.y) : PREVIEW_FACTOR),
+        /* As tall as the figure may grow: twice for the eight, the top of the height slider for the one. */
+        depth: previewBoardDepth({ placement: asset.placement, base: { y: size.y } }, view.ceilingHeight, this.way === 'one' ? Math.max(1, (sizeSpanOf(asset, 'y')?.max ?? size.y) / size.y) : PREVIEW_FACTOR),
         threed: true,
         sky: 'color',
         ...sceneLook(view),

package/client/modeller/figure-verdict.ts

@@ -392,8 +392,6 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
 
   /** The report over the source being edited. Absent when nothing is drawn, or the format refuses the source. */
   @state() private report?: FigureReport
-  /** Bodies in the asset, drawn or hidden. With none there is nothing to fit the space to, so the button is not offered. */
-  @state() private bodies = 0
   /** Whether the trend chart is open at its own size. */
   @state() private expanded = false
   @state() private inspection?: FigureInspection
@@ -428,9 +426,8 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
   }
 
   private measure() {
-    const { report, bodies, told } = verdictMeasureOf(this.revision?.asset)
+    const { report, told } = verdictMeasureOf(this.revision?.asset)
     this.report = report
-    this.bodies = bodies
     if (!report) this.expanded = false
     this.dispatchEvent(new CustomEvent('capacity-changed', { detail: told }))
   }
@@ -766,7 +763,7 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
         ${blocking.length
           ? html`<ul gate>
               <li head>${i18next.t('figure.text.must-fix-to-release')}</li>
-              ${blocking.map(finding => renderGateFinding(finding, true, this.actionsFor(finding.code), this.partNames()))}
+              ${blocking.map(finding => renderGateFinding(finding, true, nothing, this.partNames()))}
             </ul>`
           : nothing}
         ${advisory.length
@@ -782,16 +779,4 @@ export class FigureVerdict extends localize(i18next)(LitElement) {
   private partNames(): string[] {
     return (this.revision?.asset.appearance ?? []).map(look => look.target)
   }
-
-  /** The same way out the release panel offers for the same two findings — declare the space from the parts. */
-  private actionsFor(code: string) {
-    if (code !== 'part-outside-occupancy' && code !== 'occupancy-undeclared') return nothing
-    /* A new figure with no parts is refused as undeclared too, but fitting needs parts to measure (seen 2026-09-24). */
-    if (!this.bodies) return nothing
-    return html`<button fit @click=${this.fit}>${i18next.t('figure.button.fit-base-to-parts')}</button>`
-  }
-
-  private fit = () => {
-    this.dispatchEvent(new CustomEvent('fit-base-to-parts', { bubbles: true, composed: true }))
-  }
 }

package/client/modeller/gizmo.ts

@@ -111,6 +111,16 @@ export function gizmoReachOf(asset: AssetLike, part: string): GizmoReach {
 }
 
 /** Where a drag left the part, in the asset frame: millimetres, degrees and per-axis scale. */
+/**
+ * The size handles that change one measure (ADR-0140 4.1): a round part's radius across is one value, so its X and Z
+ * handles are the same diameter, and a sphere's three are one. Said on the canvas while the size tool is on, to see how
+ * it handles before deciding to show fewer. Nothing for a part whose handles each change their own measure.
+ */
+export function sameMeasureAxesOf(reach: GizmoReach): Array<'x' | 'y' | 'z'> | undefined {
+  if (!reach.scale || !reach.round) return undefined
+  return reach.round.along.length ? ['x', 'z'] : ['x', 'y', 'z']
+}
+
 export interface GizmoResult {
   position?: [number, number, number]
   rotation?: [number, number, number]

package/client/modeller/keys.ts

@@ -5,7 +5,13 @@
  * Typing is never taken: a key pressed in a field belongs to the field -- Backspace in a name box deletes a letter,
  * not the part.
  */
-export type KeyAction = 'undo' | 'redo' | 'duplicate' | 'remove' | 'deselect' | GizmoKey
+/*
+ * `copy` · `paste` are the modeller's own: a part copied and pasted is the kernel's duplicate, with a name of its own.
+ * Left to the scene, Ctrl+C / Ctrl+V copied the canvas object with the part's name -- two objects of one name, the copy
+ * moving the original (user 2026-10-21). `hold` is a key kept from the scene that the modeller has no use for: the
+ * scene's cut and bulk paste act on canvas objects alone and leave the figure out of step with them.
+ */
+export type KeyAction = 'undo' | 'redo' | 'duplicate' | 'remove' | 'deselect' | 'copy' | 'paste' | 'hold' | GizmoKey
 
 /** The gizmo's modes on W, E and R, as the scene has them. */
 export type GizmoKey = 'translate' | 'rotate' | 'scale'
@@ -36,6 +42,9 @@ export function keyActionOf(e: KeyLike, selected: string): KeyAction | null {
   const key = e.key.toLowerCase()
   if (mod && key === 'z') return e.shiftKey ? 'redo' : 'undo'
   if (mod && key === 'y') return 'redo'
+  if (mod && key === 'c') return selected ? 'copy' : 'hold'
+  if (mod && key === 'v') return e.shiftKey ? 'hold' : 'paste'
+  if (mod && key === 'x') return 'hold'
   if (!selected) return null
   if (mod && key === 'd') return 'duplicate'
   if (!mod && (key === 'delete' || key === 'backspace')) return 'remove'

package/client/modeller/links.ts

@@ -1,5 +1,5 @@
-import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion, figureSurfaceOf } from '@hatiolab/figure-model'
-import type { FigureFollow, FigureSizeRange } 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'
@@ -733,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
 }
 
 /**
@@ -807,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/maturity.ts

@@ -137,7 +137,7 @@ export function figureReportOf(asset: FigureAsset): FigureReport | undefined {
     },
     { key: 'detail', blocked: 'figure.text.maturity-blocked-no-detail-level' },
     { key: 'reactive', blocked: 'figure.text.maturity-blocked-no-binding' },
-    readable(asset, plan, drawn, writers)
+    readable(drawn, writers)
   ]
 
   return {
@@ -229,13 +229,10 @@ const roundFootprint = (shape: { extrusion?: { axis: string; section: { kind: st
  * finer segment count does not raise it: H = −Σ p·log p over each material's share of the footprint plus the
  * background, divided by log(`LIMITS.distinctMaterials` + 1), the most this measure can reach.
  *
- * The footprint is the base box: the space the asset declares when it declares one (ADR-0044's box is the model's
- * occupancy), otherwise the drawn bodies' own extent. Bodies are their axis-aligned world boxes
+ * The footprint is the drawn bodies' own extent, the box a board gives it (ADR-0145). Bodies are their axis-aligned world boxes
  * (`figureWorldBoxesOf`, the gate's reading); the higher one covers the lower.
  */
 function readable(
-  asset: FigureAsset,
-  plan: ReturnType<typeof compileFigureDocument>,
   drawn: FigureAssetGeometry[],
   writers: Map<string, string>
 ): FigureMaturityAxis {
@@ -245,20 +242,12 @@ function readable(
     .map(body => ({ body, box: figureWorldBoxesOf([body], writers)[0]! }))
   if (placed.length === 0) return { key: 'readable', blocked: 'figure.text.maturity-blocked-no-parts' }
 
-  let frame: { x0: number; x1: number; z0: number; z1: number }
-  if (asset.occupancy) {
-    const values = plan.evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values
-    const at = (ref: string) => values[ref] as number
-    const b = asset.occupancy.bounds
-    frame = { x0: at(b.x.min), x1: at(b.x.max), z0: at(b.z.min), z1: at(b.z.max) }
-  } else {
-    frame = { x0: Infinity, x1: -Infinity, z0: Infinity, z1: -Infinity }
-    for (const { box } of placed) {
-      frame.x0 = Math.min(frame.x0, box.centre.x - box.extent.x / 2)
-      frame.x1 = Math.max(frame.x1, box.centre.x + box.extent.x / 2)
-      frame.z0 = Math.min(frame.z0, box.centre.z - box.extent.z / 2)
-      frame.z1 = Math.max(frame.z1, box.centre.z + box.extent.z / 2)
-    }
+  const frame = { x0: Infinity, x1: -Infinity, z0: Infinity, z1: -Infinity }
+  for (const { box } of placed) {
+    frame.x0 = Math.min(frame.x0, box.centre.x - box.extent.x / 2)
+    frame.x1 = Math.max(frame.x1, box.centre.x + box.extent.x / 2)
+    frame.z0 = Math.min(frame.z0, box.centre.z - box.extent.z / 2)
+    frame.z1 = Math.max(frame.z1, box.centre.z + box.extent.z / 2)
   }
 
   const regions = topViewRegions(placed, frame)
@@ -417,26 +406,21 @@ export interface FigureBudgetLine {
 }
 
 /**
- * What the verdict tab measures of the figure on screen once it settles: the report, the bodies there are to fit the
- * space to (drawn or hidden -- a hidden part is still a part to measure), and what it tells the page: the count for its
- * tab and the parts list's line, from the same report. A source the format refuses has no report.
+ * What the verdict tab measures of the figure on screen once it settles: the report, and what it tells the page: the
+ * count for its tab and the parts list's line, from the same report. A source the format refuses has no report.
  */
 export function verdictMeasureOf(asset: FigureAsset | undefined): {
   report?: FigureReport
-  bodies: number
   told: { instances?: number; budget?: FigureBudgetLine }
 } {
   let report: FigureReport | undefined
-  let bodies = 0
   try {
-    const cost = asset ? figureCostOf(asset) : undefined
-    bodies = cost ? cost.groups + cost.hidden : 0
     report = asset ? figureReportOf(asset) : undefined
   } catch {
     /* A source the format refuses has no report; the server's finding says why. */
     report = undefined
   }
-  return { report, bodies, told: { instances: report?.capacity.instances, budget: budgetOf(report) } }
+  return { report, told: { instances: report?.capacity.instances, budget: budgetOf(report) } }
 }
 
 export function budgetOf(report: FigureReport | undefined): FigureBudgetLine | undefined {

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(' ')
 }
 
 /**
@@ -83,20 +76,14 @@ export function clipLossOf(error: unknown): FigureClipLoss[] | null {
   return codeOf(error) === 'CLIPS_DROPPED' ? (detailsOf(error, 'clips-dropped')?.clips ?? []) : null
 }
 
-/** A part refused because the declared room reads it -- the one refusal deleting it with the room refitted answers. */
-export function inDeclaredRoom(error: unknown): boolean {
-  return codeOf(error) === 'PART_REFERENCED' && !!detailsOf(error, 'in-declared-space')
-}
-
 /**
  * Why a part cannot be deleted, in the author's words. Since the chief architect's ruling of 2026-09-27 a part that
  * holds others, leads a motion or is followed goes, and what depended on it is let go of (`removalNoticeOf`); what is
- * left is the declared space (with a way on: fit it again) and a row -- one laid along the part, or hanging in its row.
+ * left is a row -- one laid along the part, or hanging in its row.
  */
 export function partRefusalOf(error: unknown, part: string, say: Say): string | null {
   const code = codeOf(error)
   if (code !== 'PART_REFERENCED' && code !== 'PART_ROW') return null
-  if (detailsOf(error, 'in-declared-space')) return say('figure.text.part-in-declared-space', { part })
   const along = detailsOf(error, 'row-along')
   if (along) return say('figure.text.part-row-along', { part, rows: along.rows.join(', ') })
   const carried = detailsOf(error, 'hangs-in-row')
@@ -297,7 +284,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 +297,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/pages/figure-modeller-page.ts

@@ -10,7 +10,6 @@ import { fetchFigure, fetchFigureCategories, fetchFigureNamespaces, fetchFigureT
 import { figureProposalOutcome } from '../figure-assistant.js'
 import { availableRecipes, recipeGuide } from '../modeller/recipe-source.js'
 import type { RecipeTemplate } from '../modeller/recipes.js'
-import { occupancyFromParts } from '../modeller/occupancy.js'
 import type { FigureAuthoringAction } from '@hatiolab/figure-model'
 import type { FigureGateFinding } from '../types.js'
 import '../modeller/editor.js'
@@ -290,13 +289,7 @@ export class FigureModellerPage extends PageView {
       input.value = this.row.type ?? ''
     }
   }
-  /** 「부품에 맞추기」 — 공간을 지금 부품에서 다시 선언한다. 저장은 저작자가 따로 한다. */
-  private fitToParts = () => {
-    const shown = this.session.revisionNow()
-    /* Nothing open, nothing to fit: the button stands only beside an open figure. */
-    if (shown) this.runCommand(() => occupancyFromParts(shown.asset))
-  }
-  /** A command from the properties tab — rename, declare the room, the mounting face. */
+  /** A command from the properties tab — rename, the mounting face. */
   private onCommand = (event: Event) => {
     const action = (event as CustomEvent).detail?.action as FigureAuthoringAction | undefined
     if (action) this.runCommand(() => action)
@@ -311,18 +304,12 @@ export class FigureModellerPage extends PageView {
       this.commandError = ''
       this.changed()
     } catch (error) {
-      /*
-        This used to set the page error, which replaces the whole editor with one raw line — for a figure with no
-        parts that line was 「OCCUPANCY_NO_PARTS: occupancy: no part could be measured」 (2026-09-24).
-      */
-      this.commandError =
-        (error as { code?: string })?.code === 'OCCUPANCY_NO_PARTS'
-          ? i18next.t('figure.text.fit-needs-parts')
-          : (error as { code?: string })?.code
-            ? editRefusalOf(error, (key, params) => i18next.t(key, params))
-            : error instanceof Error
-              ? error.message
-              : String(error)
+      /* Said in the author's words beside the side panel, not as the page error that replaces the whole editor. */
+      this.commandError = (error as { code?: string })?.code
+        ? editRefusalOf(error, (key, params) => i18next.t(key, params))
+        : error instanceof Error
+          ? error.message
+          : String(error)
     }
   }
   /**
@@ -562,7 +549,6 @@ export class FigureModellerPage extends PageView {
         @capacity-changed=${(event: CustomEvent) => {
           this.budget = event.detail.budget
         }}
-        @fit-base-to-parts=${this.fitToParts}
         @release-verdict=${(event: CustomEvent<{ blocking: FigureGateFinding[] }>) => (this.releaseBlockers = event.detail.blocking)}
       ></figure-verdict>
       <figure-history-panel
@@ -575,7 +561,6 @@ export class FigureModellerPage extends PageView {
         .dirty=${!!view.dirty}
         .saveFirst=${this.saveBeforeRevert}
         .serverSource=${() => this.session.confirmedSource()}
-        @fit-base-to-parts=${this.fitToParts}
         @figure-released=${this.released}
         @figure-reverted=${this.reverted}
       ></figure-history-panel>