@things-factory/figure-ui 10.1.151 → 10.1.153

package/client/modeller/fasten-geometry.ts

@@ -125,6 +125,38 @@ export function alignmentAt(d: number, face: number | undefined, part: number, e
   return { how: 'mm', mm: Math.round(d) }
 }
 
+/**
+ * The alignment that brings the footprint inside the face, for 정렬·간격 고치기: on each axis it comes past an edge, the
+ * least move -- to that edge from inside (`min` / `max`, or that distance where edges are not offered) -- or the centre
+ * when the part is wider than the face and cannot be inside. `inside` when nothing of it is past an edge: what is out
+ * is something fastened on it. `unmeasured` when the face has no size to measure against.
+ */
+export function insideAlignmentOf(
+  view: FaceView | undefined,
+  align: Partial<Record<Axis, Alignment>>,
+  alignMm: Partial<Record<Axis, number>>
+): { align: Partial<Record<Axis, Alignment>>; alignMm: Partial<Record<Axis, number>>; moved: Axis[] } | { cannot: 'inside' | 'unmeasured' } {
+  if (!view || view.axes.some(a => view.face[a] === undefined)) return { cannot: 'unmeasured' }
+  const next = { align: { ...align }, alignMm: { ...alignMm }, moved: [] as Axis[] }
+  for (const a of view.axes) {
+    const face = view.face[a]!,
+      part = view.part[a]
+    const at = offsetOf(align[a], alignMm[a], face, part)
+    const low = -face / 2 - (at - part / 2) > 0.5,
+      high = at + part / 2 - face / 2 > 0.5
+    if (!low && !high) continue
+    next.moved.push(a)
+    if (part > face) {
+      next.align[a] = 'centre'
+      continue
+    }
+    const edge = ((low ? -1 : 1) * (face - part)) / 2
+    if (view.edges[a]) next.align[a] = low ? 'min' : 'max'
+    else ((next.align[a] = 'mm'), (next.alignMm[a] = Math.round(edge)))
+  }
+  return next.moved.length ? next : { cannot: 'inside' }
+}
+
 /** How far the footprint comes past the face's edges, per side, and whether it touches the face at all. */
 export function overhangOf(view: FaceView, at: Record<Axis, number>): { touching: boolean; sides: Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> } {
   const sides: Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> = []

package/client/modeller/figure-first-save.ts

@@ -63,6 +63,15 @@ export class FigureFirstSave extends LitElement {
     if (offer.suggested !== undefined) this.suggested = offer.suggested
   }
 
+  /*
+    The name is focused here, each time the question opens. The browser honours `autofocus` once per document: the
+    question asked again opened with nothing focused, and any autofocus taken earlier on the page left even the first
+    opening unfocused (2026-10-11, product-page check).
+  */
+  firstUpdated() {
+    this.renderRoot.querySelector<HTMLInputElement>('#name')?.focus()
+  }
+
   render() {
     return html`
       <div class="what">${i18next.t('figure.text.save-new-figure-desc')}</div>
@@ -70,7 +79,6 @@ export class FigureFirstSave extends LitElement {
         <label for="name">${i18next.t('figure.label.name')}</label>
         <input
           id="name"
-          autofocus
           .value=${this.name}
           placeholder=${i18next.t('figure.text.figure-name-example')}
           @input=${(e: Event) => (this.name = (e.target as HTMLInputElement).value)}

package/client/modeller/figure-links.ts

@@ -6,7 +6,7 @@ import './figure-slot-layout-panel.js'
 import { customElement, property, state } from 'lit/decorators.js'
 
 import { i18next, localize } from '@operato/i18n'
-import { FIGURE_FACES } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureFaceOverhangOf } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureAuthoringAction, FigureDimensionSource, FigureFace } from '@hatiolab/figure-model'
 
 import {
@@ -56,7 +56,7 @@ import {
 import { SidePanelStyles } from './side-panel-styles.js'
 import './figure-fasten-drawing.js'
 import type { FastenChange } from './figure-fasten-drawing.js'
-import { faceViewOf, modeOf, myFaceFor, turnsInPlace, type FastenMode } from './fasten-geometry.js'
+import { faceViewOf, insideAlignmentOf, modeOf, myFaceFor, turnsInPlace, type FaceView, type FastenMode } from './fasten-geometry.js'
 import type { FigureRevision } from './revision.js'
 import { HelpToggles } from './help.js'
 import { jointAxisWord } from './joint-axis.js'
@@ -186,6 +186,8 @@ export class FigureLinks extends localize(i18next)(LitElement) {
   /** The fastening section, marked for a moment when "open attachment settings" brings it into view. */
   @state() private spotlit = false
   @state() private fasten = freshFasten()
+  /** Why 정렬·간격 고치기 moved nothing, said under it; empty once it moved the part or the part changed. */
+  @state() private fixNote = ''
   @state() private motion: MotionForm = freshMotion()
   @state() private place = freshPlace()
   /** How places are made here: one at a time, or by the figure's rule. Unset: by the rule when the figure has one. */
@@ -201,7 +203,9 @@ export class FigureLinks extends localize(i18next)(LitElement) {
   /* The part the forms were loaded for. A panel made with a part already chosen loaded nothing, and said "editing the
      fastening it has" over an empty target (2026-09-27, :3391, the doors). */
   private loadedFor?: string
-  willUpdate(_changed: Map<string, unknown>) {
+  willUpdate(changed: Map<string, unknown>) {
+    /* What 고치기 said is about the figure as it was: another step or another part, and it no longer holds. */
+    if (changed.has('asset') || changed.has('partId')) this.fixNote = ''
     if (this.asset && this.partId && this.partId !== this.loadedFor) {
       this.loadedFor = this.partId
       /* A part's own fastening is not another part's choices: the form opens on it (walk 1, 2026-09-26). */
@@ -430,16 +434,27 @@ export class FigureLinks extends localize(i18next)(LitElement) {
    * holding places instead).
    */
   /** The face the part sits on, in view with the focus on it: where the place across the face is dragged or keyed. */
-  private async showWhere() {
-    this.working = 'fasten'
-    await this.updateComplete
-    /* The drawing draws itself after this panel does: its "where" is there only once it has. */
-    const drawing = this.renderRoot.querySelector<HTMLElement & { updateComplete?: Promise<unknown> }>('figure-fasten-drawing')
-    await drawing?.updateComplete
-    const where = drawing?.shadowRoot?.querySelector<HTMLElement>('div[where]')
-    if (!where) return
-    where.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
-    where.focus({ preventScroll: true })
+  /**
+   * 정렬·간격 고치기: the part moved inside the face it is fastened on, as one step -- the least move on each side it is
+   * out, or centred when it is wider than the face. When nothing of it can be moved, why is said under the button, not
+   * nothing at all (:3300, 2026-10-11: the button only scrolled to the drawing, which was already in view).
+   */
+  private async fixAlignment(view: FaceView | undefined, target: string) {
+    /* Whether it is out is the kernel's measure (a round face is not measured there); the drawing's sizes say how far to move. */
+    const own = this.revision ? figureFaceOverhangOf(this.revision.asset, this.partId, this.revision.inputs) : undefined
+    const fixed =
+      own?.state === 'unknown'
+        ? ({ cannot: 'unmeasured' } as const)
+        : own?.state === 'out' || own?.state === 'possible'
+          ? insideAlignmentOf(view, this.fasten.align, this.fasten.alignMm)
+          : ({ cannot: 'inside' } as const)
+    if ('cannot' in fixed) {
+      this.fixNote = i18next.t(`figure.text.fix-alignment-${fixed.cannot}`, { part: this.partId, on: target })
+      return
+    }
+    this.fixNote = ''
+    this.fasten = { ...this.fasten, align: fixed.align, alignMm: fixed.alignMm }
+    await this.onFastenRelease(true)
   }
 
   /** The fastening form, open on this part and in view: for "fasten it first" from elsewhere. */
@@ -600,7 +615,10 @@ export class FigureLinks extends localize(i18next)(LitElement) {
         ? html`<div overhang role="status">
             ${this.overhangWords.map(line => html`<p>${line}</p>`)}
             ${current
-              ? html`<button act @click=${() => this.showWhere()}><md-icon>tune</md-icon>${i18next.t('figure.button.fix-alignment')}</button>`
+              ? html`<button act fix-alignment ?disabled=${this.locked} @click=${() => this.fixAlignment(view, held ? f.target : '')}>
+                    <md-icon>tune</md-icon>${i18next.t('figure.button.fix-alignment')}
+                  </button>
+                  ${this.fixNote ? html`<p hint fix-note>${this.fixNote}</p>` : nothing}`
               : nothing}
           </div>`
         : nothing}

package/client/modeller/mesh-import.ts

@@ -38,16 +38,6 @@ export function meshChoicesOf(upload: MeshUpload): Array<{ node?: number; name:
   ]
 }
 
-/** A part id from a node's name: letter-led, letters, digits, `_` and `-`; another number when it is taken. */
-export function meshPartIdOf(name: string, taken: ReadonlySet<string>): string {
-  const cleaned = name.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^[^a-zA-Z]+/, '').replace(/-+$/, '')
-  const base = cleaned || 'mesh'
-  if (!taken.has(base)) return base
-  let n = 2
-  while (taken.has(`${base}-${n}`)) n++
-  return `${base}-${n}`
-}
-
 /**
  * The part: its bounds and counts as the server read them, its size the reach along its longest axis (so it is 1:1),
  * and -- for a node -- standing where the node stood in the file, so a crane taken apart node by node stands as it did.

package/client/modeller/modeller-keys.ts

@@ -0,0 +1,60 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit'
+import { keyActionOf, type KeyAction } from './keys.js'
+
+/** What the keys ask of the editor. */
+export interface ModellerKeysHost {
+  /** Whether the modeller takes keys now: a figure open, not loading or saving, and no section editor open. */
+  taking(): boolean
+  /** The scene, whose keys the modeller's are too. */
+  scene(): Element | null
+  selected(): string
+  act(action: KeyAction): void
+}
+
+/**
+ * The modeller's keys (`keys.ts`): undo, redo, duplicate, remove, back to the whole figure, the gizmo's modes. Heard on
+ * the window, first (capture), while the editor is on the page.
+ */
+export class ModellerKeys implements ReactiveController {
+  constructor(
+    host: ReactiveControllerHost,
+    private readonly of: ModellerKeysHost
+  ) {
+    host.addController(this)
+  }
+
+  hostConnected() {
+    window.addEventListener('keydown', this.onKey, true)
+  }
+
+  hostDisconnected() {
+    window.removeEventListener('keydown', this.onKey, true)
+  }
+
+  private onKey = (e: KeyboardEvent) => {
+    if (!this.of.taking()) return
+    const canvas = this.of.scene()
+    const path = e.composedPath()
+    const action = keyActionOf(
+      {
+        key: e.key,
+        ctrlKey: e.ctrlKey,
+        metaKey: e.metaKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        target: path[0] as HTMLElement,
+        inScene: !!canvas && path.includes(canvas)
+      },
+      this.of.selected()
+    )
+    if (!action) return
+    e.preventDefault()
+    /*
+      The session's history is the only one. With the canvas focused the scene took Ctrl+Z as well, undoing on its own
+      board the last value the canvas had written -- which the canvas then told as a drag: an undo of a drag on a
+      part placed by a rule wrote the drag again (2026-09-25). Heard first (capture) and kept from the scene.
+    */
+    e.stopPropagation()
+    this.of.act(action)
+  }
+}

package/client/modeller/pane-fold.ts

@@ -0,0 +1,61 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit'
+import { i18next } from '@operato/i18n'
+import type { OxThreePane } from '@operato/layout'
+import { notify } from '@operato/layout'
+
+/** Whether the narrow fold was said in this browser before; true from now on. Storage refused: said, as before. */
+function foldSaid(): boolean {
+  try {
+    if (localStorage.getItem('figure-fold-said')) return true
+    localStorage.setItem('figure-fold-said', '1')
+  } catch {
+    /* No storage here: said every time, as it was. */
+  }
+  return false
+}
+
+/*
+  Narrow, the parts list gives way to the canvas rather than all three shrinking (designer 2026-09-27, U11): under
+  FOLD_START_UNDER px the canvas would be left under about 560 px beside both sides. The fold is said once, and the
+  bar's own toggle opens it again; opened by the author, it is not folded again until the screen has been wide.
+  Said once in this browser, not on every opening (2026-10-02): the list folds as before, the notice does not come back.
+*/
+export class PaneFold implements ReactiveController {
+  static readonly FOLD_START_UNDER = 1100
+  private foldedForWidth = false
+  private keptOpenByAuthor = false
+  private widthWatch = new ResizeObserver(([entry]) => this.fitTo(entry!.contentRect.width))
+
+  /** `panes` is the frame the bar folds, once it is drawn. */
+  constructor(
+    private readonly host: ReactiveControllerHost & HTMLElement,
+    private readonly panes: () => OxThreePane | undefined
+  ) {
+    host.addController(this)
+  }
+
+  hostConnected() {
+    this.widthWatch.observe(this.host)
+  }
+
+  hostDisconnected() {
+    this.widthWatch.disconnect()
+  }
+
+  fitTo(width: number) {
+    const panes = this.panes()
+    if (!panes || !width) return
+    if (this.foldedForWidth && !panes.foldStart) this.keptOpenByAuthor = true
+    if (width < PaneFold.FOLD_START_UNDER) {
+      if (!panes.foldStart && !this.keptOpenByAuthor) {
+        panes.foldStart = true
+        this.foldedForWidth = true
+        if (!foldSaid()) notify({ level: 'info', message: i18next.t('figure.text.parts-panel-folded-narrow') })
+      }
+    } else {
+      if (this.foldedForWidth && panes.foldStart) panes.foldStart = false
+      this.foldedForWidth = false
+      this.keptOpenByAuthor = false
+    }
+  }
+}

package/client/modeller/panel-memory.ts

@@ -0,0 +1,53 @@
+/*
+  Per model and per part, how far its properties panel was scrolled and which of its folds were open, so going back
+  to one finds it as it was left (designer 2026-09-27, B.1). The path stays held at the top, so a scroll kept cannot
+  hide which part the panel speaks of. Another model starts clean.
+*/
+export class PanelMemory {
+  private kept = new Map<string, { top: number; open: boolean[] }>()
+  private restoreFor?: string
+
+  /** `root` is where the properties panel is drawn: the editor's render root. */
+  constructor(private readonly root: () => ParentNode) {}
+
+  private panel() {
+    return this.root().querySelector<HTMLElement>('div[panel]')
+  }
+
+  private foldsOf(panel: HTMLElement): HTMLDetailsElement[] {
+    const folds = [...panel.querySelectorAll('details')]
+    for (const inner of panel.querySelectorAll('figure-links')) folds.push(...(inner.shadowRoot?.querySelectorAll('details') ?? []))
+    return folds
+  }
+
+  /** Another model: nothing kept. */
+  clear() {
+    this.kept.clear()
+  }
+
+  /** The selection moves from `was` to `now` ('' is the model): the panel as `was` left it is kept, `now`'s put back after the update. */
+  leave(was: string, now: string) {
+    const panel = this.panel()
+    if (panel) this.kept.set(was || '@model', { top: panel.scrollTop, open: this.foldsOf(panel).map(d => d.open) })
+    this.restoreFor = now || '@model'
+  }
+
+  /** After the update: the panel of the part chosen as it was left, while that part is still the one chosen. */
+  restore(selected: () => string) {
+    if (this.restoreFor === undefined) return
+    const key = this.restoreFor
+    this.restoreFor = undefined
+    /*
+      Put back as soon as the links have drawn, before any click can come: the updates are microtasks. Put back a
+      frame later, it closed a fold opened by a click in that frame (2026-10-11, the row on a bench under load).
+    */
+    const panel = this.panel()
+    if (panel)
+      void Promise.all([...panel.querySelectorAll<HTMLElement & { updateComplete?: Promise<unknown> }>('figure-links')].map(el => el.updateComplete)).then(() => {
+        if ((selected() || '@model') !== key) return
+        const kept = this.kept.get(key)
+        if (kept) this.foldsOf(panel).forEach((fold, i) => i < kept.open.length && (fold.open = kept.open[i]!))
+        panel.scrollTop = kept?.top ?? 0
+      })
+  }
+}

package/client/modeller/refusal-teller.ts

@@ -0,0 +1,93 @@
+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 { 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
+ * other refusal is the app's notification, which stays until it is closed.
+ */
+export class RefusalTeller {
+  private toldViewError = ''
+
+  constructor(private readonly of: RefusalHost) {}
+
+  /** 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 })
+    }
+    const notice = this.of.notice()
+    if (changed.has('notice') && notice) notify({ level: 'info', message: notice })
+    const viewError = this.of.session()?.read()?.error ?? ''
+    if (viewError && viewError !== this.toldViewError) notify({ level: 'error', message: viewError })
+    this.toldViewError = viewError
+  }
+
+  /*
+    An edit that would stop clips is refused by figure-model with the clips named (CLIPS_DROPPED). The person is told
+    which, and why, before anything is written; agreed, the same edit is made again letting exactly those go, as one
+    step undo brings back (designer 2026-09-27).
+  */
+  askClipLoss(error: unknown, again: () => void): boolean {
+    const clips = clipLossOf(error)
+    if (!clips) return false
+    /* The consent is for this edit, on this figure as it is now: held with it while the person reads. */
+    const session = this.of.session()!
+    const { context, revision } = session.read()
+    void this.confirmClipLoss(clips, again, { session, context: context!, revision: revision! })
+    return true
+  }
+
+  private async confirmClipLoss(clips: FigureClipLoss[], again: () => void, asked: { session: FigureProductSession; context: string; revision: number }) {
+    const agreed = await OxPrompt.open({
+      type: 'warning',
+      text: i18next.t('figure.text.clips-would-go', { clips: clips.map(c => i18next.t(`figure.text.clip-${c.why}`, { clip: c.clip })).join(', ') }),
+      confirmButton: { text: i18next.t('figure.button.let-clips-go') },
+      cancelButton: { text: i18next.t('figure.button.keep-editing') }
+    })
+    if (!agreed) return
+    /* Changed while the person read -- another figure, or an edit in between: the consent was not for this; nothing is applied. */
+    const now = this.of.session() === asked.session ? asked.session.read() : undefined
+    if (!now || now.context !== asked.context || now.revision !== asked.revision) {
+      this.of.refuse(i18next.t('figure.text.clips-consent-stale'))
+      return
+    }
+    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 FigureRefusalDetails } from '@hatiolab/figure-model'
+import { FIGURE_INSTANCE_SIZE_INPUTS, type FigureClipLoss, type FigureRefusalDetails } from '@hatiolab/figure-model'
 
 type Say = (key: string, params: Record<string, string>) => string
 type Reason = FigureRefusalDetails['reason']
@@ -70,6 +70,23 @@ export function placementRefusalOf(error: unknown, say: Say): string | null {
   })
 }
 
+/** A refusal carried on in a record (an AI proposal's outcome) in figure-model's own shape: its code and details. */
+export interface FigureRefusalRecord {
+  code?: string
+  details?: FigureRefusalDetails
+}
+
+/** The record of a refusal: figure-model's code and details, copied as they are. */
+export function refusalRecordOf(error: unknown): FigureRefusalRecord {
+  const { details } = (error ?? {}) as FigureRefusalRecord
+  return { code: codeOf(error), ...(details ? { details } : {}) }
+}
+
+/** The clips an edit would stop, as figure-model named them (CLIPS_DROPPED) -- the person is asked before any go; nothing for any other refusal. */
+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')
@@ -101,6 +118,9 @@ export function placedRefusalOf(error: unknown, part: string, say: Say): string
 
 /** A part name refused: not a name, already used, or another part is named under the part. The rule is the kernel's. */
 export function partNameRefusalOf(error: unknown, say: Say): string | null {
+  /* A new part named as one already is: the same sentence as a part renamed so. */
+  const takenId = detailsOf(error, 'part-id-taken')
+  if (takenId) return say('figure.text.part-name-taken', { name: takenId.part })
   if (codeOf(error) !== 'PART_ID') return null
   const invalid = detailsOf(error, 'name-invalid')
   if (invalid) return say('figure.text.part-name-invalid', { name: invalid.name })
@@ -236,7 +256,8 @@ export function inputRangeRefusalOf(error: unknown, say: Say): string | null {
 
 /**
  * A row past its limits: a pitch so fine it would hold more copies than a row takes, a row that would expand to more
- * bodies than a figure draws, or a number of copies outside what a row may have.
+ * bodies than a figure draws, a number of copies outside what a row may have or more than its length holds apart, a
+ * row inside a row along the same axis, or a part whose face something holds made into a row.
  */
 export function rowLimitRefusalOf(error: unknown, say: Say): string | null {
   const copies = detailsOf(error, 'copies-over-limit')
@@ -245,9 +266,18 @@ export function rowLimitRefusalOf(error: unknown, say: Say): string | null {
   if (bodies) return say('figure.text.row-geometry-over-limit', { count: bodies.count.toLocaleString(), limit: bodies.limit.toLocaleString() })
   const count = detailsOf(error, 'row-copies-out-of-range')
   if (count) return say('figure.text.row-copies-out-of-range', { count: count.count.toLocaleString(), min: String(count.min), max: String(count.max) })
+  const fit = detailsOf(error, 'row-does-not-fit')
+  if (fit) return say('figure.text.row-does-not-fit', { count: fit.count.toLocaleString(), length: mmOf(fit.length), extent: mmOf(fit.extent) })
+  const axis = detailsOf(error, 'row-same-axis')
+  if (axis) return say('figure.text.row-same-axis', { part: axis.part, outer: axis.outer, axis: axis.axis.toUpperCase() })
+  const held = detailsOf(error, 'surface-on-row')
+  if (held) return say(`figure.text.row-face-held-${heldByOf(held.at)}`, { part: held.part })
   return null
 }
 
+/* What holds a face, from the contract path the kernel names it by: the slot layout, a place, the footprint. */
+const heldByOf = (at: string) => (at.startsWith('slotLayout') ? 'slot-layout' : at.startsWith('bindings') ? 'place' : at.startsWith('occupancy') ? 'footprint' : 'other')
+
 /** A row's pitch under which the figure, at the length it is authored, would hold more copies than a row takes. */
 export function repeatPitchRefusalOf(error: unknown, say: Say): string | null {
   if (codeOf(error) !== 'INPUT_RANGE') return null

package/dist-client/modeller/ai-proposal.d.ts

@@ -1,5 +1,6 @@
 import type { FigureProposalStep } from '@hatiolab/figure-model';
 import type { FigureProductSession } from './product-session.js';
+import { type FigureRefusalRecord } from './refusals.js';
 /** What the card carries, as `proposeFigureCandidate` returned it. */
 export interface FigureProposalCard {
     /** The proposal's own name, given by the tool: a save records it, a new figure made from it is created under it. */
@@ -10,8 +11,11 @@ export interface FigureProposalCard {
     context?: string;
     revision?: number;
 }
-/** The `figure-apply` event's detail. The page that takes it sets `applied`, and `error` when refused. */
-export interface FigureApplyDetail {
+/**
+ * The `figure-apply` event's detail. The page that takes it sets `applied`, and when refused `error` and the refusal in
+ * figure-model's shape (`code`, `details`, the `clips` it would stop).
+ */
+export interface FigureApplyDetail extends FigureRefusalRecord {
     key?: string;
     steps: FigureProposalStep[];
     create: boolean;
@@ -19,9 +23,6 @@ export interface FigureApplyDetail {
     revision?: number;
     applied?: boolean;
     error?: string;
-    code?: string;
-    /** The clips a refused proposal would have stopped (CLIPS_DROPPED), by name. */
-    clips?: string[];
 }
 export type Say = (key: string, params?: Record<string, string>) => string;
 export interface FigureProposalTarget {

package/dist-client/modeller/ai-proposal.js

@@ -1,3 +1,4 @@
+import { clipLossOf, refusalRecordOf } from './refusals.js';
 /**
  * The dock's "check the result" (ADR-0097 §5.6 item 5): what the server recorded of a proposal. Saved into figures:
  * accepted, named. Nothing recorded: not known -- applied and not saved yet, undone, or never taken -- so `undefined`,
@@ -11,7 +12,9 @@ export function proposalOutcomeFrom(saved, say) {
 }
 /** The workspace refuses a request made on another version; said as what happened, not as the kernel's code. */
 const STALE = new Set(['REVISION_CONFLICT', 'CONTEXT_CONFLICT']);
-function refused(code, error, say, clips) {
+function refused(refusal, say) {
+    const { code, error } = refusal;
+    const clips = clipLossOf(refusal);
     /*
       A proposal that would stop clips is refused whole; nobody but the person may agree to that, and a proposal is not
       asked about -- the person edits by hand if they mean it (designer 2026-09-27).
@@ -20,8 +23,8 @@ function refused(code, error, say, clips) {
         ? say('figure.text.proposal-stale')
         : code === 'NEW_FIGURE_UNSAVED'
             ? (error ?? '')
-            : code === 'CLIPS_DROPPED'
-                ? say('figure.text.proposal-would-drop-clips', { clips: (clips ?? []).join(', ') })
+            : clips
+                ? say('figure.text.proposal-would-drop-clips', { clips: clips.map(c => c.clip).join(', ') })
                 : say('figure.text.proposal-refused', { reason: error ?? '' });
     return { verdict: 'refused', errorCode: code ?? 'refused', note };
 }
@@ -58,11 +61,8 @@ export function takeFigureOffer(session, detail, { onSavedFigure, say }) {
     }
     catch (error) {
         detail.applied = false;
-        detail.code = error?.code;
+        Object.assign(detail, refusalRecordOf(error));
         detail.error = error instanceof Error ? error.message : String(error);
-        const clips = error?.clips;
-        if (clips)
-            detail.clips = clips.map(c => c.clip);
         return false;
     }
 }
@@ -80,7 +80,7 @@ export async function runFigureProposal(card, target, say) {
     if (detail.applied)
         return accepted();
     if (detail.applied === false)
-        return refused(detail.code, detail.error, say, detail.clips);
+        return refused(detail, say);
     /* A revision belongs to the figure the model saw; with that modeller gone there is nowhere true to apply it. */
     if (!create)
         return { verdict: 'unavailable', errorCode: 'modeller-not-open', note: say('figure.text.proposal-needs-modeller') };
@@ -89,7 +89,7 @@ export async function runFigureProposal(card, target, say) {
         return accepted();
     return opened.code === 'not-opened'
         ? { verdict: 'unavailable', errorCode: 'not-opened', note: say('figure.text.proposal-not-opened') }
-        : refused(opened.code, opened.error, say);
+        : refused(opened, say);
 }
 /*
   A new figure's proposal handed to the modeller page across a navigation: the handler leaves it here and opens the