@things-factory/figure-ui 10.1.147 → 10.1.149

package/client/modeller/refusals.ts

@@ -1,31 +1,40 @@
 /*
- * A command refused because the figure could not be drawn at an end of its declared size range, in the author's words
- * with the numbers and where to put it right -- not the kernel's English (user, 2026-09-24: 「what is this warning
- * message means?」). Kept apart from the element so it is tested without a browser.
+ * A command figure-model refused, in the author's words with the numbers and where to put it right -- not the kernel's
+ * English (user, 2026-09-24: 「what is this warning message means?」). Kept apart from the element so it is tested
+ * without a browser.
+ *
+ * Every sentence here is made from the refusal's `code` and `details` (ADR-0127), never from its message: the kernel's
+ * 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'
 
 type Say = (key: string, params: Record<string, string>) => string
+type Reason = FigureRefusalDetails['reason']
 
-/** The refusal in words, or nothing for any other refusal. */
+const codeOf = (error: unknown) => (error as { code?: string } | null | undefined)?.code
+/** The refusal's details when they are of this reason, or nothing. */
+function detailsOf<R extends Reason>(error: unknown, reason: R): Extract<FigureRefusalDetails, { reason: R }> | undefined {
+  const details = (error as { details?: FigureRefusalDetails } | null | undefined)?.details
+  return details?.reason === reason ? (details as Extract<FigureRefusalDetails, { reason: R }>) : undefined
+}
+const mmOf = (mm: number) => mm.toLocaleString(undefined, { maximumFractionDigits: 1 })
+const numberOf = (value: number) => value.toLocaleString(undefined, { maximumFractionDigits: 3 })
+/** 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. */
 export function sizeRangeRefusalOf(error: unknown, say: Say): string | null {
-  if ((error as { code?: string })?.code !== 'INSTANCE_SIZE_RANGE') return null
-  const message = error instanceof Error ? error.message : String(error)
-  const mmOf = (raw: string) => Number(raw).toLocaleString(undefined, { maximumFractionDigits: 1 })
-  const found = /size\.([xyz]):\s*(below|above) ([\d.]+) mm [^(;]*(?:\(([^)]+)\))?;/.exec(message)
-  if (found) {
-    const [, axis, side, mm, part] = found
-    return say(side === 'below' ? 'figure.text.size-range-too-small' : 'figure.text.size-range-too-large', { axis: axis!.toUpperCase(), mm: mmOf(mm!), part: part ?? '' })
-  }
-  /* The kernel's other sentences under this code: a range that leaves out the size the figure is drawn at, a smallest size of zero, a part already gone at that size. */
-  const outside = /size\.([xyz]):\s*the authored size ([\d.]+) mm must lie within ([\d.]+)…([\d.]+) mm/.exec(message)
-  if (outside) {
-    const [, axis, at, min, max] = outside
-    return say('figure.text.size-range-leaves-out-size', { axis: axis!.toUpperCase(), at: mmOf(at!), min: mmOf(min!), max: mmOf(max!) })
-  }
-  const zero = /size\.([xyz]):\s*the smallest size must be above zero/.exec(message)
-  if (zero) return say('figure.text.size-range-from-zero', { axis: zero[1]!.toUpperCase() })
-  const gone = /size\.([xyz]):\s*the figure is authored at ([\d.]+) mm, where a length is already gone/.exec(message)
-  if (gone) return say('figure.text.size-range-part-gone', { axis: gone[1]!.toUpperCase(), at: mmOf(gone[2]!) })
+  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) })
+  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) })
   return null
 }
 
@@ -34,16 +43,14 @@ export function sizeRangeRefusalOf(error: unknown, say: Say): string | null {
  * 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' || (error as { code?: string })?.code !== 'INSTANCE_SIZE_RANGE') return null
-  const message = error instanceof Error ? error.message : String(error)
-  const found = /size\.([xyz]):\s*(below|above) ([\d.]+) mm [^(;]*(?:\(([^)]+)\))?;/.exec(message)
-  if (!found) return null
-  const [, axis, side, raw, part] = found
-  const mm = Number(raw).toLocaleString(undefined, { maximumFractionDigits: 1 })
-  const words = { axis: axis!.toUpperCase(), mm, part: part ?? '' }
+  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(side === 'below' ? 'figure.text.link-needs-smaller-range' : 'figure.text.link-needs-larger-range', words),
-    label: say(side === 'below' ? 'figure.button.narrow-range-from' : 'figure.button.narrow-range-to', words),
+    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 }
   }
 }
