@things-factory/figure-ui 10.1.83 → 10.1.84

package/client/modeller/command-preview.ts

@@ -1,6 +1,7 @@
 import type { FigureBodyMove, FigureClipLoss, FigureFaceArea, FigureRowReading } from '@hatiolab/figure-model'
 
 import type { FigureRenderPart } from './renderer.js'
+import { boxShape, discShape } from './drawn-shapes.js'
 
 /*
  * A command seen before it is done, as the modeller shows it (ADR-0097 §5.5, designer 2026-09-27): the bodies it would
@@ -53,9 +54,10 @@ export function faceHighlightOf(face: FigureFaceArea | undefined): FigureRenderP
   /* Its own x · y · z are the face's two sides and its normal, as the kernel gives them. */
   const r = [0, 1, 2].map(i => [face.u[i]!, face.normal[i]!, face.v[i]!])
   const t = [0, 1, 2].map(i => face.centre[i]! + face.normal[i]! * (LIFT + THICKNESS / 2))
+  /* A plane touching a curved side is a line (Q3): drawn as a narrow strip, never a plate. */
   const shape: FigureRenderPart['shape'] = face.round
-    ? { provider: 'cylinder', dimensions: { radius: face.size.u / 2, length: THICKNESS } }
-    : { provider: 'box', dimensions: { width: face.size.u, height: THICKNESS, depth: face.size.v } }
+    ? discShape(face.size.u / 2, THICKNESS)
+    : boxShape(Math.max(face.size.u, THICKNESS), THICKNESS, Math.max(face.size.v, THICKNESS))
   /* Solid: a translucent plate over a light face was hardly seen (2026-09-27, :3391); it covers the face it names. */
   return { id: TARGET_FACE, shape, pose: { r, t }, material: { token: TARGET_FACE } }
 }

package/client/modeller/drawn-shapes.ts

@@ -0,0 +1,29 @@
+/**
+ * Shapes the modeller draws of its own -- a lit face, a joint's fan, a slide's line -- written as the shapes figure-model
+ * evaluates (ADR-0100): a section pushed along Y, centred. things-scene's one builder draws them as it draws a part.
+ */
+export interface DrawnShape {
+  provider: 'extrude'
+  dimensions: Record<string, number>
+  extrusion: { axis: 'y'; section: DrawnSection; start: number; end: number }
+}
+type DrawnSection =
+  | { kind: 'rectangle'; size: { x: number; z: number } }
+  | { kind: 'ellipse'; radius: { x: number; z: number } }
+  | { kind: 'polygon'; points: Array<{ id: string; x: number; z: number }> }
+
+const centred = (section: DrawnSection, height: number): DrawnShape => ({
+  provider: 'extrude',
+  dimensions: { length: height },
+  extrusion: { axis: 'y', section, start: -height / 2, end: height / 2 }
+})
+
+/** A box: width along X, height along Y, depth along Z. */
+export const boxShape = (width: number, height: number, depth: number): DrawnShape => centred({ kind: 'rectangle', size: { x: width, z: depth } }, height)
+
+/** A disc of a radius, `height` thick along Y. */
+export const discShape = (radius: number, height: number): DrawnShape => centred({ kind: 'ellipse', radius: { x: radius, z: radius } }, height)
+
+/** A section in X-Z, `height` thick along Y. */
+export const sectionShape = (points: ReadonlyArray<{ x: number; z: number }>, height: number): DrawnShape =>
+  centred({ kind: 'polygon', points: points.map((p, i) => ({ id: `p${i + 1}`, x: p.x, z: p.z })) }, height)

package/client/modeller/editor.ts

@@ -16,6 +16,7 @@ import { drawableFigureParts } from './renderer.js'
 import './canvas.js'
 import './figure-parts.js'
 import './figure-material-panel.js'
+import './figure-section-panel.js'
 import { faceHighlightOf, ghostPartsOf, previewWordsOf, rowWordsOf, type HeldPreview } from './command-preview.js'
 import { motionEndsOf, type MotionEnds } from './motion-ends.js'
 import './figure-links.js'
@@ -47,6 +48,7 @@ import { jointFanOf } from './joint-fan.js'
 import { jointDragOf } from './joint-drag.js'
 import type { FirstSave } from './first-save.js'
 import { isLive, livePartsOf, liveOverSession, NOTHING_LIVE, scrubbed, scrubStep, type LiveValues } from './live.js'
