@things-factory/figure-ui 10.1.245 → 10.1.247

package/client/modeller/align.ts

@@ -1,5 +1,5 @@
-import { figureOccupiedBoxesOf, figureWritersOf } from '@hatiolab/figure-model'
-import type { FigureInputChange, FigureWorldBox } from '@hatiolab/figure-model'
+import { figureHangingChainOf, figureOccupiedBoxesOf, figureWritersOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigurePartEdit, FigureWorldBox } from '@hatiolab/figure-model'
 
 import { derivedOf, type FigureRevision } from './revision.js'
 
@@ -7,7 +7,7 @@ import type { GizmoReach } from './gizmo.js'
 
 /**
  * 맞추기 — the align tools on a part: centre on X, centre on Z, stand on the floor,
- * mirror on X or Z, snap to the grid.
+ * snap to the grid; and whether a mirrored copy is offered.
  *
  * The asset's frame has the floor at y 0 and X and Z centred on 0, so centring puts the part's box centre on 0 and the floor puts its lowest point on
  * y 0. The part's box is its evaluated, rotated extent (`figureOccupiedBoxesOf`), so a turned part lands by what it
@@ -72,20 +72,58 @@ export function alignChanges(revision: FigureRevision, part: string, reach: Gizm
 }
 
 /**
- * Where a mirrored copy goes: the same distance on the other side of the centre plane. The copy is made by
- * `duplicate-part` first; this is the position the copy is then given.
+ * Mirroring a part that already sits on the centre plane would put the copy inside it, so it is not offered. The copy
+ * itself is figure-model's `mirror-part`, which places it -- fastened or not -- and refuses what it cannot mirror.
  */
