@things-factory/figure-ui 10.1.200 → 10.1.201

package/client/modeller/editor.ts

@@ -1442,12 +1442,15 @@ export class FigureEditor extends LitElement {
     return derivedOf(shown, `overhang|${part}|${i18next.language}`, () => {
       const asset = shown.asset
       const say = (k: string, params?: Record<string, string>) => i18next.t(k, params)
-      const where = (o: FigureFaceOverhang) => ({ on: partLabelOf(o.on.part), face: say(`figure.label.face-${o.on.face}`) })
+      const where = (o: FigureFaceOverhang & { on: { part: string; face: string } }) => ({ on: partLabelOf(o.on.part), face: say(`figure.label.face-${o.on.face}`) })
+      /* On another part's face: the plane's edges are the figure's room, said where the room is. */
+      const onPart = (o: FigureFaceOverhang | undefined): o is FigureFaceOverhang & { on: { part: string; face: string } } => !!o && o.on !== 'plane'
       const sides = (o: FigureFaceOverhang) => o.sides.map(s => say(`figure.text.overhang-side-${s.side}`, { axis: s.axis.toUpperCase(), mm: String(s.mm) })).join(', ')
       const words: string[] = []
       const note: string[] = []
       try {
-        const own = figureFaceOverhangOf(asset, part, shown.inputs)
+        const found = figureFaceOverhangOf(asset, part, shown.inputs)
+        const own = onPart(found) ? found : undefined
         if (own?.state === 'larger') {
           note.push(say('figure.text.overhang-larger', { ...where(own), sides: sides(own) }))
           if (own.lopsided.length) note.push(say('figure.text.overhang-lopsided', { axes: own.lopsided.map(a => a.toUpperCase()).join(', ') }))
@@ -1455,8 +1458,9 @@ export class FigureEditor extends LitElement {
         if (own?.state === 'out') words.push(say('figure.text.overhang-out', { ...where(own), sides: sides(own) }))
         else if (own?.state === 'possible') words.push(say('figure.text.overhang-possible', where(own)))
         else if (own?.state === 'unknown') words.push(say('figure.text.overhang-unknown', where(own)))
+        if (own?.contact === 'off') words.push(say('figure.text.overhang-off', where(own)))
         const held = (asset.joints ?? []).filter(j => 'part' in j.body0 && j.body0.part === part).map(j => figureFaceOverhangOf(asset, j.body1.part, shown.inputs))
-        const past = held.filter((o): o is FigureFaceOverhang => o?.state === 'out' || o?.state === 'possible')
+        const past = held.filter((o): o is FigureFaceOverhang => o?.state === 'out' || o?.state === 'possible' || o?.contact === 'off')
         if (past.length) words.push(say('figure.text.overhang-held', { parts: past.map(o => partLabelOf(o.part)).join(', ') }))
       } catch {
         /* Not read: nothing said rather than a guess. */

package/client/modeller/fasten-form.ts

@@ -1,7 +1,7 @@
 import { FIGURE_FACES } from '@hatiolab/figure-model'
 import type { FigureAuthoringAction, FigureFace } from '@hatiolab/figure-model'
 
-import { faceViewOf, modeOf, myFaceFor, type FaceView, type FastenMode, type FastenTarget } from './fasten-geometry.js'
+import { faceViewOf, type FaceView, type FastenMode, type FastenTarget } from './fasten-geometry.js'
 import type { FastenChange } from './figure-fasten-drawing.js'
 import {
   alignOf,
@@ -12,7 +12,7 @@ import {
   fastenGapOf,
   hangsFrom,
   heldBy,
-  ownFacesOf,
+  mountingPlaneOf,
   placeKeptOf,
   type Alignment,
   type Axis
@@ -20,7 +20,7 @@ import {
 import type { FigureRevision } from './revision.js'
 
 /*
- * A fastening as it is chosen, before it is done: what, which face, how, where across the face. The fastening window
+ * A fastening as it is chosen, before it is done: to what, which face, how, where across the face. The fastening window
  * (`figure-fasten-dialog.ts`) holds one and changes it as the author chooses; the attach command is worked out from it
  * only here, so the window, its preview and the panel's 「정렬 고치기」 send the same command for the same choice.
  */
@@ -28,29 +28,26 @@ import type { FigureRevision } from './revision.js'
 const FACES = Object.keys(FIGURE_FACES) as FigureFace[]
 
 export interface FastenForm {
-  face: FigureFace | 'centre'
   toPlane: boolean
   target: string
   targetFace: FigureFace
-  facing: 'meet' | 'flush'
+  /** How it meets the face: its near end on it, its far end on it (flush), or its middle (ADR-0140 3.11). */
+  facing: FastenMode
   gap: number
   /** The record's gap when it is worked out (a length that follows something): kept until a number is typed. */
   gapKept: unknown
-  twist: number
   align: Partial<Record<Axis, Alignment>>
   alignMm: Partial<Record<Axis, number>>
   alignInput: Partial<Record<Axis, string>>
 }
 
 export const freshFasten = (): FastenForm => ({
-  face: 'bottom',
   toPlane: false,
   target: '',
   targetFace: 'top',
   facing: 'meet',
   gap: 0,
   gapKept: undefined,
-  twist: 0,
   align: {},
   alignMm: {},
   alignInput: {}
@@ -97,7 +94,7 @@ export function aimFasten(
     : f.target
       ? { part: f.target, face: targetFace }
       : undefined
-  return { ...f, ...(aim ? placeKeptOf(revision, part, aim, !!f.twist) : { align: {}, alignMm: {}, alignInput: {} }) }
+  return { ...f, ...(aim ? placeKeptOf(revision, part, aim) : { align: {}, alignMm: {}, alignInput: {} }) }
 }
 
 /** A change the drawing asks: a face, a way, a gap or a place across the face. */
@@ -109,12 +106,7 @@ export function fastenChanged(
 ): FastenForm {
   const f = form
   if ('targetFace' in change) return aimFasten(revision, part, f, { targetFace: change.targetFace as FigureFace })
-  if ('mode' in change)
-    return {
-      ...f,
-      face: change.mode === 'centre' ? 'centre' : f.face === 'centre' ? 'bottom' : f.face,
-      facing: change.mode === 'flush' ? 'flush' : 'meet'
-    }
+  if ('mode' in change) return { ...f, facing: change.mode }
   if ('gap' in change) return { ...f, gap: change.gap, gapKept: undefined }
   return {
     ...f,
@@ -123,15 +115,13 @@ export function fastenChanged(
   }
 }
 
-/** What a form comes to: the face aimed at, the part's own face, the way, the drawing of the face and the command. */
+/** What a form comes to: the face aimed at, the way, the drawing of the face and the command. */
 export interface FastenPlan {
   /** Nothing is aimed at until a part or the plane is chosen. */
   aim?: FastenTarget
   theirFaces: string[]
   targetFace: FigureFace
   mode: FastenMode
-  /** The part's own face: not chosen, the target's face and the way give it (user 2026-10-01; the kernel takes no other). */
-  myFace: FigureFace | 'centre'
   view?: FaceView
   /** The axes across the face asked in rows: where the drawing cannot set the place. */
   alignRows: { axis: Axis; edges: boolean }[]
@@ -142,7 +132,6 @@ export interface FastenPlan {
 
 export function fastenPlanOf(revision: FigureRevision, part: string, f: FastenForm): FastenPlan {
   const asset = revision.asset
-  const mineFaces = ownFacesOf(asset, part, f.toPlane)
   const theirFaces = f.target ? facesOf(asset, f.target) : FACES
   const targetFace = (theirFaces.includes(f.targetFace) ? f.targetFace : theirFaces[0]) as FigureFace
   const aim: FastenTarget | undefined = f.toPlane
@@ -150,20 +139,17 @@ export function fastenPlanOf(revision: FigureRevision, part: string, f: FastenFo
     : f.target
       ? { part: f.target, face: targetFace }
       : undefined
-  const mode: FastenMode = f.toPlane ? 'meet' : modeOf(f.face, f.facing)
-  const derived = aim ? myFaceFor(revision, part, aim, mode) : undefined
-  const myFace = derived ?? (mineFaces.includes(f.face) ? f.face : mineFaces[0]!)
-  if (!aim) return { theirFaces, targetFace, mode, myFace, alignRows: [] }
-  const align = alignOf(asset, part, aim, f.align, f.alignMm, !!f.twist, f.alignInput)
-  const view = faceViewOf(revision, part, aim)
+  /* The plane takes a part standing on it or hanging below it, a wall only one standing out of it (ADR-0140 3.11). */
+  const mode: FastenMode = f.toPlane ? (mountingPlaneOf(asset).facings.includes(f.facing) ? f.facing : 'meet') : f.facing
+  if (!aim) return { theirFaces, targetFace, mode, alignRows: [] }
+  const align = alignOf(asset, aim, f.align, f.alignMm, f.alignInput)
+  const view = faceViewOf(revision, part, aim, mode)
   const action = {
     kind: 'attach',
     part,
-    face: myFace,
     to: f.toPlane ? { plane: 'mounting-plane' } : { part: f.target, face: targetFace },
-    ...(f.toPlane ? {} : { facing: f.facing }),
+    ...(f.toPlane ? (mode === 'flush' ? { facing: mode } : {}) : { facing: mode }),
     ...fastenGapOf(f),
-    twist: f.twist,
     ...(align ? { align } : {}),
     replace: !!heldBy(asset, part)
   } as FigureAuthoringAction
@@ -172,9 +158,8 @@ export function fastenPlanOf(revision: FigureRevision, part: string, f: FastenFo
     theirFaces,
     targetFace,
     mode,
-    myFace,
     view,
-    alignRows: alignRowsOf(asset, part, aim, view, !!f.twist, f.alignInput),
+    alignRows: alignRowsOf(asset, aim, view, f.alignInput),
     action,
     ...(f.toPlane ? {} : { face: { part: f.target, face: targetFace } })
   }
@@ -182,16 +167,15 @@ export function fastenPlanOf(revision: FigureRevision, part: string, f: FastenFo
 
 type Say = (key: string, params?: Record<string, string>) => string
 
-/** 「lid 의 아랫면을 bin 의 윗면에 맞닿게」: what the fastening is, in one line, the part's own face said as a result. */
+/** 「bin의 윗면에 올려놓기」: what the fastening is, in one line -- the part is the one the window is open on, not named again. */
 export function fastenSentenceOf(
-  part: string,
   form: FastenForm,
   plan: FastenPlan,
   planeWord: string,
   say: Say
 ): string {
   const to = form.toPlane ? planeWord : `${form.target}의 ${say('figure.label.face-' + plan.targetFace)}`
-  return say(`figure.text.fasten-sentence-${plan.mode}`, { part, face: say('figure.label.face-' + plan.myFace), to })
+  return say(`figure.text.fasten-sentence-${plan.mode}`, { to })
 }
 
 /** What the folded details hold that is not their default, said while folded; nothing for the default. */
@@ -201,7 +185,6 @@ export function fastenDetailWordsOf(form: FastenForm, say: Say): string[] {
       ? [say('figure.text.fasten-summary-gap-worked-out')]
       : form.gap
         ? [say('figure.text.fasten-summary-gap', { mm: String(form.gap) })]
-        : []),
-    ...(form.twist ? [say('figure.text.fasten-summary-twist', { degrees: String(form.twist) })] : [])
+        : [])
   ]
 }

package/client/modeller/fasten-geometry.ts

@@ -1,108 +1,67 @@
-import { figurePartFaceOf } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureFace } from '@hatiolab/figure-model'
+import { figureFaceInsideAlignOf, figureFaceMeasureOf, figureFaceOverhangAt, figureFastenPlaceOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureFaceMeasure, FigureFacing, FigureFastenAlignment } from '@hatiolab/figure-model'
 
-import { boxOf } from './align.js'
-import { alignAxesOf, facesOf, faceAxisOf, hasInstanceSize, mountingPlaneOf, type Alignment } from './links.js'
+import { alignAxesOf, type Alignment } from './links.js'
 import type { FigureRevision } from './revision.js'
 
 /*
  * What the 붙이기 drawing reads (user 2026-10-01): the face a part is fastened to, seen from above, and where the part
- * lies on it. A fastening is chosen by the target's face and how (올려놓기 · 같은 면에 맞추기 · 가운데를 면에); the part's
- * own face follows from those -- the kernel takes no other pairing (figure-model `attach`: meet is the facing face,
- * flush the same one, a face along another axis would need a turn).
+ * lies on it. A fastening is chosen by the target's face and how (올려놓기 · 같은 면에 맞추기 · 가운데를 면에); the part
+ * meets it by its real shape in the pose it has, by no face of its own (ADR-0140 3.2). What is measured -- the face,
+ * the part's extent across it, how far it comes past and whether what touches is on it -- is the kernel's
+ * (`figureFaceMeasureOf`, 3.8); this only draws it.
  */
 
 type Axis = 'x' | 'y' | 'z'
-const AXES: Axis[] = ['x', 'y', 'z']
-export type FastenMode = 'meet' | 'flush' | 'centre'
+export type FastenMode = FigureFacing
 export type FastenTarget = { part: string; face: string } | 'plane'
 
-const OPPOSITE: Record<FigureFace, FigureFace> = { left: 'right', right: 'left', bottom: 'top', top: 'bottom', back: 'front', front: 'back' }
-const NORMAL: Record<FigureFace, [Axis, 1 | -1]> = { left: ['x', -1], right: ['x', 1], bottom: ['y', -1], top: ['y', 1], back: ['z', -1], front: ['z', 1] }
-
-/** The world direction a part's face looks along now, as drawn, turns and all; by its name when the face's outline is not read. */
-function directionOf(revision: FigureRevision, part: string, face: string): [Axis, 1 | -1] | undefined {
-  const area = (() => {
-    try {
-      return figurePartFaceOf(revision.asset, part, face, revision.inputs)
-    } catch {
-      return undefined
-    }
-  })()
-  if (area) {
-    const k = area.normal.findIndex(v => Math.abs(v) > 0.5)
-    if (k >= 0) return [AXES[k]!, area.normal[k]! > 0 ? 1 : -1]
-  }
-  return face in NORMAL ? NORMAL[face as FigureFace] : undefined
-}
-
-/**
- * The part's own face a fastening takes: the one looking against the target's face (올려놓기), with it (같은 면), or its
- * centre. Read from where each face looks now, so a part standing turned offers the face that is really there.
- * Undefined when the part has no such face.
- */
-export function myFaceFor(revision: FigureRevision, part: string, target: FastenTarget, mode: FastenMode): FigureFace | 'centre' | undefined {
-  const asset = revision.asset
-  if (mode === 'centre') return target === 'plane' ? undefined : 'centre'
-  const want: [Axis, 1 | -1] | undefined =
-    target === 'plane'
-      ? /* The plane is met from above on a floor, from in front on a wall. */ [mountingPlaneOf(asset).normal, -1]
-      : (() => {
-          const d = directionOf(revision, target.part, target.face)
-          return d && [d[0], (mode === 'meet' ? -d[1] : d[1]) as 1 | -1]
-        })()
-  if (!want) return undefined
-  const mine = facesOf(asset, part).filter((f): f is FigureFace => f in NORMAL)
-  const hit = mine.find(f => {
-    const d = directionOf(revision, part, f)
-    return d && d[0] === want[0] && d[1] === want[1]
-  })
-  return hit ?? (target !== 'plane' && mode === 'meet' && target.face in OPPOSITE ? OPPOSITE[target.face as FigureFace] : undefined)
-}
-
-/** Which way the fastening is, read back from the part's face and facing. */
-export const modeOf = (face: string, facing: 'meet' | 'flush'): FastenMode => (face === 'centre' ? 'centre' : facing)
-
 /**
- * The face seen from above: its two axes across (as the form's alignment names them), the face's size on each -- none
- * for a plane with no declared size -- the part's footprint on each, and whether its edges can be lined up with.
+ * 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
+ * edges can be lined up with, and the kernel's measure the drawing asks again as the part is moved.
  */
 export interface FaceView {
   axes: [Axis, Axis]
   face: Partial<Record<Axis, number>>
   part: Record<Axis, number>
   edges: Record<Axis, boolean>
+  measure: FigureFaceMeasure
 }
 
-export function faceViewOf(revision: FigureRevision, part: string, target: FastenTarget): FaceView | undefined {
-  const asset = revision.asset
-  const across = alignAxesOf(asset, part, target)
-  if (across.length !== 2) return undefined
-  const box = boxOf(revision, part)
-  if (!box) return undefined
-  const axes = [across[0]!.axis, across[1]!.axis] as [Axis, Axis]
+export function faceViewOf(revision: FigureRevision, part: string, target: FastenTarget, facing: FastenMode): FaceView | undefined {
+  const measure = (() => {
+    try {
+      return figureFaceMeasureOf(revision.asset, part, revision.inputs, { on: target, facing })
+    } catch {
+      return undefined
+    }
+  })()
+  if (!measure) return undefined
+  const across = alignAxesOf(revision.asset, target)
   const face: Partial<Record<Axis, number>> = {}
-  if (target === 'plane') {
-    for (const a of axes) if (hasInstanceSize(asset, a)) face[a] = asset.designInputs[`size.${a}`]!
-  } else {
-    const theirs = boxOf(revision, target.part)
-    const normal = faceAxisOf(asset, target.part, target.face)
-    for (const a of axes) if (theirs && a !== normal) face[a] = theirs.extent[a]
+  for (const a of measure.axes) {
+    const e = measure.edges[a]
+    if (e) face[a] = e.hi - e.lo
   }
+  const extent = (a: Axis) => measure.extent[a].hi - measure.extent[a].lo
   return {
-    axes,
+    axes: measure.axes,
     face,
-    part: { x: box.extent.x, y: box.extent.y, z: box.extent.z },
-    edges: Object.fromEntries(across.map(o => [o.axis, o.edges])) as Record<Axis, boolean>
+    part: { x: extent('x'), y: extent('y'), z: extent('z') },
+    edges: Object.fromEntries(measure.axes.map(a => [a, !!across.find(o => o.axis === a)?.edges])) as Record<Axis, boolean>,
+    measure
   }
 }
 
-/** Where the part's centre is from the face's centre along one axis, for the way it is aligned there. */
+/**
+ * Where the part's centre is from the face's centre along one axis, for the way it is aligned there: the kernel's
+ * `figureFastenPlaceOf` (ADR-0140 D2), the form's distances -- typed, or a share of the size read as millimetres -- as
+ * a distance, a position field's as the centre.
+ */
 export function offsetOf(how: Alignment | undefined, mm: number | undefined, face: number | undefined, part: number): number {
-  if (how === 'min' && face !== undefined) return -(face - part) / 2
-  if (how === 'max' && face !== undefined) return (face - part) / 2
-  if (how === 'mm' || how === 'share') return mm ?? 0
-  return 0
+  const align = how === 'mm' || how === 'share' ? { mm: mm ?? 0 } : how === 'min' || how === 'max' || how === 'centre' ? how : undefined
+  return figureFastenPlaceOf({ align: { x: align }, face: { x: face }, part: { x: part } }).x!
 }
 
 /**
@@ -125,56 +84,49 @@ export function alignmentAt(d: number, face: number | undefined, part: number, e
   return { how: 'mm', mm: Math.round(d) }
 }
 
+/** The form's alignment on each axis across the face, in the kernel's words: a typed or shared distance as millimetres. */
+function kernelAlignOf(view: FaceView, align: Partial<Record<Axis, Alignment>>, alignMm: Partial<Record<Axis, number>>): Partial<Record<Axis, FigureFastenAlignment>> {
+  const out: Partial<Record<Axis, FigureFastenAlignment>> = {}
+  for (const a of view.axes) {
+    const how = align[a] ?? 'centre'
+    out[a] = how === 'mm' || how === 'share' ? { mm: alignMm[a] ?? 0 } : how === 'min' || how === 'max' ? how : 'centre'
+  }
+  return out
+}
+
 /**
- * The alignment that brings the footprint inside the face, for 정렬·간격 고치기: on each axis it comes past an edge, the
- * least move -- to that edge from inside (`min` / `max`, or that distance where edges are not offered) -- or the centre
- * when the part is wider than the face and cannot be inside. `inside` when nothing of it is past an edge: what is out
- * is something fastened on it. `unmeasured` when the face has no size to measure against.
+ * The alignment that brings the part inside the face, for 정렬·간격 고치기: the kernel's least move
+ * (`figureFaceInsideAlignOf`), in the form's words. `inside` when nothing of it is past an edge: what is out is something
+ * fastened on it. `unmeasured` when the face has no size to measure against.
  */
 export function insideAlignmentOf(
   view: FaceView | undefined,
   align: Partial<Record<Axis, Alignment>>,
   alignMm: Partial<Record<Axis, number>>
 ): { align: Partial<Record<Axis, Alignment>>; alignMm: Partial<Record<Axis, number>>; moved: Axis[] } | { cannot: 'inside' | 'unmeasured' } {
-  if (!view || view.axes.some(a => view.face[a] === undefined)) return { cannot: 'unmeasured' }
-  const next = { align: { ...align }, alignMm: { ...alignMm }, moved: [] as Axis[] }
-  for (const a of view.axes) {
-    const face = view.face[a]!,
-      part = view.part[a]
-    const at = offsetOf(align[a], alignMm[a], face, part)
-    const low = -face / 2 - (at - part / 2) > 0.5,
-      high = at + part / 2 - face / 2 > 0.5
-    if (!low && !high) continue
-    next.moved.push(a)
-    if (part > face) {
-      next.align[a] = 'centre'
-      continue
-    }
-    const edge = ((low ? -1 : 1) * (face - part)) / 2
-    if (view.edges[a]) next.align[a] = low ? 'min' : 'max'
-    else ((next.align[a] = 'mm'), (next.alignMm[a] = Math.round(edge)))
+  if (!view) return { cannot: 'unmeasured' }
+  const fix = figureFaceInsideAlignOf(view.measure, kernelAlignOf(view, align, alignMm), view.edges)
+  if ('cannot' in fix) return fix
+  const next = { align: { ...align }, alignMm: { ...alignMm }, moved: fix.moved as Axis[] }
+  for (const a of fix.moved as Axis[]) {
+    const how = fix.align[a]
+    if (how && typeof how === 'object') ((next.align[a] = 'mm'), (next.alignMm[a] = how.mm))
+    else if (how) next.align[a] = how
   }
-  return next.moved.length ? next : { cannot: 'inside' }
+  return next
 }
 
-/** How far the footprint comes past the face's edges, per side, and whether it touches the face at all. */
-export function overhangOf(view: FaceView, at: Record<Axis, number>): { touching: boolean; sides: Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> } {
-  const sides: Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> = []
-  let touching = true
-  for (const a of view.axes) {
-    const face = view.face[a]
-    if (face === undefined) continue
-    const lo = at[a] - view.part[a] / 2,
-      hi = at[a] + view.part[a] / 2
-    if (lo >= face / 2 || hi <= -face / 2) touching = false
-    if (-face / 2 - lo > 0.5) sides.push({ axis: a, side: 'low', mm: Math.round(-face / 2 - lo) })
-    if (hi - face / 2 > 0.5) sides.push({ axis: a, side: 'high', mm: Math.round(hi - face / 2) })
-  }
-  return { touching, sides }
+/**
+ * How far the part comes past the face's edges, per side, whether any of it lies over the face, and whether what
+ * touches the face is on it -- with its middle `at` from the face's middle: the kernel's (`figureFaceOverhangAt`).
+ */
+export function overhangOf(view: FaceView, at: Record<Axis, number>): { touching: boolean; contact: 'on' | 'off' | 'unknown'; sides: Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> } {
+  const o = figureFaceOverhangAt(view.measure, Object.fromEntries(view.axes.map(a => [a, { mm: at[a] }])))
+  return { touching: o.over, contact: o.contact, sides: o.sides as Array<{ axis: Axis; side: 'low' | 'high'; mm: number }> }
 }
 
 /** Whether the part turns about a joint: then 가운데를 면에 is offered -- a roller spinning in place. */
-export const turnsInPlace = (asset: FigureAsset, part: string) => (asset.joints ?? []).some(j => j.body1.part === part && (j.type === 'revolute' || ('face' in j.body1 && j.body1.face === 'centre')))
+export const turnsInPlace = (asset: FigureAsset, part: string) => (asset.joints ?? []).some(j => j.body1.part === part && (j.type === 'revolute' || j.origin?.facing === 'centre'))
 
 /**
  * How the face lies on the screen: X across when it is one of the face's axes, else Z; the other down the screen -- up

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

@@ -23,7 +23,7 @@ import {
   fastenTargetsOf,
   type FastenForm
 } from './fasten-form.js'
-import { fieldWordsOf, hasInstanceSize, heldBy, type Alignment, type Axis } from './links.js'
+import { fieldWordsOf, hasInstanceSize, heldBy, mountingPlaneOf, type Alignment, type Axis } from './links.js'
 import type { FigureRevision } from './revision.js'
 
 /** The target list's entry for the plane the figure stands by. */
@@ -178,7 +178,7 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
     const plan = fastenPlanOf(revision, this.partId, f)
     const planeWord = i18next.t('figure.label.resize-place-' + (asset.placement ?? 'floor'))
     const modes: FastenMode[] = f.toPlane
-      ? ['meet']
+      ? mountingPlaneOf(asset).facings
       : ['meet', 'flush', ...(turnsInPlace(asset, this.partId) ? (['centre'] as FastenMode[]) : [])]
     const detail = fastenDetailWordsOf(f, (key, params) => i18next.t(key, params))
     const drawing = (show: 'face' | 'how') =>
@@ -202,7 +202,7 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
       ${
         plan.aim
           ? html`<p fasten-sentence role="status">
-              ${fastenSentenceOf(this.partId, f, plan, planeWord, (key, params) => i18next.t(key, params))}
+              ${fastenSentenceOf(f, plan, planeWord, (key, params) => i18next.t(key, params))}
             </p>`
           : html`<p hint fasten-sentence>${i18next.t('figure.text.fasten-target-first')}</p>`
       }
@@ -215,7 +215,7 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
           ? html`<div question="face">
                 <h4>
                   ${
-                    /* The face asked is the target's, named: the part's own face follows from it. */ f.toPlane
+                    /* The face asked is the target's, named: the part meets it by its real shape, by no face of its own. */ f.toPlane
                       ? i18next.t('figure.label.fasten-face-on-plane', { plane: planeWord })
                       : i18next.t('figure.label.fasten-face-on-part', { part: f.target })
                   }
@@ -246,14 +246,6 @@ export class FigureFastenDialog extends localize(i18next)(LitElement) {
                       placeholder=${f.gapKept !== undefined ? i18next.t('figure.label.follows-expression') : ''}
                       @change=${(e: Event) => this.set({ gap: Number((e.target as HTMLInputElement).value) || 0, gapKept: undefined })}
                     />
-                    <span>${i18next.t('figure.label.twist')}</span>
-                    <input
-                      twist
-                      type="number"
-                      step="any"
-                      .value=${String(f.twist)}
-                      @change=${(e: Event) => this.set({ twist: Number((e.target as HTMLInputElement).value) || 0 })}
-                    />
                   </div>
                 </details>
               </div>

package/client/modeller/figure-links.ts

@@ -463,7 +463,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
     const revision = this.revision
     if (!revision) return
     const form = fastenFormOf(revision, this.partId)
-    /* Whether it is out is the kernel's measure (a round face is not measured there); the drawing's sizes say how far to move. */
+    /* Whether it is out, and the least move that brings it in, are the kernel's measure (ADR-0140 3.8). */
     const own = figureFaceOverhangOf(revision.asset, this.partId, revision.inputs)
     const fixed =
       own?.state === 'unknown'
@@ -486,21 +486,20 @@ export class FigureLinks extends localize(i18next)(LitElement) {
   }
 
   /**
-   * What holds the part, said as its state -- 「아랫면을 바닥에 유지 중」 -- with the ways to change it: open the fastening,
+   * What holds the part, said as its state -- 「바닥에 붙어 있음」 -- with the ways to change it: open the fastening,
    * or take it off. Right after "follow size, attached" this is the result, not a refusal (designer 2026-09-27).
    */
   private heldWords(asset: FigureAsset) {
     const joint = (asset.joints ?? []).find(j => j.body1.part === this.partId)
-    const face = joint ? i18next.t(endPlaceKeyOf(joint.body1)) : ''
     const gap = joint?.origin?.gap ?? 0
     const place = i18next.t(`figure.label.resize-place-${asset.placement ?? 'floor'}`)
     const where = !joint
       ? i18next.t('figure.text.held-by-rule')
       : 'plane' in joint.body0
         ? typeof gap === 'number'
-          ? i18next.t('figure.text.held-on-plane', { face, place, gap: String(gap) })
-          : i18next.t('figure.text.held-on-plane-worked-out', { face, place })
-        : i18next.t('figure.text.held-on-part', { face, other: joint.body0.part, otherFace: i18next.t(endPlaceKeyOf(joint.body0)) })
+          ? i18next.t('figure.text.held-on-plane', { place, gap: String(gap) })
+          : i18next.t('figure.text.held-on-plane-worked-out', { place })
+        : i18next.t('figure.text.held-on-part', { other: joint.body0.part, otherFace: i18next.t(endPlaceKeyOf(joint.body0)) })
     return where
   }
 
@@ -572,7 +571,7 @@ export class FigureLinks extends localize(i18next)(LitElement) {
       return html`
         ${overhang}
         <div fastened-summary>
-          <p fasten-sentence>${fastenSentenceOf(this.partId, form, plan, planeWord, (key, params) => i18next.t(key, params))}</p>
+          <p fasten-sentence>${fastenSentenceOf(form, plan, planeWord, (key, params) => i18next.t(key, params))}</p>
           <button act change-fastening ?disabled=${this.locked} @click=${() => this.openFastening()}>${i18next.t('figure.button.change-fastening')}</button>
         </div>
         ${this.renderDetachWords()}

package/client/modeller/joint-drag.ts

@@ -39,8 +39,8 @@ const round = (v: number, step: number) => Number((Math.round(v / step) * step).
 const rotateMatrix = (j: FigureJoint) => eulerMatrixOrder(AXES.map(a => j.origin?.parentRotate?.[a] ?? 0), 'ZYX')
 const eulerMatrixOrder = (deg: number[], order: THREE.EulerOrder) => new THREE.Matrix4().makeRotationFromEuler(new THREE.Euler(...(deg.map(THREE.MathUtils.degToRad) as [number, number, number]), order))
 
-/** The part's own quarter turn in the joint frame, as the record says it (`origin.childRotate`). */
-const turnMatrix = (j: FigureJoint) => eulerMatrix(AXES.map(a => j.origin?.childRotate?.[a] ?? 0))
+/** The part's own pose on its end, any angle, as the record says it (`origin.childRotate`, Rz·Ry·Rx, ADR-0140 3.11). */
+const turnMatrix = (j: FigureJoint) => eulerMatrixOrder(AXES.map(a => j.origin?.childRotate?.[a] ?? 0), 'ZYX')
 
 /** The joint frame's rotation in the figure: the part's rotation now, less its own turn and less the joint's. */
 function jointFrameRotation(j: FigureJoint, part: FigureRenderPart, angle: number): THREE.Matrix4 {
@@ -113,9 +113,9 @@ export function jointDragOf(asset: FigureAsset, id: string, part: FigureRenderPa
     }
     return { kind: 'joint', joint: { ...j, origin: { ...origin, offset } } as FigureJoint }
   }
-  const normal: Axis = 'plane' in j.body0 ? 'y' : FACE_AXIS[j.body0.face]!
-  /* Which way a larger gap moves the part: out of the face it meets (on the plane: up when it stands, down when it hangs). */
-  const outward = 'plane' in j.body0 ? ('face' in j.body1 && j.body1.face === 'bottom' ? 1 : -1) : ((j.origin?.facing ?? 'meet') === 'meet' ? 1 : -1) * FACE_SIGN[j.body0.face]!
+  const normal: Axis = 'plane' in j.body0 ? (asset.placement === 'wall' ? 'z' : 'y') : FACE_AXIS[j.body0.face]!
+  /* Which way a larger gap moves the part: out of the face it meets or sits by its middle on, into it when flush with it (ADR-0140 3.11). */
+  const outward = ((j.origin?.facing ?? 'meet') === 'flush' ? -1 : 1) * ('plane' in j.body0 ? 1 : FACE_SIGN[j.body0.face]!)
   const along = local[normal]
   if (Math.abs(along) >= 0.5) {
     const gap = origin.gap ?? 0