@things-factory/figure-ui 10.1.205 → 10.1.206

package/client/modeller/editor-styles.ts

@@ -131,6 +131,22 @@ export const EditorStyles = css`
     min-width: 0;
     min-height: 0;
   }
+  /* Which size handles change one diameter (ADR-0140 4.1): a quiet line over the canvas, out of the gizmo's way. */
+  p[same-measure] {
+    position: absolute;
+    bottom: 12px;
+    left: 50%;
+    z-index: 5;
+    transform: translateX(-50%);
+    margin: 0;
+    padding: 4px 10px;
+    border-radius: 999em;
+    background: var(--md-sys-color-surface-container-high);
+    color: var(--md-sys-color-on-surface-variant);
+    font-size: var(--ui-t-small, 11.5px);
+    pointer-events: none;
+    white-space: nowrap;
+  }
   /* A new figure's first question, over the empty canvas. */
   div[start] {
     position: absolute;

package/client/modeller/editor.ts

@@ -30,13 +30,13 @@ import './figure-preview.js'
 import './figure-settings.js'
 import { DEFAULT_VIEW, type ViewSettings } from '@things-factory/figure-viewer/dist-client/figure-view.js'
 import './figure-capability-panel.js'
-import { gizmoChanges, gizmoReachOf, sizeKeepOf, type GizmoReach, type GizmoResult } from './gizmo.js'
+import { gizmoChanges, gizmoReachOf, sameMeasureAxesOf, sizeKeepOf, type GizmoReach, type GizmoResult } from './gizmo.js'
 import { keptBySizeOf, partsAtFrame, SIZE_KEEPS_WORDS, startSizeDrag, throughPlaneOf, type SizeDrag, type SizeDragFrame } from './size-drag.js'
 import type { KeyAction } from './keys.js'
 import { ModellerKeys } from './modeller-keys.js'
 import { PaneFold } from './pane-fold.js'
 import { PanelMemory } from './panel-memory.js'
-import { RefusalTeller, type Retry } from './refusal-teller.js'
+import { RefusalTeller } from './refusal-teller.js'
 import { groupFields, ownerOf, partLabelOf, repeatOf, type FieldLike, type FieldGroup } from './fields.js'
 import { SidePanelStyles } from '@things-factory/figure-viewer/dist-client/side-panel-styles.js'
 import { EditorStyles } from './editor-styles.js'
@@ -60,11 +60,11 @@ type HeldValues = { position?: number[]; rotation?: number[]; size?: (number | u
 import { occupancyFromParts, roomRefitRowsOf } from './occupancy.js'
 import { gateFindingStyles, renderGateFinding } from './gate-findings.js'
 import type { FigureGateFinding } from '../types.js'
-import { editRefusalOf, inDeclaredRoom, narrowingRetryOf, partNameRefusalOf, partRefusalOf, placedRefusalOf, recipeRefusalOf, removalNoticeOf } from './refusals.js'
+import { editRefusalOf, inDeclaredRoom, partNameRefusalOf, sizeRangeFitsOf, partRefusalOf, placedRefusalOf, recipeRefusalOf, removalNoticeOf } from './refusals.js'
 import type { FigureRenderPart } from './renderer.js'
 import type { FigureBudgetLine } from './maturity.js'
 import { HelpToggles } from './help.js'
-import { endPlaceKeyOf, fieldWordsOf, followOf, sizeFollowersOf, measureNow, partSummaryOf, instanceRangeOf, instanceRangeToDeclare, proportionToFollow, rangeDiffers, rangeWith, turnsAboutAJoint, valueNow } from './links.js'
+import { endPlaceKeyOf, fieldWordsOf, followOf, sizeFollowersOf, measureNow, partSummaryOf, instanceRangeOf, instanceSizeToDeclare, proportionToFollow, rangeWith, turnsAboutAJoint, valueNow } from './links.js'
 import { jointFanOf } from './joint-fan.js'
 import { derivedOf, type FigureRevision } from './revision.js'
 import { jointDragOf } from './joint-drag.js'
@@ -135,8 +135,6 @@ export class FigureEditor extends LitElement {
    * edit was made (`from`).
    */
   @state() private faceMapping?: { action: FigureAuthoringAction; need: FigureFaceMappingNeed; from: 'section-editor' | 'panel' }
-  /** The same link offered again with the size range narrowed, after a link the declared range could not hold. */
-  @state() private retry?: Retry
   @state() private tab: SideTab = 'properties'
   /** The view settings or the release history, open over the work from the bar. */
   @state() private overlay?: BarOverlay
@@ -268,6 +266,14 @@ export class FigureEditor extends LitElement {
     selected: () => this.selected,
     act: action => this.keyAction(action)
   })
+  /** The part Ctrl+C took: pasted as the kernel's duplicate. Not kept past the editor, nor written anywhere. */
+  private copied = ''
+  /** A copied part still in the figure is duplicated -- a part of its own, named by figure-model; one gone, nothing. */
+  private pasteCopied() {
+    const asset = this.session?.revisionNow()?.asset
+    if (!this.copied || !asset?.document.model.nodes.some(n => n.op === 'place@1' && n.id === this.copied)) return
+    this.duplicatePart(this.copied)
+  }
   private keyAction(action: KeyAction) {
     const view = this.session!.read()
     const canvas = this.renderRoot.querySelector<FigureCanvas>('figure-canvas')
@@ -275,6 +281,9 @@ export class FigureEditor extends LitElement {
     else if (action === 'undo') view.canUndo && this.run(() => this.session!.undo())
     else if (action === 'redo') view.canRedo && this.run(() => this.session!.redo())
     else if (action === 'duplicate') this.duplicatePart(this.selected)
+    else if (action === 'copy') this.copied = this.selected
+    else if (action === 'paste') this.pasteCopied()
+    else if (action === 'hold') return
     else if (action === 'remove') this.removePart(this.selected)
     else this.selected = ''
   }
@@ -283,9 +292,7 @@ export class FigureEditor extends LitElement {
     session: () => this.session,
     error: () => this.error,
     notice: () => this.notice,
-    retry: () => this.retry,
-    refuse: message => (this.error = message),
-    command: action => this.linkCommand(action)
+    refuse: message => (this.error = message)
   })
   private panelMemory = new PanelMemory(() => this.renderRoot)
   /** The preview is made when first asked for, and kept (hidden) after that; it is taken down with the editor. */
@@ -331,6 +338,14 @@ export class FigureEditor extends LitElement {
       if (closed && this.selected === editing) this.selected = next
     })
   }
+  /** While the size tool is on a round part: which of its handles change the one diameter (ADR-0140 4.1). */
+  private renderSameMeasure(unavailable: boolean) {
+    if (unavailable || this.gizmoMode !== 'scale' || !this.selected) return nothing
+    const axes = sameMeasureAxesOf(this.reachOf(this.selected))
+    return axes
+      ? html`<p same-measure role="status">${i18next.t('figure.text.gizmo-same-measure', { axes: axes.map(a => a.toUpperCase()).join(' · ') })}</p>`
+      : nothing
+  }
   /** The scene toggles: the mode already shown takes the gizmo away. */
   private useGizmo(mode: 'translate' | 'rotate' | 'scale') {
     /*
@@ -412,6 +427,9 @@ export class FigureEditor extends LitElement {
   }
 
   private changed() {
+    /* What the step did to the size ends the author typed, said with whatever else it said. */
+    const fits = this.session?.takeSizeRangeFits() ?? []
+    if (fits.length) this.notice = [this.notice, sizeRangeFitsOf(fits, (key, params) => i18next.t(key, params))].filter(Boolean).join(' ')
     this.requestUpdate()
     this.dispatchEvent(new CustomEvent('changed', { bubbles: true, composed: true }))
   }
@@ -507,7 +525,6 @@ export class FigureEditor extends LitElement {
     this.run(() => this.session!.edit({ kind: 'move-part', target: id, to }))
   }
   private removePart(id: string, refitRoom = false) {
-    this.retry = undefined
     try {
       const view = this.session!.edit({ kind: 'remove-part', target: id, ...(refitRoom ? { refitRoom: true } : {}) }) as { removal?: Parameters<typeof removalNoticeOf>[0] }
       this.error = ''
@@ -965,7 +982,6 @@ export class FigureEditor extends LitElement {
   private linkCommand(action: FigureAuthoringAction, from: 'section-editor' | 'panel' = 'panel'): boolean {
     /* Committed or refused, a command in hand is let go of: the figure as it stands is drawn again. */
     this.holdAction(null)
-    this.retry = undefined
     this.notice = ''
     const hadSize = this.hasSize()
     const hadSpace = !!this.shown()?.asset.occupancy
@@ -996,12 +1012,6 @@ export class FigureEditor extends LitElement {
         this.error = ''
         return false
       }
-      const narrowing = narrowingRetryOf(action, error, (key, params) => i18next.t(key, params))
-      if (narrowing) {
-        this.error = narrowing.message
-        this.retry = { label: narrowing.label, action: narrowing.retry as FigureAuthoringAction }
-        return false
-      }
       this.error =
         code === 'DIMENSION_CYCLE'
           ? i18next.t('figure.text.follow-would-loop')
@@ -1086,21 +1096,21 @@ export class FigureEditor extends LitElement {
     label.addEventListener('pointerup', up)
     label.addEventListener('pointercancel', up)
   }
-  /** The sizes a board may give the figure, and the way to measure them again after its parts changed. */
+  /** The sizes a board may give the figure: the ends the author typed, and the rest as far as its parts allow. */
   private renderInstanceRange(shown: FigureRevision | undefined, unavailable: boolean) {
     if (!shown) return nothing
     const asset = shown.asset
-    /* Measured once per version: measuring evaluates the figure at its edges. */
+    /* Computed once per version: figure-model evaluates the figure at its edges. */
     const measured = derivedOf(shown, 'instance-range', () => {
       let of: ReturnType<typeof instanceRangeOf>
-      let toDeclare: ReturnType<typeof instanceRangeToDeclare>
+      let toDeclare: ReturnType<typeof instanceSizeToDeclare>
       try {
         of = instanceRangeOf(asset)
       } catch {
         of = undefined
       }
       try {
-        toDeclare = of ? undefined : instanceRangeToDeclare(asset)
+        toDeclare = of ? undefined : instanceSizeToDeclare(asset)
       } catch {
         toDeclare = undefined
       }
@@ -1121,13 +1131,17 @@ export class FigureEditor extends LitElement {
       return html`<section board-size>
         ${title('figure.text.board-size-fixed-explained')}
         <p fixed-size>${i18next.t('figure.text.board-size-fixed', { x: mm(toDeclare.at.x), y: mm(toDeclare.at.y), z: mm(toDeclare.at.z) })}</p>