-export function mirrorChanges(revision: FigureRevision, part: string, copy: string, axis: 'x' | 'z'): FigureInputChange[] {
+export function canMirror(revision: FigureRevision, part: string, axis: 'x' | 'z'): boolean {
   const box = boxOf(revision, part)
-  if (!box) return []
-  const id = `${part}.position.${axis}`
-  return [{ kind: 'set-design', input: `${copy}.position.${axis}`, unit: 'mm', value: Math.round((revision.asset.designInputs[id] ?? 0) - 2 * box.centre[axis]) }]
+  return !!box && Math.abs(box.centre[axis]) >= 0.5
 }
 
-/** Mirroring a part that already sits on the centre plane would put the copy inside it, so it is refused. */
-export function canMirror(revision: FigureRevision, part: string, axis: 'x' | 'z', reach: GizmoReach): boolean {
-  const box = reach.translate ? boxOf(revision, part) : undefined
-  return !!box && Math.abs(box.centre[axis]) >= 0.5
+/** How a mirrored copy is made: with what hangs from the part, under which names, turning as a mirror or as the original. */
+export interface MirrorForm {
+  axis: 'x' | 'z'
+  chain: boolean
+  /** The beginning swapped in the copies' names (\`fl\` → \`fr\`); empty, the copies take \`-copy\`. */
+  from: string
+  to: string
+  keepMotion: boolean
+}
+
+/* The beginning a mirror across each axis swaps, by the figure's faces: X is its left and right, Z its front and back. */
+const SWAPS: Record<'x' | 'z', Record<string, string>> = { x: { l: 'r', r: 'l' }, z: { f: 'b', b: 'f' } }
+
+/**
+ * What a mirror of this part asks before it is made: the parts hanging from it (a leg from its hip), whether any of them
+ * moves, and the form started -- the chain taken, the names' beginning guessed from the part's own (\`fl-hip\` across Z
+ * is \`bl-\`, across X \`fr-\`, by the figure's faces), the motion mirrored. A part with nothing hanging and nothing
+ * moving asks nothing.
+ */
+export function mirrorPlanOf(asset: FigureAsset, part: string, axis: 'x' | 'z'): { hanging: string[]; moves: boolean; asks: boolean; form: MirrorForm } {
+  const chain = figureHangingChainOf(asset, part)
+  const moves = (asset.joints ?? []).some(j => chain.includes(j.body1.part) && !!j.motion?.length)
+  const head = /^([a-zA-Z]{1,3})-/.exec(part)?.[1] ?? ''
+  const swapped = [...head].map(c => SWAPS[axis][c.toLowerCase()] ?? c).join('')
+  const named = head && swapped !== head && chain.every(p => p.startsWith(`${head}-`))
+  const hanging = chain.slice(1)
+  return {
+    hanging,
+    moves,
+    asks: hanging.length > 0 || moves,
+    form: { axis, chain: true, from: named ? `${head}-` : '', to: named ? `${swapped}-` : '', keepMotion: false }
+  }
+}
+
+/** The one edit the form comes to. */
+export function mirrorEditOf(part: string, form: MirrorForm): FigurePartEdit {
+  return {
+    kind: 'mirror-part',
+    target: part,
+    axis: form.axis,
+    ...(form.chain ? { chain: true } : {}),
+    ...(form.from && form.to && form.from !== form.to ? { prefix: { from: form.from, to: form.to } } : {}),
+    ...(form.keepMotion ? { keepMotion: true } : {})
+  }
 }
 
 /**

package/client/modeller/clips.ts

@@ -1,4 +1,4 @@
-import { driverValue } from '@hatiolab/figure-model'
+import { driverValue, figureShiftedDriverKeys } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureDriver, FigureInputChange } from '@hatiolab/figure-model'
 
 /*
@@ -111,12 +111,62 @@ export function withKey(keys: readonly ClipKey[], key: ClipKey): ClipKey[] {
   return [...keys.filter(k => k.seconds !== key.seconds), key].sort((a, b) => a.seconds - b.seconds)
 }
 
+/**
+ * A key typed where it stands: its moment, its value, or both. The first key stays at 0 (a track starts there); a moment
+ * outside the clip, or on another key's, is refused (null) rather than taking that key's place unseen.
+ */
+export function withKeyChanged(keys: readonly ClipKey[], index: number, patch: Partial<ClipKey>, duration: number): ClipKey[] | null {
+  const was = keys[index]
+  if (!was) return null
+  const next = { seconds: patch.seconds ?? was.seconds, value: patch.value ?? was.value }
+  if (!Number.isFinite(next.seconds) || !Number.isFinite(next.value)) return null
+  if (index === 0 && next.seconds !== 0) return null
+  if (next.seconds < 0 || next.seconds > duration) return null
+  if (keys.some((k, i) => i !== index && k.seconds === next.seconds)) return null
+  return keys.map((k, i) => (i === index ? next : k)).sort((a, b) => a.seconds - b.seconds)
+}
+
 /** A track's keys without one; a track keeps at least its two ends, as the format asks. */
 export function withoutKey(keys: readonly ClipKey[], index: number): ClipKey[] | null {
   if (keys.length <= 2 || index === 0) return null
   return keys.filter((_, i) => i !== index)
 }
 
+/** A name no clip has, for a copy: `walk-copy`, then `walk-copy-2`, … */
+export function freeClipNameOf(asset: FigureAsset, clip: string): string {
+  const taken = new Set((asset.drivers ?? []).map(d => d.clip))
+  const base = `${clip}-copy`
+  if (!taken.has(base)) return base
+  let n = 2
+  while (taken.has(`${base}-${n}`)) n++
+  return `${base}-${n}`
+}
+
+/** The controls a track of `clip` can be copied onto: those it plays already, and those it may take. */
+export const copyTargetsOf = (asset: FigureAsset, clip: string): string[] => [
+  ...new Set([...(asset.drivers ?? []).filter(d => d.clip === clip).map(d => d.state), ...undrivenOf(asset, clip)])
+]
+
+/** Whether a track can be moved round its loop: one that wraps and does not add up (figure-model's rule). */
+export const shiftable = (track: ClipTrack) => track.loop === 'wrap' && !track.accumulates
+
+/**
+ * A track copied onto `target` -- itself, or another control -- played `seconds` later round its loop (robot dog
+ * 2026-11-03: a leg's swing half a period after another's). One edit; a track the clip plays on `target` is replaced.
+ */
+export function copiedTrackEdit(asset: FigureAsset, clip: Clip, track: ClipTrack, target: string, seconds: number) {
+  const driver = (asset.drivers ?? []).find(d => d.clip === clip.name && d.state === track.state)!
+  return {
+    kind: 'set-driver' as const,
+    state: target,
+    clip: clip.name,
+    keys: seconds ? figureShiftedDriverKeys(driver, seconds) : track.keys,
+    loop: track.loop,
+    interpolation: track.interpolation,
+    accumulates: track.accumulates
+  }
+}
+
 /** The edit that writes a track back. */
 export const trackEdit = (clip: Clip, track: ClipTrack, patch: Partial<Pick<ClipTrack, 'keys' | 'loop' | 'interpolation'>> = {}) => ({
   kind: 'set-driver' as const,

package/client/modeller/data-interface.ts

@@ -390,6 +390,22 @@ export function sampleOf(
 /** The rows a person gives a value by hand, as a board's saved values: one value, read by a binding, not inside a list. */
 export const valueRowsOf = (asset: FigureAsset): FigureDataRow[] => schemaRowsOf(asset).filter(r => isValue(r.node) && r.bindings.length > 0 && !r.path.includes('[]'))
 
+/**
+ * What the data gives a row, read the way a placed figure reads its data: when it is there, it is what the figure shows,
+ * and a value saved by hand for the row is not read (things-scene's FigureDataReader: live data first). Undefined when
+ * the data leaves the row out, or gives it null.
+ */
+export function dataValueAt(data: unknown, path: string): unknown {
+  const steps = parseFigureAccessor(path)
+  if (!steps) return undefined
+  let at: unknown = data
+  for (const step of steps) {
+    if (at === null || typeof at !== 'object') return undefined
+    at = 'field' in step ? (at as Record<string, unknown>)[step.field] : (at as unknown[])[step.index]
+  }
+  return at === null ? undefined : at
+}
+
 /** A value typed or chosen for a row, as its kind reads it: a number (NaN when empty), true or false, or the text. */
 export function typedValueOf(node: FigureDataNode, typed: string): FigureDataValue {
   if (node.kind === 'number') return typed.trim() === '' ? Number.NaN : Number(typed)

package/client/modeller/editor-styles.ts

@@ -447,4 +447,10 @@ export const EditorStyles = css`
     color: var(--md-sys-color-on-surface-variant);
     line-height: 1.5;
   }
+  /* A mirror asked about: under its row, the panel's own field rows (what comes with it, its names, how it turns). */
+  div[mirror-form] {
+    display: grid;
+    gap: 6px;
+    margin: 4px 0 8px;
+  }
 `

package/client/modeller/editor.ts

@@ -8,7 +8,7 @@ import { openPopup } from '@operato/layout'
 import { OxPrompt } from '@operato/popup'
 import { customElement, property, state } from 'lit/decorators.js'
 import { live } from 'lit/directives/live.js'
-import { parseFigureAsset, figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, type FigurePlaneContact, figureRowOf, type FigureRowReading, figureFaceOverhangOf, type FigureFaceOverhang } from '@hatiolab/figure-model'
+import { parseFigureAsset, figureFastenAxesOf, figurePartFaceOf, PART_LIMIT, parseFigureRecipe, resolveFigureRecipe, figurePartCountOf, figurePartIdFor, figureRecipeIdFor, figureSizeEditOf, figureSizeEditorOf, figureSectionMeasuresOf, figurePlaneAlignChanges, type FigurePlaneContact, figureLayDownOf, figureHangingChainOf, figureRowOf, type FigureRowReading, figureFaceOverhangOf, type FigureFaceOverhang } from '@hatiolab/figure-model'
 import type { RecipeTemplate } from './recipes.js'
 import './figure-recipe-catalog.js'
 import type { FigureAsset, FigureAuthoringAction, FigureEvaluatedShape, FigureInputChange, FigurePartEdit, FigurePrimitiveCreation, FigureProposalStep, FigureRecipe, FigureRecipeValue, FigurePlacement, FigureFaceMappingNeed, FigureFaceRemap } from '@hatiolab/figure-model'
@@ -19,6 +19,7 @@ import './canvas.js'
 import './figure-parts.js'
 import './figure-material-panel.js'
 import './figure-section-panel.js'
+import './figure-pipe-panel.js'
 import './figure-section-editor.js'
 import { faceHighlightOf, rowWordsOf } from './command-preview.js'
 import { CommandPreview, NO_WORDS } from './command-preview-controller.js'
@@ -47,7 +48,7 @@ import { groupFields, ownerOf, partLabelOf, repeatOf, type FieldLike, type Field
 import { SidePanelStyles } from '@things-factory/figure-viewer/dist-client/side-panel-styles.js'
 import { EditorStyles } from './editor-styles.js'
 import { ScrollbarStyles } from '@operato/styles'
-import { alignChanges, canMirror, mirrorChanges, type AlignTool } from './align.js'
+import { alignChanges, canMirror, mirrorEditOf, mirrorPlanOf, type AlignTool, type MirrorForm } from './align.js'
 import type { FigurePaletteKind, FigurePartRow } from './figure-parts.js'
 import { paletteRecipe } from './palette.js'
 import { meshChoicesOf, meshPartOf } from './mesh-import.js'
@@ -65,7 +66,7 @@ import { nudgeOf, placementOf } from './stage-model.js'
 type HeldValues = { position?: number[]; rotation?: number[]; size?: (number | undefined)[]; sizeRuled?: boolean }
 import { gateFindingStyles, renderGateFinding } from './gate-findings.js'
 import type { FigureGateFinding } from '../types.js'
-import { editRefusalOf, partNameRefusalOf, sizeRangeFitsOf, partRefusalOf, placedRefusalOf, recipeRefusalOf, removalNoticeOf } from './refusals.js'
+import { defaultsMovedOf, editRefusalOf, partNameRefusalOf, sizeRangeFitsOf, partRefusalOf, placedRefusalOf, recipeRefusalOf, removalNoticeOf } from './refusals.js'
 import type { FigureRenderPart } from './renderer.js'
 import type { FigureBudgetLine } from './maturity.js'
 import { HelpToggles } from './help.js'
@@ -156,6 +157,8 @@ export class FigureEditor extends LitElement {
    * the tab or the middle changes under it.
    */
   @state() private fastening = false
+  /** A mirrored copy being asked about (with what hangs from it, under which names), for the part selected. */
+  @state() private mirroring?: { part: string; form: MirrorForm; hanging: string[]; moves: boolean }
   private fastenPopup?: { close: () => void }
   private fastenWindow?: HTMLElement & {
     revision?: FigureRevision
@@ -388,11 +391,12 @@ export class FigureEditor extends LitElement {
     return code ? editRefusalOf(error, (key, params) => i18next.t(key, params)) : error instanceof Error ? error.message : String(error)
   }
   private run(action: () => unknown) {
+    const before = this.shown()?.asset
     try {
       action()
       this.error = ''
-      /* The next step stands on its own: what the last removal let go of is no longer the news. */
-      this.notice = ''
+      /* The next step stands on its own: what the last removal let go of is no longer the news -- what this one moved is. */
+      this.notice = defaultsMovedOf(before, this.shown()?.asset, (key, params) => i18next.t(key, params))
       this.changed()
     } catch (error) {
       if (this.refusals.askClipLoss(error, () => this.run(action))) return
@@ -763,16 +767,54 @@ export class FigureEditor extends LitElement {
       if (changes.length) this.session!.apply(changes)
     })
   }
-  /** A mirrored copy: duplicate, then place the copy on the other side — two steps. */
+  /**
+   * A mirrored copy, one step: figure-model's mirror-part, a fastened part's record reflected with it. A part with parts
+   * hanging from it, or moving, is asked about first -- what comes with it, its names, how it turns (robot dog 2026-11-03).
+   */
   private mirror(axis: 'x' | 'z') {
+    const plan = mirrorPlanOf(this.shown()!.asset, this.selected, axis)
+    if (plan.asks) this.mirroring = { part: this.selected, form: plan.form, hanging: plan.hanging, moves: plan.moves }
+    else this.mirrorWith(this.selected, plan.form)
+  }
+  private mirrorWith(part: string, form: MirrorForm) {
     this.run(() => {
-      const id = this.selected
-      const copy = this.session!.edit({ kind: 'duplicate-part', target: id }).made?.[0]
-      if (!copy) return
-      this.session!.apply(mirrorChanges(this.shown()!, id, copy, axis))
-      this.selected = copy
+      /* The copy of the part itself, the first of what the edit made. */
+      const copy = this.session!.edit(mirrorEditOf(part, form)).made?.[0]
+      this.mirroring = undefined
+      if (copy) this.selected = copy
     })
   }
+  private renderMirrorForm(unavailable: boolean) {
+    const m = this.mirroring
+    if (!m || m.part !== this.selected) return nothing
+    const set = (patch: Partial<MirrorForm>) => (this.mirroring = { ...m, form: { ...m.form, ...patch } })
+    const text = (key: 'from' | 'to') => (e: Event) => set({ [key]: (e.target as HTMLInputElement).value.trim() })
+    return html`<div mirror-form>
+      ${m.hanging.length
+        ? html`<label toggle>
+            <input type="checkbox" .checked=${m.form.chain} @change=${(e: Event) => set({ chain: (e.target as HTMLInputElement).checked })} />
+            ${i18next.t('figure.label.mirror-with-hanging', { count: m.hanging.length })}
+          </label>`
+        : nothing}
+      <div form>
+        <span>${i18next.t('figure.label.mirror-names')}</span>
+        <div pair>
+          <input aria-label=${i18next.t('figure.label.mirror-names-from')} placeholder=${i18next.t('figure.label.mirror-names-from')} .value=${m.form.from} @change=${text('from')} />
+          <input aria-label=${i18next.t('figure.label.mirror-names-to')} placeholder=${i18next.t('figure.label.mirror-names-to')} .value=${m.form.to} @change=${text('to')} />
+        </div>
+      </div>
+      ${m.moves
+        ? html`<label toggle title=${i18next.t('figure.text.mirror-keep-motion-explained')}>
+            <input type="checkbox" .checked=${m.form.keepMotion} @change=${(e: Event) => set({ keepMotion: (e.target as HTMLInputElement).checked })} />
+            ${i18next.t('figure.label.mirror-keep-motion')}
+          </label>`
+        : nothing}
+      <div pair>
+        <button act ?disabled=${unavailable} @click=${() => this.mirrorWith(m.part, m.form)}>${i18next.t('figure.button.mirror-' + m.form.axis)}</button>
+        <button act @click=${() => (this.mirroring = undefined)}>${i18next.t('figure.button.cancel')}</button>
+      </div>
+    </div>`
+  }
   /**
    * The one-off "put it on the plane", by the figure's placement (designer 2026-09-27): figure-model's rule
    * (`figurePlaneAlignChanges`) -- a floor figure's part to the floor by its bottom, a ceiling one's to the ceiling by
@@ -790,16 +832,29 @@ export class FigureEditor extends LitElement {
       }
     })
   }
+  /*
+    A part with parts hanging from it, or one on the mounting plane, is put down as a whole: the lowest point of all of it,
+    as it stands, reaches the plane -- a body by its feet (robot dog 2026-11-03).
+  */
+  private laysDownWhole(asset: FigureAsset, part: string) {
+    return figureHangingChainOf(asset, part).length > 1 || !!asset.joints?.some(j => 'plane' in j.body0 && 'part' in j.body1 && j.body1.part === part)
+  }
   private renderPlaneAlign(shown: FigureRevision, unavailable: boolean) {
     const placement = shown.asset.placement ?? 'floor'
     /* A tilted part touches the plane at a point or an edge, a ball at its lowest; the tooltip says so rather than promise a face (designer 2026-09-27). */
-    const contact = this.planeContactOf(shown, this.selected)
-    const told = contact === 'tilted' || contact === 'extreme' ? `-${contact}` : ''
+    const contact = this.laysDownWhole(shown.asset, this.selected) ? 'hanging' : this.planeContactOf(shown, this.selected)
+    const told = contact === 'tilted' || contact === 'extreme' || contact === 'hanging' ? `-${contact}` : ''
     return html`<button plane-align=${placement} ?disabled=${unavailable} title=${i18next.t(`figure.text.align-to-${placement}${told}`)}
       @click=${() => this.alignToPlane()}>${i18next.t(`figure.button.align-to-${placement}`)}</button>`
   }
   private alignToPlane() {
     const asset = this.shown()!.asset
+    if (this.laysDownWhole(asset, this.selected)) {
+      const { command, refusal } = figureLayDownOf(asset, this.selected)
+      if (refusal) this.error = i18next.t(`figure.text.align-refused-${refusal.toLowerCase().replace(/_/g, '-')}`, { part: partLabelOf(this.selected) })
+      else if (command) this.run(() => this.session!.command(command))
+      return
+    }
     const { changes, contact, refusal } = figurePlaneAlignChanges(asset, this.selected)
     if (refusal) {
       this.error = i18next.t(`figure.text.align-refused-${refusal.toLowerCase().replace(/_/g, '-')}`, { part: partLabelOf(this.selected) })
@@ -811,23 +866,33 @@ export class FigureEditor extends LitElement {
   private renderTools(unavailable: boolean) {
     const reach = this.reachOf(this.selected)
     const shown = this.shown()
-    if (!this.selected || !reach.translate || !shown) return null
+    if (!this.selected || !shown) return null
     /*
      * In words, two rows by what they do (user 2026-10-01: 「무엇을 하는 것인지 모르겠다」): moving the part to the figure's
      * centre lines, onto its plane or onto the grid; and making a mirrored copy, which makes a part and moves nothing.
      */
     const tool = (name: AlignTool, label: string, title: string) =>
       html`<button ?disabled=${unavailable} title=${i18next.t(title)} @click=${() => this.align(name)}>${i18next.t(label)}</button>`
-    const mirrors = (['x', 'z'] as const).map(axis => ({ axis, able: canMirror(shown, this.selected, axis, reach) }))
-    return html`<div vector-row>
-        <label>${i18next.t('figure.label.tools')}</label>
-        <div tools>
-          ${tool('centre-x', 'figure.button.center-x', 'figure.text.center-on-x')}
-          ${tool('centre-z', 'figure.button.center-z', 'figure.text.center-on-z')}
-          ${this.renderPlaneAlign(shown, unavailable)}
-          ${tool('snap', 'figure.button.snap', 'figure.text.snap-explained')}
-        </div>
-      </div>
+    /* A fastened part is not moved by these tools, but it is mirrored: the copy's fastening is reflected with it. */
+    const mirrors = (['x', 'z'] as const).map(axis => ({ axis, able: canMirror(shown, this.selected, axis) }))
+    /* On the mounting plane nothing else here moves it; putting it down writes its gap. */
+    const onPlane = !reach.translate && !!shown.asset.joints?.some(j => 'plane' in j.body0 && 'part' in j.body1 && j.body1.part === this.selected)
+    return html`${onPlane
+        ? html`<div vector-row>
+            <label>${i18next.t('figure.label.tools')}</label>
+            <div tools>${this.renderPlaneAlign(shown, unavailable)}</div>
+          </div>`
+        : nothing}${reach.translate
+        ? html`<div vector-row>
+            <label>${i18next.t('figure.label.tools')}</label>
+            <div tools>
+              ${tool('centre-x', 'figure.button.center-x', 'figure.text.center-on-x')}
+              ${tool('centre-z', 'figure.button.center-z', 'figure.text.center-on-z')}
+              ${this.renderPlaneAlign(shown, unavailable)}
+              ${tool('snap', 'figure.button.snap', 'figure.text.snap-explained')}
+            </div>
+          </div>`
+        : null}
       <div vector-row>
         <label>${i18next.t('figure.label.mirror-copy')}</label>
         <div tools>
@@ -838,6 +903,7 @@ export class FigureEditor extends LitElement {
           )}
         </div>
       </div>
+      ${this.renderMirrorForm(unavailable)}
 `
   }
   /**
@@ -912,6 +978,21 @@ export class FigureEditor extends LitElement {
     const place = groups.vectors.filter(g => g.kind === 'vector' && g.name !== 'size')
     const fastened = !!this.asset()?.joints?.some(j => j.body1.part === ownerOf(this.selected))
     const placeLocked = fastened && place.every(g => g.kind === 'vector' && (['x', 'y', 'z'] as const).every(axis => !g.cells[axis]))
+    /* A pipe's measures are its section, wall and path, in its own panel (ADR-0100 §16.2): not raw fields of the part. */
+    const body = geometry.find(g => g.id === this.selected) as { id: string; shape?: FigureEvaluatedShape } | undefined
+    if (body?.shape?.sweep)
+      return this.renderLinks(
+        unavailable,
+        'shape',
+        html`<section slot="size" group-fields>
+            <h3>${i18next.t('figure.label.group-pipe')}</h3>
+            <!-- Its command reaches the links' own handler: it is slotted in them. -->
+            <figure-pipe-panel .body=${body} ?locked=${unavailable}></figure-pipe-panel>
+          </section>
+          ${place.length && !placeLocked
+            ? html`<div slot="place" group-fields>${place.map(g => this.renderVector(g, unavailable, held))}${this.renderHeldAxes(place)}</div>`
+            : nothing}`
+      )
     return this.renderLinks(
       unavailable,
       'shape',
@@ -1065,12 +1146,18 @@ export class FigureEditor extends LitElement {
     this.holdAction(null)
     this.notice = ''
     const hadSize = this.hasSize()
+    const before = this.shown()?.asset
     try {
       this.session!.command(action)
       this.error = ''
       this.faceMapping = undefined
-      /* What the command did besides what was asked, in one line: the figure's size declared to follow (ADR ruling Q1). */
+      /*
+        What the command did besides what was asked, in one line: the figure's size declared to follow (ADR ruling Q1), a
+        default pose its new range moved.
+      */
       if (action.kind === 'follow-size' && !hadSize) this.notice = this.sizeDeclaredWords()
+      const moved = defaultsMovedOf(before, this.shown()?.asset, (key, params) => i18next.t(key, params))
+      if (moved) this.notice = [this.notice, moved].filter(Boolean).join(' ')
       this.changed()
       return true
     } catch (error) {

package/client/modeller/fasten-form.ts

@@ -1,7 +1,7 @@
 import { FIGURE_FACES, figureFastenKeptGapOf, figureFastenTargetAt, figurePlaneFacingOf, figureSurfaceKeptPlaceOf } from '@hatiolab/figure-model'
 import type { FigureAuthoringAction, FigureFace, FigureSurfacePlace } from '@hatiolab/figure-model'
 
-import { faceViewOf, type FaceView, type FastenMode, type FastenTarget } from './fasten-geometry.js'
+import { faceViewOf, facesAsDrawnOf, type FaceView, type FastenMode, type FastenTarget } from './fasten-geometry.js'
 import type { FastenChange } from './figure-fasten-drawing.js'
 import {
   alignOf,
@@ -192,9 +192,16 @@ export interface FastenPlan {
   face?: { part: string; face: string }
   /** On a point of the target's curved surface: which surface, about which axis, and where (ADR-0140 3.9). */
   surface?: { form: 'around' | 'toward'; axis: Axis; place: FigureSurfacePlace }
+  /** The target's own face at each of the drawing's places, as the target is drawn (\`facesAsDrawnOf\`). */
+  drawnFaces?: Record<FigureFace, FigureFace>
 }
 
 export function fastenPlanOf(revision: FigureRevision, part: string, f: FastenForm): FastenPlan {
+  const plan = fastenPlanWithout(revision, part, f)
+  return f.target && !f.toPlane ? { ...plan, drawnFaces: facesAsDrawnOf(revision, f.target) } : plan
+}
+
+function fastenPlanWithout(revision: FigureRevision, part: string, f: FastenForm): FastenPlan {
   const asset = revision.asset
   const theirFaces = f.target ? facesOf(asset, f.target) : FACES
   const targetFace = (theirFaces.includes(f.targetFace) ? f.targetFace : theirFaces[0]) as FigureFace

package/client/modeller/fasten-geometry.ts

@@ -1,5 +1,5 @@
-import { figureFaceInsideAlignOf, figureFaceMeasureOf, figureFaceOverhangAt, figureFastenPlaceOf } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureFaceMeasure, FigureFacing, FigureFastenAlignment } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureFaceInsideAlignOf, figureFaceMeasureOf, figureFaceOverhangAt, figureFastenPlaceOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureFace, FigureFaceMeasure, FigureFacing, FigureFastenAlignment } from '@hatiolab/figure-model'
 
 import { alignAxesOf, type Alignment } from './links.js'
 import type { FigureRevision } from './revision.js'
@@ -16,6 +16,28 @@ type Axis = 'x' | 'y' | 'z'
 export type FastenMode = FigureFacing
 export type FastenTarget = { part: string; face: string } | 'plane'
 
+/* Which way each of the six faces looks, along its axis, in a part's own frame. */
+const OUTWARD: Record<FigureFace, number> = { left: -1, right: 1, bottom: -1, top: 1, back: -1, front: 1 }
+const SIX = Object.keys(OUTWARD) as FigureFace[]
+
+/**
+ * The target's own face that stands at each of the drawing's six places as the part is drawn (robot dog, 2026-11-03):
+ * a face is named in its part's own frame, so a cylinder laid on its side has its 「아래」 on the side, and the box drawn
+ * upright showed the name where the face is not. Each place -- up, down, right, left, toward the eye, away -- shows the
+ * own face whose outward normal, turned by the part's pose, points most that way. Unturned, each is itself.
+ */
+export function facesAsDrawnOf(revision: FigureRevision, target: string): Record<FigureFace, FigureFace> {
+  const drawn = (revision.geometry as Array<{ id: string; pose?: { r: number[][] } }>).find(g => g.id === target)?.pose?.r
+  const same = Object.fromEntries(SIX.map(f => [f, f])) as Record<FigureFace, FigureFace>
+  if (!drawn) return same
+  const index = { x: 0, y: 1, z: 2 } as const
+  /* World direction of an own face: its column of the pose, outward. */
+  const world = (f: FigureFace) => [0, 1, 2].map(i => OUTWARD[f] * drawn[i]![index[FIGURE_FACES[f] as Axis]]!)
+  const along = (place: FigureFace) => [0, 1, 2].map(i => (i === index[FIGURE_FACES[place] as Axis] ? OUTWARD[place] : 0))
+  const dot = (a: number[], b: number[]) => a.reduce((sum, v, i) => sum + v * b[i]!, 0)
+  return Object.fromEntries(SIX.map(place => [place, SIX.reduce((best, f) => (dot(world(f), along(place)) > dot(world(best), along(place)) ? f : best))])) as Record<FigureFace, FigureFace>
+}
+
 /**
  * The face seen from above: its two axes across (as the form's alignment names them), the face's size on each as a
  * fastening lines up to it -- none for a plane with no declared size -- the part's real extent on each, whether its