@@ -53,16 +60,19 @@ export function narrowingRetryOf<A extends { kind: string }>(action: A, error: u
  * on the floor, when the figure is to hang on a wall), said in the author's words with the parts it names.
  */
 export function placementRefusalOf(error: unknown, say: Say): string | null {
-  if ((error as { code?: string })?.code !== 'PLACEMENT_PLANE') return null
-  const message = error instanceof Error ? error.message : String(error)
-  const found = /: (.+?) (?:is|are) fastened to the mounting plane by a face an? (\w+) does not take \(([^)]+)\)/.exec(message)
-  if (!found) return null
-  return say('figure.text.placement-plane-refused', { parts: found[1]!, placement: say('figure.label.placement-' + found[2]!, {}), faces: found[3]! })
+  if (codeOf(error) !== 'PLACEMENT_PLANE') return null
+  const misfit = detailsOf(error, 'placement-face')
+  if (!misfit) return null
+  return say('figure.text.placement-plane-refused', {
+    parts: misfit.parts.map(p => `${p.part} (${p.face})`).join(', '),
+    placement: say('figure.label.placement-' + misfit.placement, {}),
+    faces: misfit.takes.join(', ')
+  })
 }
 
 /** 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 (error as { code?: string })?.code === 'PART_REFERENCED' && /is in the space the figure declares/.test(error instanceof Error ? error.message : String(error))
+  return codeOf(error) === 'PART_REFERENCED' && !!detailsOf(error, 'in-declared-space')
 }
 
 /**
@@ -71,18 +81,36 @@ export function inDeclaredRoom(error: unknown): boolean {
  * 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.
  */
 export function partRefusalOf(error: unknown, part: string, say: Say): string | null {
-  const code = (error as { code?: string })?.code
+  const code = codeOf(error)
   if (code !== 'PART_REFERENCED' && code !== 'PART_ROW') return null
-  /* figure-model's sentence after its code and path: 「PART_ROW: bed: roller is a row laid along bed; …」. */
-  const message = (error instanceof Error ? error.message : String(error)).replace(/^[A-Z_]+: [^:]+: /, '')
-  if (/is in the space the figure declares/.test(message)) return say('figure.text.part-in-declared-space', { part })
-  const along = /^(.+?) (?:is a row|are rows) laid along /.exec(message)
-  if (along) return say('figure.text.part-row-along', { part, rows: along[1]! })
-  const carried = /^(.+?) hangs? in the row /.exec(message)
-  if (carried) return say('figure.text.part-row-carries', { part, others: carried[1]! })
+  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')
+  if (carried) return say('figure.text.part-row-carries', { part, others: carried.parts.join(', ') })
   return say('figure.text.part-is-referenced', { part })
 }
 