-        <button act ?disabled=${unavailable} @click=${() => this.linkCommand({ kind: 'declare-instance-size', range: toDeclare.range, at: toDeclare.at })}>
+        <button act ?disabled=${unavailable} @click=${() => this.linkCommand({ kind: 'declare-instance-size', at: toDeclare.at })}>
           <md-icon>open_in_full</md-icon>${i18next.t('figure.button.declare-instance-size')}
         </button>
       </section>`
     if (!range) return nothing
-    const differs = rangeDiffers(range.declared, range.measured)
     const followers = sizeFollowersOf(asset)
+    /*
+      An end the author typed shows its number; an open end is empty, with what the parts allow written faintly in it
+      (ADR-0087 decision 6). Typing narrows that end, emptying the field opens it again.
+    */
+    const shownEnd = (r: (typeof range)['x'], bound: 'min' | 'max') => (bound === 'max' && !Number.isFinite(r.max) ? '∞' : mm(r[bound]))
     return html`<section board-size>
       ${title('figure.text.board-size-range-explained')}
       ${(['x', 'y', 'z'] as const).map(
@@ -1139,11 +1153,12 @@ export class FigureEditor extends LitElement {
                 aria-label=${`size.${axis}.${bound}`}
                 type="number"
                 step="any"
-                .value=${live(String(Math.round(range.declared[axis][bound])))}
+                .value=${live(range[axis].narrowed[bound] ? String(Math.round(range[axis][bound])) : '')}
+                placeholder=${shownEnd(range[axis], bound)}
                 ?disabled=${unavailable}
                 @change=${(e: Event) => {
-                  const next = rangeWith(range.declared, axis, bound, (e.target as HTMLInputElement).valueAsNumber)
-                  if (next) this.linkCommand({ kind: 'declare-instance-size', range: next, replace: true })
+                  const typed = (e.target as HTMLInputElement).valueAsNumber
+                  this.linkCommand({ kind: 'declare-instance-size', range: rangeWith(range, axis, bound, typed), replace: true })
                 }}
               />`
             )}
@@ -1157,19 +1172,6 @@ export class FigureEditor extends LitElement {
             })
           : i18next.t('figure.text.board-size-no-followers')}
       </p>
-      ${differs
-        ? html`<p hint>
-              ${i18next.t('figure.text.instance-range-can-widen', {
-                ranges: (['x', 'y', 'z'] as const)
-                  .filter(axis => rangeDiffers(range.declared, { ...range.declared, [axis]: range.measured[axis] }))
-                  .map(axis => `${axis.toUpperCase()} ${mm(range.measured[axis].min)} – ${mm(range.measured[axis].max)}`)
-                  .join(' · ')
-              })}
-            </p>
-            <button act ?disabled=${unavailable} @click=${() => this.linkCommand({ kind: 'declare-instance-size', range: range.measured, replace: true })}>
-              <md-icon>straighten</md-icon>${i18next.t('figure.button.remeasure-range')}
-            </button>`
-        : nothing}
       ${this.renderSizingRule(asset, unavailable)}
     </section>`
   }
@@ -1325,7 +1327,7 @@ export class FigureEditor extends LitElement {
       this.publishing?.part === part
         ? this.publishing
         : listed && input
-          ? { part, label: listed.label, min: input.min, max: input.max }
+          ? /* A published input has both ends (figure-model checkPublicInput). */ { part, label: listed.label, min: input.min!, max: input.max! }
           : undefined
     const open = !!form
     const edit = (key: 'label' | 'min' | 'max') => (e: Event) => {
@@ -1921,7 +1923,7 @@ export class FigureEditor extends LitElement {
           @render-error=${(e: CustomEvent<Error>) => {
             this.error = e.detail.message
           }}
-        ></figure-canvas></div>
+        ></figure-canvas>${this.renderSameMeasure(unavailable)}</div>
         <aside slot="end">
           <div tabs>
             ${this.renderTab('properties', 'tune', i18next.t('figure.label.properties'))}

package/client/modeller/fasten-form.ts

@@ -1,4 +1,4 @@
-import { FIGURE_FACES, figureFastenTargetAt, figurePlaneFacingOf, figureSurfaceKeptPlaceOf } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureFastenKeptGapOf, figureFastenTargetAt, figurePlaneFacingOf, figureSurfaceKeptPlaceOf } from '@hatiolab/figure-model'
 import type { FigureAuthoringAction, FigureFace, FigureSurfacePlace } from '@hatiolab/figure-model'
 
 import { faceViewOf, type FaceView, type FastenMode, type FastenTarget } from './fasten-geometry.js'
@@ -38,6 +38,12 @@ export interface FastenForm {
   gap: number
   /** The record's gap when it is worked out (a length that follows something): kept until a number is typed. */
   gapKept: unknown
+  /**
+   * Where the gap came from (ADR-0140 stage 4, 「현재 상태로 붙이기」): `kept` -- the distance the part stands at, worked
+   * out again whenever where or how it is fastened changes, so fastening does not move it; `typed` -- the author's
+   * number, left as it is; `pressed` -- 0, the part put where the canvas was pressed.
+   */
+  gapFrom: 'kept' | 'typed' | 'pressed'
   align: Partial<Record<Axis, Alignment>>
   alignMm: Partial<Record<Axis, number>>
   alignInput: Partial<Record<Axis, string>>
@@ -52,6 +58,7 @@ export const freshFasten = (): FastenForm => ({
   facing: 'meet',
   gap: 0,
   gapKept: undefined,
+  gapFrom: 'kept',
   align: {},
   alignMm: {},
   alignInput: {}
@@ -60,7 +67,9 @@ export const freshFasten = (): FastenForm => ({
 /** The part's own fastening as a form, or a fresh one: a window opens on what the part has (walk 1, 2026-09-26). */
 export function fastenFormOf(revision: FigureRevision, part: string): FastenForm {
   const own = fasteningOf(revision, part)
-  return own && !own.atOrigin ? ({ ...freshFasten(), ...own } as FastenForm) : freshFasten()
+  if (!own || own.atOrigin) return freshFasten()
+  /* A gap the record works out is the author's; a number is where the part stands, so aiming again keeps it there. */
+  return { ...freshFasten(), ...own, gapFrom: own.gapKept !== undefined ? 'typed' : 'kept' } as FastenForm
 }
 
 /** What a part may be fastened to: every other part that can be, each said whether it would close a loop. */
@@ -133,11 +142,11 @@ export function fastenChanged(
   change: FastenChange
 ): FastenForm {
   const f = form
-  if ('targetFace' in change) return aimFasten(revision, part, f, { targetFace: change.targetFace as FigureFace })
-  if ('onSurface' in change) return aimFasten(revision, part, f, { surface: true })
-  if ('surface' in change) return { ...f, surface: change.surface }
-  if ('mode' in change) return { ...f, facing: change.mode }
-  if ('gap' in change) return { ...f, gap: change.gap, gapKept: undefined }
+  if ('targetFace' in change) return keptGapOf(revision, part, aimFasten(revision, part, f, { targetFace: change.targetFace as FigureFace }))
+  if ('onSurface' in change) return keptGapOf(revision, part, aimFasten(revision, part, f, { surface: true }))
+  if ('surface' in change) return keptGapOf(revision, part, { ...f, surface: change.surface })
+  if ('mode' in change) return keptGapOf(revision, part, { ...f, facing: change.mode })
+  if ('gap' in change) return { ...f, gap: change.gap, gapKept: undefined, gapFrom: 'typed' }
   return {
     ...f,
     align: { ...f.align, [change.axis]: change.how },
@@ -145,6 +154,29 @@ export function fastenChanged(
   }
 }
 
+/**
+ * The form with the gap that keeps the part where it stands (ADR-0140 stage 4, user 2026-10-20 「현재 상태로 붙이기」):
+ * figure-model's `figureFastenKeptGapOf` for what it is aimed at and how it meets it. A gap the author typed, or the 0 a
+ * canvas press puts, is left as it is. Nothing aimed at yet, the form is as it was.
+ */
+export function keptGapOf(revision: FigureRevision, part: string, form: FastenForm): FastenForm {
+  if (form.gapFrom !== 'kept') return form
+  const asset = revision.asset
+  const theirFaces = form.target ? facesOf(asset, form.target) : FACES
+  const targetFace = (theirFaces.includes(form.targetFace) ? form.targetFace : theirFaces[0]) as FigureFace
+  const planeWay = figurePlaneFacingOf(asset)
+  const mode: FastenMode = form.toPlane ? (mountingPlaneOf(asset).facings.includes(form.facing) ? form.facing : (planeWay ?? 'meet')) : form.facing
+  const to = form.toPlane
+    ? ('plane' as const)
+    : form.target && form.surface && surfaceOf(asset, form.target)
+      ? { part: form.target, surface: form.surface }
+      : form.target
+        ? { part: form.target, face: targetFace }
+        : undefined
+  if (!to) return form
+  return { ...form, gap: figureFastenKeptGapOf(asset, part, to, mode, { ...revision.inputs }), gapKept: undefined }
+}
+
 /** What a form comes to: the face aimed at, the way, the drawing of the face and the command. */
 export interface FastenPlan {
   /** Nothing is aimed at until a part or the plane is chosen. */
@@ -226,12 +258,16 @@ export function fastenSentenceOf(
   return say(`figure.text.fasten-sentence-${plan.mode}`, { to })
 }
 
-/** What the folded details hold that is not their default, said while folded; nothing for the default. */
+/**
+ * What the folded details hold that is not their default, said while folded; nothing for the default. The gap's default
+ * is the one it starts at -- the distance the part stands at, or 0 where the canvas was pressed -- so only a number typed
+ * is said.
+ */
 export function fastenDetailWordsOf(form: FastenForm, say: Say): string[] {
   return [
     ...(form.gapKept !== undefined
       ? [say('figure.text.fasten-summary-gap-worked-out')]
-      : form.gap
+      : form.gapFrom === 'typed' && form.gap
         ? [say('figure.text.fasten-summary-gap', { mm: String(form.gap) })]
         : [])
   ]
@@ -244,6 +280,9 @@ export function fastenDetailWordsOf(form: FastenForm, say: Say): string[] {
  * nothing to fasten to is not aimed at; a press on a curve there is no fastening to aims at the part alone. Each says
  * why, by its words' key.
  */
+/* Put where the canvas was pressed: on the face or the surface there, with no gap (ADR-0140 stage 4). */
+const PRESSED = { gap: 0, gapKept: undefined, gapFrom: 'pressed' as const }
+
 export function aimFastenAt(
   revision: FigureRevision,
   part: string,
@@ -265,8 +304,8 @@ export function aimFastenAt(
     /* On the face where it was pressed, as a point of a curved surface is: its middle there. */
     const onFace = aimFasten(revision, part, { ...aimed, surface: undefined }, { targetFace: lands.face as FigureFace })
     const at = lands.at as Partial<Record<Axis, number>>
-    return { form: { ...onFace, align: Object.fromEntries(Object.keys(at).map(a => [a, 'mm'])) as FastenForm['align'], alignMm: { ...at }, alignInput: {} }, part: target }
+    return { form: { ...onFace, ...PRESSED, align: Object.fromEntries(Object.keys(at).map(a => [a, 'mm'])) as FastenForm['align'], alignMm: { ...at }, alignInput: {} }, part: target }
   }
-  if ('surface' in lands) return { form: { ...aimed, toPlane: false, target, surface: lands.surface, align: {}, alignMm: {}, alignInput: {} }, part: target }
+  if ('surface' in lands) return { form: { ...aimed, ...PRESSED, toPlane: false, target, surface: lands.surface, align: {}, alignMm: {}, alignInput: {} }, part: target }
   return { form: aimed, note: 'aim-not-here', part: target }
 }

package/client/modeller/figure-fasten-dialog.ts

@@ -16,6 +16,7 @@ import { turnsInPlace, type FastenMode } from './fasten-geometry.js'
 import {
   aimFasten,
   aimFastenAt,
+  keptGapOf,
   fastenChanged,
   fastenDetailWordsOf,
   fastenFormOf,
@@ -260,7 +261,7 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
                       step="any"
                       .value=${f.gapKept !== undefined ? '' : String(f.gap)}
                       placeholder=${f.gapKept !== undefined ? i18next.t('figure.label.follows-expression') : ''}
-                      @change=${(e: Event) => this.set({ gap: Number((e.target as HTMLInputElement).value) || 0, gapKept: undefined })}
+                      @change=${(e: Event) => this.set({ gap: Number((e.target as HTMLInputElement).value) || 0, gapKept: undefined, gapFrom: 'typed' })}
                     />
                   </div>
                 </details>
@@ -330,7 +331,7 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
     this.aimNote = ''
     const chosen = this.form.toPlane ? PLANE : this.form.target
     if (part === chosen) return
-    this.form = aimFasten(this.revision, this.partId, this.form, part === PLANE ? { plane: true } : { part })
+    this.form = keptGapOf(this.revision, this.partId, aimFasten(this.revision, this.partId, this.form, part === PLANE ? { plane: true } : { part }))
   }
 
   /**

package/client/modeller/figure-links.ts

@@ -278,7 +278,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
         <section size-response>
           <h3>${i18next.t('figure.label.group-size')}</h3>
           <p group-question>${i18next.t('figure.label.resize-intent')}</p>
-          ${canFollow(asset, this.partId) ? this.renderDimensions(asset) : html`<p hint>${i18next.t('figure.text.links-need-a-box')}</p>`}
+          ${canFollow(asset, this.partId) ? this.renderDimensions(asset) : html`<p hint>${i18next.t('figure.text.part-cannot-follow')}</p>`}
         </section>
         ${positions.length
           ? html`<section position-response>
@@ -302,7 +302,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
           ${groupMenu([{ label: i18next.t('figure.button.detach'), icon: 'link_off', disabled: this.locked || !held, run: () => this.command({ kind: 'detach', part: this.partId }) }])}
         </h3>${this.help.hint('figure.text.fastening-explained')}
         <slot name="place"></slot>
-        ${canFasten(asset, this.partId) ? this.renderFastening(asset) : html`<p hint>${i18next.t('figure.text.links-need-a-box')}</p>`}
+        ${canFasten(asset, this.partId) ? this.renderFastening(asset) : html`<p hint>${i18next.t('figure.text.part-cannot-fasten')}</p>`}
       </section>
     `
     this.candidate = this.fastenCandidate

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, occupancyAtSize, 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'
 
 /**
@@ -335,7 +335,7 @@ export class FigurePreview extends localize(i18next)(LitElement) {
     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>
@@ -377,7 +377,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
@@ -609,8 +609,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/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/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':