+import { startingShapeKindOfBody } from './starting-shape.js'
 
 
 /**
@@ -1342,7 +1344,7 @@ export class FigureEditor extends LitElement {
       }
       rows.set(id, {
         id,
-        provider: (g as { shape?: { provider?: string } }).shape?.provider ?? '',
+        kind: startingShapeKindOfBody((g as { shape?: never }).shape) ?? '',
         hidden: this.hiddenParts.has(id),
         invisible: (g as { visible?: boolean }).visible === false,
         ...(id !== g.id ? { copies: 1 } : {}),
@@ -2012,6 +2014,11 @@ export class FigureEditor extends LitElement {
                   ${this.renderGroups(this.withSizeRow(groupFields(partFields, this.selected), held), 'figure.label.group-placement-size', 'figure.label.group-shape', unavailable, this.renderTools(unavailable), held)}
                   ${roomFields.length ? this.renderRoomOnly(roomFields, unavailable) : nothing}
                   ${this.renderLinks(unavailable, 'shape')}
+                  <figure-section-panel
+                    .body=${{ ...part, id: this.selected }}
+                    ?locked=${unavailable}
+                    @command=${(e: CustomEvent) => this.linkCommand(e.detail.action)}
+                  ></figure-section-panel>
                   <figure-material-panel
                     .body=${{ ...part, id: this.selected }}
                     .palette=${view.palette ?? {}}

package/client/modeller/figure-material-panel.ts

@@ -6,6 +6,7 @@ import { MATERIAL_PRESETS, SEGMENT_PRESETS, figureTrianglesOf } from '@hatiolab/
 import { activePalette } from '@hatiolab/things-scene'
 import type { FigureAssetGeometry, FigureMaterial, FigurePartEdit } from '@hatiolab/figure-model'
 import { SidePanelStyles } from './side-panel-styles.js'
+import { isRoundBody } from './starting-shape.js'
 
 /** The purpose each palette role is for, by its token. */
 const PURPOSE: Record<string, string> = {
@@ -23,7 +24,6 @@ const PURPOSE: Record<string, string> = {
 export const purposeOf = (token?: string) => i18next.t(`figure.label.palette-purpose-${PURPOSE[token ?? ''] ?? 'registered'}`)
 
 /** Bodies with a rim — the ones `set-segments` accepts. */
-const ROUND = new Set(['cylinder', 'ellipticCylinder', 'sphere', 'frustum'])
 const DEFAULT_SEGMENTS = 12
 
 /**
@@ -230,8 +230,7 @@ export class FigureMaterialPanel extends localize(i18next)(LitElement) {
   }
 
   private renderSegments(part: FigureAssetGeometry & { id: string }) {
-    const provider = (part as { shape?: { provider?: string } }).shape?.provider ?? ''
-    if (!ROUND.has(provider)) return nothing
+    if (!isRoundBody((part as { shape?: never }).shape)) return nothing
     const current = part.segments ?? DEFAULT_SEGMENTS
     return html`
       <div field>

package/client/modeller/figure-parts.ts

@@ -13,7 +13,7 @@ import { partLabelOf } from './fields.js'
  *
  * 팔레트는 목록 위에, 눈 단추는 늘 자리를 차지하고, 조작은 고른 줄에서만 보인다.
  *
- * 부품의 도형은 평가가 준 `provider` 로 읽는다. 「숨김」은 여기서도 **작업대의 것**이다 — 저장되지 않고, 자산의 `visibility`(상태에 따라
+ * 부품의 도형은 평가가 준 형상에서 읽은 시작 모양 이름(`kind`)으로 보인다. 「숨김」은 여기서도 **작업대의 것**이다 — 저장되지 않고, 자산의 `visibility`(상태에 따라
  * 보이고 안 보이는 것)와는 다른 것이다. 그것은 속성 패널의 몫이다.
  *
  * 이 컴포넌트는 정본을 만지지 않는다. 무엇을 하겠다는 것만 알린다.
@@ -22,7 +22,8 @@ import { partLabelOf } from './fields.js'
 /** 한 줄 — 평가에서 이 패널이 읽는 것만. */
 export interface FigurePartRow {
   id: string
-  provider: string
+  /** 시작 모양 이름(`startingShapeKindOfBody`): 상자 · 원기둥 … 아이콘을 고른다. */
+  kind: string
   /** 작업대에서 잠깐 가린 것. 저장되지 않는다. */
   hidden?: boolean
   /** 자산이 지금 상태에서 보이지 않는다고 한 것. 저장되는 것이고, 여기서는 표시만 한다. */
@@ -36,17 +37,14 @@ export interface FigurePartRow {
   fastenedTo?: string
 }
 
-/** 제공자마다의 아이콘. Material Symbols 이름이다. */
-const PROVIDER_ICON: Record<string, string> = {
-  box: 'deployed_code',
+/** 시작 모양마다의 아이콘. Material Symbols 이름이다. */
+const KIND_ICON: Record<string, string> = {
+  cube: 'deployed_code',
   cylinder: 'database',
-  ellipticCylinder: 'database',
   frustum: 'change_history',
   sphere: 'circle',
-  roundedBox: 'crop_square',
-  roundedBoxXZ: 'crop_square',
-  hollowBox: 'check_box_outline_blank',
-  hollowBoxXZ: 'check_box_outline_blank',
+  'rounded-box': 'crop_square',
+  'hollow-box': 'check_box_outline_blank',
   polygon: 'pentagon',
   portal: 'door_front'
 }
@@ -575,7 +573,7 @@ export class FigureParts extends localize(i18next)(LitElement) {
         >
           <md-icon>${off ? 'visibility_off' : 'visibility'}</md-icon>
         </button>
-        <md-icon>${PROVIDER_ICON[part.provider] ?? 'deployed_code'}</md-icon>
+        <md-icon>${KIND_ICON[part.kind] ?? 'deployed_code'}</md-icon>
         <span label title=${part.id}
           >${partLabelOf(part.id)}${part.copies ? html` <small copies>× ${part.copies}</small>` : nothing}${part.invisible ? html`<small>${i18next.t('figure.label.state-hidden')}</small>` : nothing}${part.fastenedTo
             ? html`<small fastened-to title=${i18next.t('figure.label.fastened-to')}>${part.fastenedTo}</small>`

package/client/modeller/figure-section-panel.ts

@@ -0,0 +1,175 @@
+import { css, html, LitElement, nothing } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+import { live } from 'lit/directives/live.js'
+
+import { i18next, localize } from '@operato/i18n'
+import type { FigureAuthoringAction, FigureCavityRequest, FigureEvaluatedShape } from '@hatiolab/figure-model'
+import { SidePanelStyles } from './side-panel-styles.js'
+import { cavityRequestOf, defaultWallOf, mm, sameOf } from './section-controls.js'
+
+type Axis = 'x' | 'y' | 'z'
+type End = 'start' | 'end'
+
+/** The face each end of a push is, by the axis it runs along: its start is the low side. */
+const END_FACE: Record<Axis, Record<End, string>> = {
+  x: { start: 'left', end: 'right' },
+  y: { start: 'bottom', end: 'top' },
+  z: { start: 'back', end: 'front' }
+}
+
+/**
+ * 단면 — a pushed part's rounded corners and its inside (ADR-0100 stage 1).
+ *
+ * Only what the part's section has: corners for a rectangle, an inside for a rectangle or an ellipse. A drawn section
+ * and a turned body show nothing here. A radius or a wall entered sets every corner or every wall to it; the kernel
+ * holds per-axis values, and when they differ the field says so and shows none of them.
+ *
+ * Every change leaves as one `command`; the editor runs it through the session, one step of the undo history.
+ */
+@customElement('figure-section-panel')
+export class FigureSectionPanel extends localize(i18next)(LitElement) {
+  static styles = [SidePanelStyles, css`
+    :host {
+      display: block;
+    }
+    div[row] {
+      display: flex;
+      gap: 6px;
+      align-items: center;
+    }
+    div[row] > * {
+      flex: 1;
+      min-width: 0;
+    }
+    div[row] > label {
+      flex: 0 0 auto;
+    }
+  `]
+
+  @property({ attribute: false }) body?: { id: string; shape: FigureEvaluatedShape }
+  @property({ type: Boolean }) locked = false
+
+  render() {
+    const body = this.body
+    const extrusion = body?.shape?.provider === 'extrude' ? body.shape.extrusion : undefined
+    if (!body || !extrusion) return nothing
+    const kind = extrusion.section.kind
+    if (kind !== 'rectangle' && kind !== 'ellipse') return nothing
+    return html`<section>
+      <h3>${i18next.t('figure.label.group-section')}</h3>
+      ${kind === 'rectangle' ? this.renderCorner(body) : nothing} ${this.renderCavity(body, extrusion.axis)}
+    </section>`
+  }
+
+  private renderCorner(body: { id: string; shape: FigureEvaluatedShape }) {
+    const d = body.shape.dimensions
+    const reaches = Object.keys(d)
+      .filter(k => k.startsWith('corner.'))
+      .map(k => d[k])
+    const one = reaches.length ? sameOf(reaches) : 0
+    return html`<div field>
+      <label>${i18next.t('figure.label.section-corner')}</label>
+      <input
+        type="number"
+        min="0"
+        step="any"
+        .value=${live(one === undefined ? '' : String(mm(one)))}
+        placeholder=${one === undefined ? i18next.t('figure.text.section-corner-differs') : ''}
+        ?disabled=${this.locked}
+        @change=${(e: Event) => {
+          const input = e.target as HTMLInputElement
+          const value = Number(input.value)
+          if (input.value === '' || !Number.isFinite(value) || value < 0) {
+            input.value = one === undefined ? '' : String(mm(one))
+            return
+          }
+          /* 0 is a sharp corner: the rounding is taken away rather than kept at nothing. */
+          this.command({ kind: 'set-section-corner', part: body.id, corner: value > 0 ? value : null })
+        }}
+      />
+    </div>`
+  }
+
+  private renderCavity(body: { id: string; shape: FigureEvaluatedShape }, axis: Axis) {
+    const cavity = body.shape.cavity
+    const request = (patch: Partial<FigureCavityRequest>) => cavityRequestOf(body.shape, patch)
+    return html`<div field>
+        <label>
+          <input
+            type="checkbox"
+            .checked=${live(!!cavity)}
+            ?disabled=${this.locked}
+            @change=${(e: Event) => {
+              const on = (e.target as HTMLInputElement).checked
+              ;(e.target as HTMLInputElement).checked = !!cavity
+              this.command({ kind: 'set-cavity', part: body.id, cavity: on ? request({}) : null })
+            }}
+          />
+          ${i18next.t('figure.label.section-cavity')}
+        </label>
+      </div>
+      ${cavity
+        ? html`<div field>
+              <label>${i18next.t('figure.label.section-wall')}</label>
+              ${this.thickness(sameOf(Object.values(cavity.wall)), value => this.command({ kind: 'set-cavity', part: body.id, cavity: request({ wall: value }) }), 'figure.text.section-wall-differs')}
+            </div>
+            ${(['start', 'end'] as const).map(end => this.renderEnd(body.id, axis, end, cavity[end], request))}`
+        : nothing}`
+  }
+
+  private renderEnd(
+    part: string,
+    axis: Axis,
+    end: End,
+    now: 'open' | { closed: number },
+    request: (patch: Partial<FigureCavityRequest>) => FigureCavityRequest
+  ) {
+    const closed = now !== 'open'
+    const set = (value: 'open' | { closed: number }) => this.command({ kind: 'set-cavity', part, cavity: request({ [end]: value }) })
+    return html`<div field>
+      <label>${i18next.t('figure.label.face-' + END_FACE[axis][end])}</label>
+      <div row>
+        <select
+          .value=${live(closed ? 'closed' : 'open')}
+          ?disabled=${this.locked}
+          @change=${(e: Event) => {
+            const select = e.target as HTMLSelectElement
+            const want = select.value
+            select.value = closed ? 'closed' : 'open'
+            set(want === 'open' ? 'open' : { closed: defaultWallOf(this.body!.shape) })
+          }}
+        >
+          <option value="closed">${i18next.t('figure.label.section-end-closed')}</option>
+          <option value="open">${i18next.t('figure.label.section-end-open')}</option>
+        </select>
+        ${closed ? this.thickness(now.closed, value => set({ closed: value })) : html`<span></span>`}
+      </div>
+    </div>`
+  }
+
+  /** A thickness field: a positive number, committed on change; anything else puts the old value back. */
+  private thickness(now: number | undefined, commit: (value: number) => void, differs?: string) {
+    const shown = now === undefined ? '' : String(mm(now))
+    return html`<input
+      type="number"
+      min="0"
+      step="any"
+      .value=${live(shown)}
+      placeholder=${now === undefined && differs ? i18next.t(differs) : ''}
+      ?disabled=${this.locked}
+      @change=${(e: Event) => {
+        const input = e.target as HTMLInputElement
+        const value = Number(input.value)
+        if (input.value === '' || !Number.isFinite(value) || !(value > 0)) {
+          input.value = shown
+          return
+        }
+        commit(value)
+      }}
+    />`
+  }
+
+  private command(action: FigureAuthoringAction) {
+    this.dispatchEvent(new CustomEvent('command', { detail: { action }, bubbles: true, composed: true }))
+  }
+}

package/client/modeller/gizmo.ts

@@ -1,13 +1,13 @@
-import { figureAttachmentsOf } from '@hatiolab/figure-model'
+import { figureAttachmentsOf, figureShapeProviderOf } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureInputChange } from '@hatiolab/figure-model'
 
 /**
  * What the gizmo may write for a part: move · turn · size, on a asset.
  *
  * A drag can only be written back where the part is placed by its own numbers. A part the create commands made is:
- * its pose is `rigid@1` into the asset frame from `<part>.position.*` and `<part>.rotation.*`, and a box's shape
- * (`box-shape@1` or `rounded-box@1`) takes its width, height and depth from inputs of its own — `<part>.size.*` from
- * `addFigureBox`, `<part>.dimension.*` from the editor's shape palette. A part fastened to another, following an instance size or placed by
+ * its pose is `rigid@1` into the asset frame from `<part>.position.*` and `<part>.rotation.*`, and its shape takes its
+ * measures from inputs of its own — `<part>.size.*` from `addFigureBox`, `<part>.dimension.*` from the editor's shape
+ * palette — at the arguments the shape itself names (figure-model's provider). A part fastened to another, following an instance size or placed by
  * expressions has no such numbers; the gizmo does not offer what it could not write back, rather
  * than move something the next evaluation would put back.
  */
@@ -29,9 +29,6 @@ export interface GizmoReach {
   round?: { across: string[]; along: string[] }
 }
 
-/** Shapes whose first three arguments are the extent along X, Y and Z: a door frame's too (its width, height, depth). */
-const BOXES = new Set(['box-shape@1', 'rounded-box@1', 'portal-profile@2', 'hollow-box@2'])
-
 interface Node {
   id: string
   op: string
@@ -65,15 +62,28 @@ export function gizmoReachOf(asset: AssetLike, part: string): GizmoReach {
   const posed = direct || reseated
   const shape = nodes.find(node => node.id === `${part}.shape`)
   const mine = (ids: string[]) => ids.every(id => id.startsWith(`${part}.`) && design.has(id))
-  const round =
-    shape?.op === 'cylinder-shape@1' && mine(shape.args.slice(0, 2))
-      ? { across: [shape.args[0]!], along: [shape.args[1]!] }
-      : shape?.op === 'frustum-shape@1' && mine(shape.args.slice(0, 3))
-        ? { across: shape.args.slice(0, 2), along: [shape.args[2]!] }
-        : shape?.op === 'sphere-shape@1' && mine(shape.args.slice(0, 3))
-          ? { across: shape.args.slice(0, 3), along: [] }
-          : undefined
-  const extent = shape && BOXES.has(shape.op) ? shape.args.slice(0, 3) : []
+  /*
+    Which argument sizes the part along X, Y and Z: the shape says (figure-model's provider, ADR-0100) -- never its first
+    three arguments. A round section written from one radius, a sphere and a taper keep their shape: their radii take one
+    factor together.
+  */
+  const provider = shape ? figureShapeProviderOf(shape as never) : undefined
+  const edit = provider?.edit
+  const refOf = (axis: 'x' | 'y' | 'z') => {
+    const e = edit?.[axis]
+    return e && !('refused' in e) ? shape!.args[e.arg]! : undefined
+  }
+  const measures = AXES.map(refOf)
+  const shared = !!edit && AXES.some(axis => { const e = edit[axis]; return !('refused' in e) && !!(e.sameAs || e.with?.length) })
+  let round: GizmoReach['round']
+  if (shared && edit) {
+    const withs = AXES.flatMap(axis => { const e = edit[axis]; return !('refused' in e) ? (e.with ?? []).map(i => shape!.args[i]!) : [] })
+    const sphere = !!provider && Object.keys(provider.faces).length === 0
+    const across = [...new Set([refOf('x')!, ...withs])]
+    const along = sphere ? [] : [refOf('y')!]
+    if ([...across, ...along].every(id => id && mine([id]))) round = { across: sphere ? [...new Set([...across, refOf('y')!])] : across, along }
+  }
+  const extent = !round && measures.every(Boolean) ? (measures as string[]) : []
   const sizes =
     extent.length === 3 && extent.every(id => id.startsWith(`${part}.`) && design.has(id)) ? (extent as [string, string, string]) : undefined
   /*

package/client/modeller/joint-fan.ts

@@ -2,6 +2,7 @@ import { compileFigureAsset, compileFigureGraph, figureWorldBoxesOf, figureWrite
 import type { FigureAsset } from '@hatiolab/figure-model'
 
 import type { FigureRenderPart } from './renderer.js'
+import { sectionShape } from './drawn-shapes.js'
 
 /*
  * Where the selected part turns, and how far -- a translucent fan on the editing board. An axis name says nothing about which way a part swings; on a six-axis arm the author went to the preview and
@@ -249,14 +250,14 @@ export function jointFanOf(asset: FigureAsset, part: string, values: Record<stri
   const r = [0, 1, 2].map(i => [first[i]!, axisNow[i]!, zAxis[i]!])
   const local = (p: number[]) => {
     const v = sub(p, pivot)
-    return { x: dot(v, first), y: dot(v, zAxis) }
+    return { x: dot(v, first), z: dot(v, zAxis) }
   }
   const full = max - min >= 359.999
-  const profile = [...(full ? [] : [{ x: 0, y: 0 }]), ...traced.map(local)].map(p => ({ x: Math.round(p.x * 1000) / 1000, y: Math.round(p.y * 1000) / 1000 }))
+  const profile = [...(full ? [] : [{ x: 0, z: 0 }]), ...traced.map(local)].map(p => ({ x: Math.round(p.x * 1000) / 1000, z: Math.round(p.z * 1000) / 1000 }))
 
   return {
     id: JOINT_FAN,
-    shape: { provider: 'polygon', dimensions: { height: THICKNESS }, profile },
+    shape: sectionShape(profile, THICKNESS),
     pose: { t: pivot, r },
     material: { token: '__joint-fan', transparent: true },
     /** Which control turns it: the joint the fan shows. */

package/client/modeller/links.ts

@@ -1,6 +1,7 @@
 import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, compileFigureGraph, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf } from '@hatiolab/figure-model'
 import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureBindingPlace, FigureFace, FigureJoint } from '@hatiolab/figure-model'
+import { startingShapeKindOf } from './starting-shape.js'
 
 /*
  * What a part is tied to — the readers behind the parts' size response, fastening and motion sections. Kept apart from the element so they can be tested without a browser.
@@ -62,7 +63,7 @@ export function canFollow(asset: FigureAsset, part: string): boolean {
  */
 export function followableAxes(asset: FigureAsset, part: string): Axis[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return shape ? figureFollowableAxesOf(shape.op) : []
+  return shape ? figureFollowableAxesOf(shape as never) : []
 }
 
 /**
@@ -87,27 +88,14 @@ export function resizeAxesOf(asset: FigureAsset, part: string, pending?: readonl
   return { axes: editable, basis: editable.length ? 'suggested' : 'none' }
 }
 
-const KIND_OF_SHAPE: Record<string, string> = {
-  'box-shape@1': 'cube',
-  'rounded-box@1': 'rounded-box',
-  'rounded-box@2': 'rounded-box',
-  'hollow-box@1': 'hollow-box',
-  'hollow-box@2': 'hollow-box',
-  'portal-profile@2': 'portal',
-  'cylinder-shape@1': 'cylinder',
-  'cylinder-shape@2': 'cylinder',
-  'sphere-shape@1': 'sphere',
-  'frustum-shape@1': 'frustum',
-  'polygon-shape@1': 'polygon'
-}
-
 /**
  * The selected part in three short lines, for the head of its panel (designer 2026-09-27, B): what it is, how its
  * size answers the figure's, and what holds it -- 「box · 상자 / 너비는 도형을 따라감 / 아랫면을 바닥에 유지 중」.
  */
 export function partSummaryOf(asset: FigureAsset, part: string, say: (key: string, params?: Record<string, string>) => string): { kind: string; size: string; relation: string } {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  const kind = shape && KIND_OF_SHAPE[shape.op] ? say(`figure.label.primitive-${KIND_OF_SHAPE[shape.op]}`) : ''
+  const named = startingShapeKindOf(shape as never)
+  const kind = named ? say(`figure.label.primitive-${named}`) : ''
   const editable = followableAxes(asset, part)
   const round = editable.length === 2
   const word = (axis: Axis) => say(round && axis === 'x' ? 'figure.label.resize-diameter' : `figure.label.resize-${axis}`)
@@ -146,7 +134,10 @@ export function fieldWordsOf(id: string, say: (key: string) => string): string {
 /** What a part's own measure on an axis is now (a box's side, a cylinder's radius or length), at the design as it stands. */
 export function dimensionNow(asset: FigureAsset, part: string, axis: Axis): number | undefined {
   const m = modelOf(asset)
-  const ref = m.nodes.find(n => n.id === `${part}.shape`)?.args[AXES.indexOf(axis)]
+  /* The argument the shape names for this axis (figure-model's provider), not its place among the arguments. */
+  const shape = m.nodes.find(n => n.id === `${part}.shape`)
+  const edit = shape && figureShapeProviderOf(shape as never)?.edit[axis]
+  const ref = edit && !('refused' in edit) ? shape!.args[edit.arg] : undefined
   if (!ref) return undefined
   try {
     const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
@@ -163,7 +154,7 @@ export function dimensionNow(asset: FigureAsset, part: string, axis: Axis): numb
  */
 export function measureNow(asset: FigureAsset, part: string, axis: Axis): number | undefined {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  const edit = shape && figureShapeProviderOf(shape.op)?.edit[axis]
+  const edit = shape && figureShapeProviderOf(shape as never)?.edit[axis]
   if (!shape || !edit || 'refused' in edit) return undefined
   try {
     const values = compileFigureGraph(asset.document.model as never).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values as Record<string, number>
@@ -180,13 +171,20 @@ export function measureNow(asset: FigureAsset, part: string, axis: Axis): number
  */
 export function facesOf(asset: FigureAsset, part: string): string[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return Object.keys((shape && figureShapeFaces(shape.op)) ?? {})
+  return inScreenOrder(Object.keys((shape && figureShapeFaces(shape as never)) ?? {}))
+}
+
+/** Faces in the order the screen lists them: the six outer ones left to front, then the rest as the shape gives them. */
+const SCREEN_ORDER = ['left', 'right', 'bottom', 'top', 'back', 'front']
+function inScreenOrder(names: string[]): string[] {
+  const rank = (n: string) => (SCREEN_ORDER.includes(n) ? SCREEN_ORDER.indexOf(n) : SCREEN_ORDER.length)
+  return names.map((n, i) => [n, i] as const).sort((a, b) => rank(a[0]) - rank(b[0]) || a[1] - b[1]).map(([n]) => n)
 }
 
 /** The axis a face of a part faces along, from the same definitions. */
 export function faceAxisOf(asset: FigureAsset, part: string, face: string): Axis | undefined {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return (shape && figureShapeFaces(shape.op)?.[face]?.axis) as Axis | undefined
+  return (shape && figureShapeFaces(shape as never)?.[face]?.axis) as Axis | undefined
 }
 
 /** Whether `attach` can take this part: any part whose shape has a flat face. */
@@ -556,12 +554,14 @@ export function choiceOf(follow: Follow): string {
   }
 }
 
-/** The faces a place can sit on for this part: a box's six, a rounded box's top and bottom, none for a round body. */
+/**
+ * The faces a place can sit on for this part: its flat faces, but not a plane that only touches a curved side along a
+ * line (a cylinder's side, Q3) -- nothing is held on a line. A sphere has none.
+ */
 export function placeFacesOf(asset: FigureAsset, part: string): FigureFace[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  if (shape?.op === 'box-shape@1') return ['left', 'right', 'bottom', 'top', 'back', 'front']
-  if (shape?.op === 'rounded-box@1') return ['bottom', 'top']
-  return []
+  const faces = (shape && figureShapeFaces(shape as never)) ?? {}
+  return inScreenOrder(Object.entries(faces).filter(([, f]) => !(f as { contact?: string }).contact).map(([name]) => name)) as FigureFace[]
 }
 
 /** The places things are held that sit on this part. */

package/client/modeller/maturity.ts

@@ -154,8 +154,9 @@ export function figureReportOf(asset: FigureAsset): FigureReport | undefined {
 }
 
 /**
- * The key things-scene shares a body's geometry by (`figure-geometry.ts` `keyOf`): provider, dimensions to a
- * micrometre, segments (12 when unset), and a polygon's corners.
+ * The key things-scene shares a body's geometry by (`figure-geometry.ts` `keyOf`): the operation, what is not in its
+ * numbers (the axis, the kind of section, which ends of an inside are open), its numbers to a micrometre, and segments
+ * (12 when unset).
  */
 export function shapeKeyOf(body: FigureAssetGeometry | FigureGeometry): string {
   if (!('shape' in body)) {
@@ -169,9 +170,12 @@ export function shapeKeyOf(body: FigureAssetGeometry | FigureGeometry): string {
     .sort()
     .map(k => `${k}=${round(shape.dimensions[k]!)}`)
     .join(',')
-  const profile = shape.profile ? '|' + shape.profile.map(p => `${round(p.x)}:${round(p.y)}`).join(';') : ''
+  const e = shape.extrusion,
+    c = shape.cavity,
+    r = shape.revolution
+  const meaning = e ? `${e.axis}:${e.section.kind}:${c ? `${c.start === 'open' ? 'o' : 'c'}${c.end === 'open' ? 'o' : 'c'}` : '-'}` : r ? `${r.axis}:${r.profile.kind}` : ''
   const segments = (body as { segments?: number }).segments ?? 12
-  return `${shape.provider}|${dims}|s${segments}${profile}`
+  return `${shape.provider}|${meaning}|${dims}|s${segments}`
 }
 
 /**
@@ -202,7 +206,9 @@ function consistency(asset: FigureAsset, distinctMaterials: number): FigureMatur
 }
 
 /** Seen from above, these do not fill their footprint box, by provider name. */
-const ROUND_FOOTPRINT: readonly string[] = ['cylinder', 'ellipticCylinder', 'frustum', 'sphere']
+/** Round seen from above: a circle or an ellipse pushed along Y, anything turned about Y. */
+const roundFootprint = (shape: { extrusion?: { axis: string; section: { kind: string } }; revolution?: { axis: string } }) =>
+  (shape.extrusion?.axis === 'y' && shape.extrusion.section.kind === 'ellipse') || shape.revolution?.axis === 'y'
 
 /**
  * Can it be told apart from above — baseline 1.
@@ -276,7 +282,7 @@ function topViewRegions(
     const x1 = Math.min(GRID, Math.ceil((box.centre.x + box.extent.x / 2 - frame.x0) * sx))
     const y0 = Math.max(0, Math.floor((box.centre.z - box.extent.z / 2 - frame.z0) * sz))
     const y1 = Math.min(GRID, Math.ceil((box.centre.z + box.extent.z / 2 - frame.z0) * sz))
-    const round = 'shape' in body && ROUND_FOOTPRINT.includes(body.shape.provider)
+    const round = 'shape' in body && roundFootprint(body.shape as never)
 
     for (let y = y0; y < y1; y++) {
       for (let x = x0; x < x1; x++) {

package/client/modeller/motion-ends.ts

@@ -3,6 +3,7 @@ import type { FigureAsset } from '@hatiolab/figure-model'
 
 import { PREVIEW, TARGET_FACE } from './command-preview.js'
 import type { FigureRenderPart } from './renderer.js'
+import { boxShape } from './drawn-shapes.js'
 
 /*
  * Where a part's motion takes it (ADR-0097 §5.5, designer 2026-09-27): the bodies its control moves, drawn translucent at
@@ -73,7 +74,7 @@ export function motionEndsOf(asset: FigureAsset, part: string, values: Record<st
       const y = [z[1]! * x[2]! - z[2]! * x[1]!, z[2]! * x[0]! - z[0]! * x[2]!, z[0]! * x[1]! - z[1]! * x[0]!]
       ghost.push({
         id: `${TARGET_FACE}:slide`,
-        shape: { provider: 'box', dimensions: { width: length, height: THICKNESS, depth: THICKNESS } },
+        shape: boxShape(length, THICKNESS, THICKNESS),
         pose: { r: [0, 1, 2].map(i => [x[i]!, y[i]!, z[i]!]), t: [0, 1, 2].map(i => (from[i]! + to[i]!) / 2) },
         material: { token: TARGET_FACE }
       })

package/client/modeller/refusals.ts

@@ -117,10 +117,30 @@ export function recipeRefusalOf(error: unknown, say: Say): string | null {
  * 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. The kernel names the problem in its message; the screen names it in words.
+ */
+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', {})
+  return null
+}
+
 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 ?? '' })
 }