+/** A part the gizmo cannot move because a joint or a fastening places it, named as the author knows it (`part`). */
+export function placedRefusalOf(error: unknown, part: string, say: Say): string | null {
+  if (codeOf(error) !== 'EDIT_TARGET') return null
+  if (detailsOf(error, 'placed-by-joint')) return say('figure.text.gizmo-joint-places', { part })
+  if (detailsOf(error, 'placed-by-fastening')) return say('figure.text.gizmo-fastening-places', { part })
+  return null
+}
+
+/** 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 {
+  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 })
+  const taken = detailsOf(error, 'name-taken')
+  if (taken) return say('figure.text.part-name-taken', { name: taken.name })
+  const nested = detailsOf(error, 'name-has-nested')
+  if (nested) return say('figure.text.part-name-has-nested', { nested: nested.nested })
+  return null
+}
+
 /** What removing a part let go of (figure-model's `RemovalNotice`), said in one line, or nothing when it let go of nothing. */
 export function removalNoticeOf(
   notice:
@@ -97,12 +125,11 @@ export function removalNoticeOf(
   say: Say
 ): string | null {
   if (!notice) return null
-  const number = (v: number) => v.toLocaleString(undefined, { maximumFractionDigits: 3 })
   const lines: string[] = []
   const still = notice.released.filter(r => !r.control).map(r => r.part)
   if (still.length) lines.push(say('figure.text.removal-released', { parts: still.join(', ') }))
   for (const r of notice.released.filter(r => r.control)) lines.push(say('figure.text.removal-released-motion', { part: r.part, control: r.control! }))
-  for (const c of notice.controls) lines.push(say('figure.text.removal-own-control', { part: c.part, control: c.control, min: number(c.min), max: number(c.max) }))
+  for (const c of notice.controls) lines.push(say('figure.text.removal-own-control', { part: c.part, control: c.control, min: numberOf(c.min), max: numberOf(c.max) }))
   const fixed = [...new Set(notice.fixed.map(f => f.part))]
   if (fixed.length) lines.push(say('figure.text.removal-fixed', { parts: fixed.join(', ') }))
   if (notice.bindings?.length) lines.push(say('figure.text.removal-bindings', { places: notice.bindings.map(b => b.label ?? b.id).join(', ') }))
@@ -112,64 +139,123 @@ export function removalNoticeOf(
 
 /**
  * A recipe refused at one of its steps: which step, and why -- the particular sentence when there is one (a size
- * range, a value's range, a placement), otherwise the kernel's code. The kernel says 「steps[2]: attach: …」.
+ * range, a value's range, a placement), otherwise the kernel's code. The step is the refusal's path, `steps[2]`: the
+ * contract's path grammar, not its English (ADR-0127 decision 6).
  */
 export function recipeRefusalOf(error: unknown, say: Say): string | null {
   const step = /^steps\[(\d+)\]$/.exec((error as { path?: string })?.path ?? '')
   if (!step) return null
   const why = sizeRangeRefusalOf(error, say) ?? inputRangeRefusalOf(error, say) ?? placementRefusalOf(error, say)
-  return say('figure.text.recipe-step-refused', { step: String(Number(step[1]) + 1), why: why ?? '', code: (error as { code?: string })?.code ?? '' })
+  return say('figure.text.recipe-step-refused', { step: String(Number(step[1]) + 1), why: why ?? '', code: codeOf(error) ?? '' })
 }
 
 /**
- * A refusal no sentence above knows, said as a refusal with its code -- never the kernel's English on the screen (the
- * duplicate of a row's part showed 「EDIT_TARGET: … not a repeated template」, 2026-09-27). The figure's node limit
- * is said with its number.
+ * A corner or an inside the part cannot take (ADR-0100 stage 1): what was too large or too thick, or what holds on
+ * to what the edit would take away.
  */
+function sectionRefusalOf(error: unknown, say: Say): string | null {
+  const mapping = detailsOf(error, 'faces-taken-away')
+  if (mapping) return say('figure.text.section-face-in-use', { faces: mapping.lost.map(l => say('figure.label.face-' + l.face, {})).join(', ') })
+  if (codeOf(error) === 'DIMENSION_LINKED') return say('figure.text.section-dimension-linked', {})
+  if (detailsOf(error, 'section-invalid')?.issues.some(i => i.code === 'CORNER_TOO_LARGE')) return say('figure.text.section-corner-too-large', {})
+  const inside = detailsOf(error, 'inside-invalid')?.refusal
+  if (inside?.code === 'CAVITY' && inside.refused === 'NO_ROOM_INSIDE') return say('figure.text.section-wall-too-thick', {})
+  if (inside?.code === 'CAVITY_NO_LENGTH') return say('figure.text.section-ends-too-thick', {})
+  return null
+}
+
 /**
- * A corner or an inside the part cannot take (ADR-0100 stage 1): what was too large or too thick, or what holds on
- * to what the edit would take away. The kernel names the problem in its message; the screen names it in words.
+ * A slot layout refused (ADR-0118): the anchor, slot or value it was refused for. The layout's own findings are named
+ * by where they are; the editor checks them before Apply, so they rarely reach here.
  */
-function sectionRefusalOf(code: string | undefined, message: string, say: Say): string | null {
-  if (code === 'FEATURE_MAPPING_REQUIRED') {
-    /* 「takes away inside-bottom (joint j1); top (feature f2)」: the faces, each in the author's words. */
-    const faces = [...message.matchAll(/([\w-]+) \([^)]*\)/g)].map(([, face]) => say('figure.label.face-' + face, {}))
-    return say('figure.text.section-face-in-use', { faces: faces.join(', ') })
-  }
-  if (code === 'DIMENSION_LINKED') return say('figure.text.section-dimension-linked', {})
-  if (code !== 'GEOMETRY_DOMAIN') return null
-  if (/CORNER_TOO_LARGE/.test(message)) return say('figure.text.section-corner-too-large', {})
-  if (/NO_ROOM_INSIDE/.test(message)) return say('figure.text.section-wall-too-thick', {})
-  if (/CAVITY_NO_LENGTH/.test(message)) return say('figure.text.section-ends-too-thick', {})
+export function slotLayoutRefusalOf(error: unknown, say: Say): string | null {
+  if (detailsOf(error, 'slot-layout-label-missing')) return say('figure.text.slot-layout-label-missing', {})
+  if (detailsOf(error, 'slot-anchors-missing')) return say('figure.text.slot-anchors-missing', {})
+  const twice = detailsOf(error, 'slot-anchor-duplicate')
+  if (twice) return say('figure.text.slot-anchor-duplicate', { anchor: twice.anchor })
+  const flat = detailsOf(error, 'slot-anchor-not-flat')
+  if (flat) return say('figure.text.slot-anchor-not-flat', { anchor: flat.anchor, part: flat.part })
+  const gone = detailsOf(error, 'slot-anchor-no-part')
+  if (gone) return say('figure.text.slot-anchor-no-part', { anchor: gone.anchor, part: gone.part })
+  const issues = detailsOf(error, 'slot-layout-issues')
+  if (issues) return say('figure.text.slot-layout-issues', { path: issues.issues[0]?.path ?? '' })
+  const empty = detailsOf(error, 'slot-accepts-empty')
+  if (empty) return say('figure.text.slot-accepts-empty', { slot: empty.slot })
+  const taken = detailsOf(error, 'slot-id-taken')
+  if (taken) return say('figure.text.slot-id-taken', { slot: taken.slot })
   return null
 }
 
+/** The figure's limits: its nodes, its size saved, how deep it nests. */
+function documentLimitRefusalOf(error: unknown, say: Say): string | null {
+  if (codeOf(error) !== 'DOCUMENT_LIMIT') return null
+  const nodes = detailsOf(error, 'node-limit')
+  if (nodes) return say('figure.text.edit-refused-node-limit', { max: String(nodes.max) })
+  const large = detailsOf(error, 'document-too-large')
+  if (large)
+    return large.at === undefined
+      ? say('figure.text.document-too-large-unmeasured', { max: kibOf(large.max) })
+      : say('figure.text.document-too-large', { max: kibOf(large.max), at: kibOf(large.at) })
+  const deep = detailsOf(error, 'nesting-too-deep')
+  if (deep) return say('figure.text.document-nesting-too-deep', { max: String(deep.max), at: String(deep.at) })
+  return null
+}
+
+/**
+ * A refusal in the author's words when the screen has words for it, otherwise said as a refusal with its code -- never
+ * the kernel's English on the screen (the duplicate of a row's part showed 「EDIT_TARGET: … not a repeated template」,
+ * 2026-09-27).
+ */
 export function editRefusalOf(error: unknown, say: Say): string {
-  const code = (error as { code?: string })?.code
-  const message = error instanceof Error ? error.message : String(error)
-  if (code === 'DOCUMENT_LIMIT') return say('figure.text.edit-refused-node-limit', { max: /maximum (\d+) nodes/.exec(message)?.[1] ?? '' })
-  const section = sectionRefusalOf(code, message, say)
-  if (section) return section
-  return say('figure.text.edit-refused', { code: code ?? '' })
+  return (
+    sizeRangeRefusalOf(error, say) ??
+    inputRangeRefusalOf(error, say) ??
+    repeatPitchRefusalOf(error, say) ??
+    rowLimitRefusalOf(error, say) ??
+    placementRefusalOf(error, say) ??
+    partNameRefusalOf(error, say) ??
+    documentLimitRefusalOf(error, say) ??
+    sectionRefusalOf(error, say) ??
+    slotLayoutRefusalOf(error, say) ??
+    say('figure.text.edit-refused', { code: codeOf(error) ?? '' })
+  )
 }
 
 /**
- * A value outside the range its input declares, with the range and the value given -- the kernel says
- * 「size.x: 6021100 outside [300,1200]」. The figure's own size is named by its axis; any other input by its range only.
- * The repeat pitch's refusal shares the code and has its own words (`figure.text.repeat-pitch-too-small`).
+ * A value outside the range its input declares, with the range and the value given. The figure's own size is named by
+ * its axis; any other input by its range only.
  */
 export function inputRangeRefusalOf(error: unknown, say: Say): string | null {
-  if ((error as { code?: string })?.code !== 'INPUT_RANGE') return null
-  const message = error instanceof Error ? error.message : String(error)
-  const found = /([\w.-]+): (-?[\d.e+]+) outside \[(-?[\d.e+]+),\s*(-?[\d.e+]+)\]/.exec(message)
-  if (!found) return null
-  const [, input, value, min, max] = found
-  const number = (text: string) => Number(text).toLocaleString(undefined, { maximumFractionDigits: 3 })
-  const axis = /^size\.([xyz])$/.exec(input!)?.[1]
-  const params = { value: number(value!), min: number(min!), max: number(max!) }
+  if (codeOf(error) !== 'INPUT_RANGE') return 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) }
   return axis ? say('figure.text.input-range-size', { ...params, axis: axis.toUpperCase() }) : say('figure.text.input-range', params)
 }
 
+/**
+ * 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.
+ */
+export function rowLimitRefusalOf(error: unknown, say: Say): string | null {
+  const copies = detailsOf(error, 'copies-over-limit')
+  if (copies) return say('figure.text.row-copies-over-limit', { count: copies.count.toLocaleString(), limit: copies.limit.toLocaleString() })
+  const bodies = detailsOf(error, 'geometry-over-limit')
+  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) })
+  return null
+}
+
+/** 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
+  const pitch = detailsOf(error, 'pitch-too-many-copies')
+  if (!pitch) return null
+  return say('figure.text.repeat-pitch-too-small', { length: pitch.length.toLocaleString(), min: String(pitch.least), limit: String(pitch.limit) })
+}
+
 /**
  * Why "follow the size and keep where the figure is placed" was not applied, in the author's words (ADR-0097): the plan
  * says what it would have had to overwrite, and for a part through the plane how far. A code the screen has no words

package/client/modeller/section-controls.ts

@@ -1,5 +1,5 @@
 import { FIGURE_SECTION_PLANE, checkFigureSection, figureExtrusionFeaturesOf } from '@hatiolab/figure-model'
-import type { FigureCavityRequest, FigureEvaluatedShape } from '@hatiolab/figure-model'
+import type { FigureAuthoringAction, FigureCavityRequest, FigureEvaluatedShape } from '@hatiolab/figure-model'
 
 /*
  * What the 단면 section of the properties tab reads and asks (ADR-0100 §3.3): a pushed part's corners and its inside.
@@ -62,6 +62,9 @@ export function cornerLimitOf(shape: FigureEvaluatedShape): number | undefined {
   return maxes.length ? Math.min(...maxes) : undefined
 }
 
+/** A corner radius as the one command: 0 takes the rounding away. */
+export const cornerActionOf = (part: string, radius: number): FigureAuthoringAction => ({ kind: 'set-section-corner', part, corner: radius > 0 ? radius : null })
+
 /** Whether a corner radius can be taken; if not, the most it can be. */
 export function cornerRefusalOf(shape: FigureEvaluatedShape, radius: number): { max: number } | null {
   const e = shape.extrusion
@@ -100,6 +103,27 @@ export function cavityRefusalOf(shape: FigureEvaluatedShape, request: FigureCavi
   return { code: 'not-positive' }
 }
 
+/**
+ * What the kernel would refuse of an inside, as words: an i18n key and its values; null when it would take it. For one
+ * side's wall with the walls one per side, the most is that side's with the opposite kept, not the kernel's all-round one.
+ */
+export function cavityRefusalWordsOf(
+  shape: FigureEvaluatedShape,
+  request: { wall: Record<string, number>; start: FigureCavityRequest['start']; end: FigureCavityRequest['end'] },
+  perSide: boolean,
+  side?: string
+): { key: string; params: Record<string, string> } | null {
+  const ask = cavityRefusalOf(shape, { wall: { ...request.wall }, start: request.start, end: request.end })
+  if (!ask) return null
+  if (ask.code === 'wall-too-thick')
+    return { key: 'figure.text.section-wall-over', params: { max: String(perSide && side ? mm(sideWallLimitOf(shape, request.wall, side)) : ask.max) } }
+  if (ask.code === 'ends-too-thick') return { key: 'figure.text.section-ends-over', params: { max: String(ask.max) } }
+  return { key: 'figure.text.section-not-positive', params: {} }
+}
+
+/** Whether a part can have an inside: a pushed rectangle or ellipse (a drawn section's is a later stage). */
+export const hollowableOf = (shape: FigureEvaluatedShape) => shape.extrusion?.section.kind === 'rectangle' || shape.extrusion?.section.kind === 'ellipse'
+
 /** What the inside makes of the part (§3.3): open at both ends a pipe, at one a container, at neither a closed space. */
 export function cavityResultOf(cavity: NonNullable<FigureEvaluatedShape['cavity']>): 'pipe' | 'container' | 'sealed' {
   const open = [cavity.start, cavity.end].filter(e => e === 'open').length

package/client/modeller/section-drawing.ts

@@ -1,5 +1,6 @@
 import { FIGURE_SECTION_PLANE, FIGURE_SECTION_POINT_LIMIT, checkFigureSection, figureExtrusionFeaturesOf, figureSectionSidesOf } from '@hatiolab/figure-model'
-import type { FigureCavityRequest, FigureEvaluatedShape, FigureSection, FigureSectionIssue, FigureSectionPoint } from '@hatiolab/figure-model'
+import type { FigureAuthoringAction, FigureCavityRequest, FigureEvaluatedShape, FigureSection, FigureSectionIssue, FigureSectionMeasure, FigureSectionPoint } from '@hatiolab/figure-model'
+import { END_FACE } from './section-controls.js'
 
 /*
  * What the section editor does to a drawn section's points, and how it says what is wrong with them (ADR-0100 §3.2).
@@ -191,3 +192,44 @@ export function workingIssuesOf(
   }
   return { issues, words }
 }
+
+/** The inside said so two can be compared: its walls by side, its ends. */
+export const cavityKeyOf = (w: SectionWorking) => (w.cavity ? [Object.entries(w.cavity.wall).sort(), w.cavity.start, w.cavity.end] : null)
+
+/**
+ * The one command for everything changed since the editor opened: a drawn section's points always, and of the rest only
+ * what changed -- a measure left alone may follow another value and must not be written; an apex taken away is null
+ * (back to a push), an inside taken away is null.
+ */
+export function sectionActionOf(part: string, kind: FigureSection['kind'] | undefined, opened: SectionWorking, w: SectionWorking): FigureAuthoringAction {
+  const changed = (a: number | undefined, b: number | undefined) => Math.abs((a ?? 0) - (b ?? 0)) > 1e-9
+  const across = Object.fromEntries(Object.entries(w.across).filter(([k, v]) => changed(v, opened.across[k as Axis])))
+  const apexMoved = !w.apex !== !opened.apex || (!!w.apex && Object.entries(w.apex).some(([k, v]) => changed(v, opened.apex![k as Axis])))
+  const cavityMoved = JSON.stringify(cavityKeyOf(w)) !== JSON.stringify(cavityKeyOf(opened))
+  return {
+    kind: 'set-section',
+    part,
+    ...(kind === 'polygon' ? { points: w.points.map(p => ({ ...p })) } : {}),
+    ...(Object.keys(across).length ? { across } : {}),
+    ...(changed(w.length, opened.length) ? { length: w.length } : {}),
+    ...(apexMoved ? { apex: w.apex ? { ...w.apex } : null } : {}),
+    ...(cavityMoved ? { cavity: w.cavity ? { wall: { ...w.cavity.wall }, start: w.cavity.start, end: w.cavity.end } : null } : {})
+  }
+}
+
+/**
+ * What a measure's field says under it: that it follows another value, or -- given where along the push a length
+ * change keeps the part (1 its start, -1 its end, 0 its centre) -- the face it keeps; null when there is nothing to say.
+ */
+export function measureNoteOf(measure: FigureSectionMeasure | undefined, kept: -1 | 0 | 1 | undefined, axis: Axis): { key: string; face?: string } | null {
+  if (measure === 'linked') return { key: 'figure.text.section-editor-linked' }
+  if (kept === undefined) return null
+  if (kept === 0) return { key: 'figure.text.section-editor-keeps-centre' }
+  return { key: 'figure.text.section-editor-keeps', face: END_FACE(axis, kept === 1 ? 'start' : 'end') }
+}
+
+/** The words beside a drawn section's edit button: how many points it has, and the apex when its end is one point. */
+export function sectionPointsWordsOf(drawn: ReturnType<typeof drawnOf>): { key: string; params: Record<string, string> } | null {
+  if (drawn?.section.kind !== 'polygon') return null
+  return { key: drawn.apex ? 'figure.text.section-points-apex' : 'figure.text.section-points', params: { points: String(drawn.section.points.length) } }
+}

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

@@ -0,0 +1,140 @@
+/*
+ * What the Figure modeller gives the shared slot layout editor (`@operato/slot-layout-editor`, the one fmsim hosts too),
+ * and what it makes of the editor's result (ADR-0118). The editor edits tiers and slots; the modeller owns the anchors
+ * -- a part's top or bottom face, named -- and sends the whole layout as one `set-slot-layout` command.
+ *
+ * A figure's released slot layout is the only one there is (ADR-0118 decision 8, user): no scene or run overrides it, so
+ * this host offers no "use default" and no per-instance value.
+ *
+ * Kept free of Lit, i18n and the editor's element so node tests read it directly.
+ */
+import {
+  figureShapeBoundsOf,
+  figureSlotLayoutOf,
+  figureSlotLayoutIssues,
+  slotLayoutPreset,
+  SLOT_LAYOUT_PRESET_KEYS,
+  SLOT_LAYOUT_PRESET_PARAMS,
+  type FigureAsset,
+  type SlotLayout,
+  type SlotPresetSize
+} from '@hatiolab/figure-model'
+import type { FigureRenderPart } from './renderer.js'
+
+export type SlotAnchorFace = 'top' | 'bottom'
+export interface SlotAnchor {
+  id: string
+  part: string
+  face: SlotAnchorFace
+}
+/** What the panel edits besides the tiers: the layout's name, what its slots are, and the anchors they stand on. */
+export interface SlotLayoutForm {
+  label: string
+  role: 'seat' | 'grip'
+  anchors: SlotAnchor[]
+}
+/** A layout problem as the editor shows it: a code, where, and its values. */
+export interface SlotEditorIssue {
+  code: string
+  path: string
+  params?: Record<string, string | number>
+}
+
+type Body = { id: string; shape?: Parameters<typeof figureShapeBoundsOf>[0] }
+
+/** The figure's layout as the form and the layout, or a form to start one from on the selected part's top. */
+export function slotLayoutFormOf(asset: FigureAsset, part: string): { form: SlotLayoutForm; layout?: SlotLayout } {
+  const had = figureSlotLayoutOf(asset as never)
+  if (had) return { form: { label: had.label, role: had.role, anchors: had.anchors.map(a => ({ ...a, face: a.face as SlotAnchorFace })) }, layout: had.layout }
+  return { form: { label: '', role: 'seat', anchors: part ? [{ id: part, part, face: 'top' }] : [] } }
+}
+
+/** How big each anchor's face is, along the part's own X (width) and Z (depth): what the editor checks slots against. */
+export function anchorFacesOf(anchors: readonly SlotAnchor[], geometry: readonly Body[]): Record<string, { width: number; depth: number }> {
+  const out: Record<string, { width: number; depth: number }> = {}
+  for (const a of anchors) {
+    const body = geometry.find(g => g.id === a.part)
+    if (!body?.shape) continue
+    const b = figureShapeBoundsOf(body.shape)
+    out[a.id] = { width: b.x.max - b.x.min, depth: b.z.max - b.z.min }
+  }
+  return out
+}
+
+/**
+ * Where an author starts: the equipment presets (figure-model, ADR-0118 decision 8), laid out on this figure's anchors --
+ * a one-anchor preset on the first, a twin fork on the first two. A single slot stands on a top and hangs from a bottom.
+ * The editor's own controls then make it what the equipment is.
+ */
+export function slotPresetsOf(anchors: readonly SlotAnchor[], say: (key: string) => string) {
+  const first = anchors[0]
+  const on = { ...(first ? { anchor: first.id } : {}), ...(anchors.length >= 2 ? { forks: [anchors[0]!.id, anchors[1]!.id] as [string, string] } : {}) }
+  const mount = first?.face === 'bottom' ? ('HANG' as const) : ('ON' as const)
+  return SLOT_LAYOUT_PRESET_KEYS.map(key => ({
+    key,
+    label: say(`figure.label.slot-preset-${key}`),
+    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, label: say(`figure.label.slot-preset-param-${p.key}`), integer: p.integer })),
+    build: (size: SlotPresetSize, params: Record<string, number>) => slotLayoutPreset(key, size, params, { ...on, mount })
+  }))
+}
+
+/*
+ * What figure-model asks beyond the editor's own checks: every slot names the types it takes (ADR-0118 decision 5) -- the
+ * editor's "any type" is a board's, not a figure's. The kernel's own check (`figureSlotLayoutIssues`, the one a
+ * placement's override is held to as well), said before Apply rather than refused after it; the editor already shows the
+ * common findings, so only the figure's own are added.
+ */
+export function figureSlotIssues(layout: SlotLayout, anchors: readonly string[] = layout.tiers.map(t => t.anchorId)): SlotEditorIssue[] {
+  return figureSlotLayoutIssues(layout, anchors).filter(issue => issue.code === 'ACCEPTS_REQUIRED')
+}
+
+/** The command the panel sends: the whole layout, its anchors and its name, as one step of the history. */
+export function slotLayoutCommandOf(form: SlotLayoutForm, layout: SlotLayout, fallbackLabel: string) {
+  return {
+    kind: 'set-slot-layout' as const,
+    label: form.label.trim() || fallbackLabel,
+    role: form.role,
+    anchors: form.anchors.map(a => ({ id: a.id.trim(), part: a.part, face: a.face })),
+    layout: structuredClone(layout)
+  }
+}
+
+/** A new anchor's id: the part's, or the part's with a number when that is taken. */
+export function anchorIdFor(part: string, taken: readonly string[]): string {
+  if (!taken.includes(part)) return part
+  let n = 2
+  while (taken.includes(`${part}_${n}`)) n++
+  return `${part}_${n}`
+}
+
+/* The token the canvas draws slots in: translucent, never picked, never saved. */
+export const SLOT_MARK = '__slot'
+
+type Evaluated = { id: string; pose: { r: number[][]; t: number[] }; region: { dimensions: number[] } | null }
+
+/**
+ * The unfolded slots as boxes the canvas draws (ADR-0118 decision 4): each as big as what it allows, standing on its
+ * place -- or hanging from it, for a tier that hangs things -- so an author sees where every slot of the rule falls.
+ */
+export function slotMarksOf(places: readonly Evaluated[], layout: SlotLayout | undefined) {
+  if (!layout) return []
+  const mountOf = new Map(layout.tiers.map(t => [t.tierNo, t.mount]))
+  const marks: FigureRenderPart[] = []
+  for (const p of places) {
+    const slot = /^t(\d+)_s\d+$/.exec(p.id)
+    if (!slot || !p.region) continue
+    const [width, height, depth] = p.region.dimensions as [number, number, number]
+    const down = mountOf.get(Number(slot[1])) === 'HANG'
+    marks.push({
+      id: `${SLOT_MARK}:${p.id}`,
+      shape: {
+        provider: 'extrude',
+        dimensions: { width, height, depth },
+        extrusion: { axis: 'y', section: { kind: 'rectangle', size: { x: width, z: depth } }, start: down ? -height : 0, end: down ? 0 : height }
+      },
+      pose: p.pose,
+      material: { token: SLOT_MARK, transparent: true }
+    })
+  }
+  return marks
+}

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

@@ -29,7 +29,7 @@ import {
 } from '@things-factory/ai-assistant/dist-client/index.js'
 import type { FirstSave } from '../modeller/first-save.js'
 import { typeOf } from '../modeller/first-save.js'
-import { placementRefusalOf } from '../modeller/refusals.js'
+import { editRefusalOf } from '../modeller/refusals.js'
 import { proposalOutcomeFrom, takeFigureOffer, takePendingNewFigure } from '../modeller/ai-proposal.js'
 
 /**
@@ -291,10 +291,11 @@ export class FigureModellerPage extends PageView {
       this.commandError =
         (error as { code?: string })?.code === 'OCCUPANCY_NO_PARTS'
           ? i18next.t('figure.text.fit-needs-parts')
-          : placementRefusalOf(error, (key, params) => i18next.t(key, params)) ??
-            (error instanceof Error
-            ? error.message
-            : String(error))
+          : (error as { code?: string })?.code
+            ? editRefusalOf(error, (key, params) => i18next.t(key, params))
+            : error instanceof Error
+              ? error.message
+              : String(error)
     }
   }
   /**

package/client/viewparts/detail-route.ts

@@ -0,0 +1,7 @@
+/**
+ * The catalogue preview belongs to the page it was opened on: it closes once the shell leaves that page, by any route
+ * (`opened` is that page, `current` the page the shell is on now). Opened on no known page, it is never closed by this.
+ */
+export function leftOpeningPage(opened: string | undefined, current: string | undefined) {
+  return opened !== undefined && current !== opened
+}

package/client/viewparts/figure-detail-dock.ts

@@ -9,6 +9,7 @@ import { figureCostOf, parseFigureAsset, type FigureAsset } from '@hatiolab/figu
 import { capacityFrom } from '../modeller/scene-budget.js'
 import { fetchFigure, fetchReleasedFigure } from '../graphql/index.js'
 import { modellerPathOf } from '../modeller/modeller-route.js'
+import { leftOpeningPage } from './detail-route.js'
 import type { Figure } from '../types.js'
 import './figure-asset-viewer.js'
 
@@ -177,9 +178,6 @@ function visibleBar(root: Document | ShadowRoot): Element | undefined {
 let dock: FigureDetailDock | undefined
 /** The page the preview was opened on; the preview belongs to that page and closes when the shell leaves it. */
 let openedOn: string | undefined
-export function leftOpeningPage(opened: string | undefined, current: string | undefined) {
-  return opened !== undefined && current !== opened
-}
 function hideDetail() {
   store.dispatch({ type: UPDATE_VIEWPART, name: VIEWPART, override: { show: false } })
 }