@things-factory/figure-ui 10.1.200 → 10.1.202

package/client/modeller/links.ts

@@ -1,6 +1,6 @@
-import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion } from '@hatiolab/figure-model'
 import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureJoint } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureFacing, FigureJoint } from '@hatiolab/figure-model'
 import { startingShapeKindOf } from './starting-shape.js'
 import { boxOf } from './align.js'
 import { graphValuesOf, type FigureRevision } from './revision.js'
@@ -55,7 +55,7 @@ export function heldBy(asset: FigureAsset, part: string): { part: string } | { p
   return to ? { part: to } : null
 }
 
-/** The word for where a joint end sits: its face's, or the part's origin for an end placed by it (ADR-0107 decision 4). */
+/** The word for where a joint's body0 end sits: its face's, or the part's origin for an end placed by it (ADR-0107 decision 4). */
 export const endPlaceKeyOf = (end: object) => ('face' in end ? `figure.label.face-${(end as { face: string }).face}` : 'figure.label.joint-origin')
 
 /** Whether a dimension of this part can follow something — box-shaped, whose three sizes are X, Y and Z. */
@@ -259,9 +259,8 @@ export function rowAxesOf(asset: FigureAsset, part: string): Axis[] {
   if (!j || j.repeat || !('part' in j.body0)) return []
   if (joints.some(o => 'part' in o.body0 && o.body0.part === part)) return []
   /* Placed by an origin: no face to lay the row across, and the kernel refuses it. */
-  const by = j.body1
-  if (!('face' in j.body0) || !('face' in by)) return []
-  return AXES.filter(axis => axis !== FIGURE_FACES[by.face])
+  if (!('face' in j.body0) || 'at' in j.body1) return []
+  return figureFastenAxesOf(asset, { part: j.body0.part, face: j.body0.face })
 }
 
 /**
@@ -275,7 +274,7 @@ export function rowBlockOf(asset: FigureAsset, part: string): 'unfastened' | 'on
   if (j.repeat) return undefined
   if (!('part' in j.body0)) return 'on-plane'
   if (joints.some(o => 'part' in o.body0 && o.body0.part === part)) return 'holds-parts'
-  if (!('face' in j.body0) || !('face' in j.body1)) return 'at-origin'
+  if (!('face' in j.body0) || 'at' in j.body1) return 'at-origin'
   return undefined
 }
 
@@ -294,37 +293,18 @@ export type Alignment = 'centre' | 'min' | 'max' | 'mm' | 'share' | 'input'
  */
 /**
  * The mounting plane of this figure, by its placement (ADR-0093): the floor or the ceiling is Y = 0 and a part stands
- * on it by its bottom or hangs from it by its top; a wall is Z = 0 and a part is fastened to it by its back.
+ * on it or hangs below it; a wall is Z = 0 and a part stands out of it (ADR-0140 3.11).
  */
-export function mountingPlaneOf(asset: FigureAsset): { normal: Axis; faces: FigureFace[] } {
-  return asset.placement === 'wall' ? { normal: 'z', faces: ['back'] } : { normal: 'y', faces: ['bottom', 'top'] }
+export function mountingPlaneOf(asset: FigureAsset): { normal: Axis; facings: FigureFacing[] } {
+  return asset.placement === 'wall' ? { normal: 'z', facings: ['meet'] } : { normal: 'y', facings: ['meet', 'flush'] }
 }
 
-export function alignAxesOf(asset: FigureAsset, part: string, target: { part: string; face: string } | 'plane', twisted = false): { axis: Axis; edges: boolean }[] {
+export function alignAxesOf(asset: FigureAsset, target: { part: string; face: string } | 'plane'): { axis: Axis; edges: boolean }[] {
   /* The plane has no edges, but a figure that declares its size has sides on it (figure-model 0.1.64). */
-  if (target === 'plane') {
-    const { normal } = mountingPlaneOf(asset)
-    return AXES.filter(axis => axis !== normal).map(axis => ({ axis, edges: !twisted && hasInstanceSize(asset, axis) }))
-  }
-  const along = faceAxisOf(asset, target.part, target.face)
-  if (!along) return []
-  const theirs = new Set(facesOf(asset, target.part)),
-    mine = new Set(facesOf(asset, part))
-  /* A part twisted about the face's normal has no side level with the target's edges. */
-  return AXES.filter(axis => axis !== along).map(axis => ({ axis, edges: !twisted && OUTER[axis].every(f => theirs.has(f) && mine.has(f)) }))
-}
-
-/**
- * The faces of its own a part may be fastened by: its outer faces -- on the mounting plane only the ones the plane takes
- * (a bottom or a top on the floor, a back on a wall) -- and, to another part, its centre, which a roller spins about.
- */
-export function ownFacesOf(asset: FigureAsset, part: string, toPlane: boolean): Array<FigureFace | 'centre'> {
-  const outer = Object.keys(FIGURE_FACES) as FigureFace[]
-  const plane = mountingPlaneOf(asset)
-  return [
-    ...(facesOf(asset, part).filter(face => outer.includes(face as FigureFace) && (!toPlane || plane.faces.includes(face as FigureFace))) as FigureFace[]),
-    ...(toPlane ? [] : (['centre'] as const))
-  ]
+  if (target === 'plane') return figureFastenAxesOf(asset, 'plane').map(axis => ({ axis, edges: hasInstanceSize(asset, axis) }))
+  /* The part is lined up by its real extent in the pose it has (ADR-0140 3.4): the target's two sides are what it needs. */
+  const theirs = new Set(facesOf(asset, target.part))
+  return figureFastenAxesOf(asset, target).map(axis => ({ axis, edges: OUTER[axis].every(f => theirs.has(f)) }))
 }
 
 /**
@@ -334,13 +314,11 @@ export function ownFacesOf(asset: FigureAsset, part: string, toPlane: boolean):
  */
 export function alignRowsOf(
   asset: FigureAsset,
-  part: string,
   aim: { part: string; face: string } | 'plane',
   view: { axes: readonly Axis[] } | undefined,
-  twisted: boolean,
   alignInput: Partial<Record<Axis, string>> = {}
 ): { axis: Axis; edges: boolean }[] {
-  return alignAxesOf(asset, part, aim, twisted).filter(({ axis }) => !view || !view.axes.includes(axis) || !!alignInput[axis] || hasInstanceSize(asset, axis))
+  return alignAxesOf(asset, aim).filter(({ axis }) => !view || !view.axes.includes(axis) || !!alignInput[axis] || hasInstanceSize(asset, axis))
 }
 
 /** The controls a part's showing can follow: the figure's state inputs, with their range and label. */
@@ -374,8 +352,8 @@ export function hangsFrom(asset: FigureAsset, part: string, from: string): boole
 }
 
 /**
- * The fastening a part has, as the fastening form holds it -- so the form opens on what is there (the face, including
- * \`centre\`, the target and its face, the gap, the twist and where across the face) and a change is a change to that.
+ * The fastening a part has, as the fastening form holds it -- so the form opens on what is there (the target and its
+ * face, how it meets it, the gap and where across the face) and a change is a change to that.
  * Opening it on the defaults showed a roller fastened by its centre as fastened by its bottom, and fastening again
  * from there broke its turning in place (walk 1, 2026-09-26). Null for a part fastened to nothing.
  */
@@ -383,15 +361,13 @@ export function fasteningOf(
   revision: FigureRevision,
   part: string
 ): {
-  face: string
   toPlane: boolean
   target: string
   targetFace: string
-  facing: 'meet' | 'flush'
+  facing: FigureFacing
   gap: number
   /** The record's gap when it is worked out (a length that follows something): kept as it is until a number is typed. */
   gapKept?: unknown
-  twist: number
   align: Partial<Record<Axis, Alignment>>
   alignMm: Partial<Record<Axis, number>>
   /** Placed by a part's origin (ADR-0107 decision 4): no face to fasten by, and the form does not write it. */
@@ -402,10 +378,9 @@ export function fasteningOf(
   const toPlane = 'plane' in record.body0
   const target = 'part' in record.body0 ? record.body0.part : ''
   const targetFace = 'face' in record.body0 ? record.body0.face : 'top'
-  const atOrigin = !('plane' in record.body0) && (!('face' in record.body0) || !('face' in record.body1))
-  const twist = record.origin?.twist ?? 0
+  const atOrigin = !('plane' in record.body0) && (!('face' in record.body0) || 'at' in record.body1)
   /* Where across the face: as the record says it, and where it says nothing, where the part stands now. */
-  const kept = placeKeptOf(revision, part, toPlane ? 'plane' : { part: target, face: targetFace }, !!twist)
+  const kept = placeKeptOf(revision, part, toPlane ? 'plane' : { part: target, face: targetFace })
   for (const [axis, how] of Object.entries(record.origin?.align ?? {}) as Array<[Axis, unknown]>) {
     if (how === 'min' || how === 'max' || how === 'centre') {
       kept.align[axis] = how
@@ -422,14 +397,12 @@ export function fasteningOf(
   }
   const gap = record.origin?.gap
   return {
-    face: 'face' in record.body1 ? record.body1.face : 'centre',
     toPlane,
     target,
     targetFace,
     facing: record.origin?.facing ?? 'meet',
     gap: typeof gap === 'number' ? gap : 0,
     ...(gap !== undefined && typeof gap !== 'number' ? { gapKept: gap } : {}),
-    twist,
     ...kept,
     ...(atOrigin ? { atOrigin: true as const } : {})
   }
@@ -446,52 +419,28 @@ export function fastenGapOf(form: { gap: number; gapKept?: unknown }): { gap?: u
 }
 
 /**
- * The alignment that keeps the part where it stands when it is fastened: on each axis across the face, its distance
- * from the target's centre (the plane's is the origin). Fastening used to centre it -- a door set 100 mm in front of
- * its frame slid into it (2026-09-26). Left centred where it already is, and where the target stands turned.
+ * The alignment that keeps the part where it stands when it is fastened, as the form holds it: the kernel's place
+ * (`figureFastenKeptPlaceOf`, ADR-0140 3.7), a distance on each axis it is off the target's centre.
  */
 export function placeKeptOf(
   revision: FigureRevision,
   part: string,
-  target: { part: string; face: string } | 'plane',
-  twisted = false
+  target: { part: string; face: string } | 'plane'
 ): { align: Partial<Record<Axis, Alignment>>; alignMm: Partial<Record<Axis, number>>; alignInput: Partial<Record<Axis, string>> } {
-  const kept = { align: {} as Partial<Record<Axis, Alignment>>, alignMm: {} as Partial<Record<Axis, number>>, alignInput: {} as Partial<Record<Axis, string>> }
-  const asset = revision.asset
-  /* Where it stands as drawn: the pose the command that fastens it sees. */
-  const geometry = revision.geometry as unknown as Array<{ id: string; pose?: { r: number[][]; t: number[] } }>
-  const poseOf = (id: string) => geometry.find(g => g.id === id)?.pose
-  const mine = poseOf(part)
-  if (!mine) return kept
-  let centre = [0, 0, 0]
-  if (target !== 'plane') {
-    const theirs = poseOf(target.part)
-    const upright = theirs?.r.every((row, i) => row.every((v, j) => Math.abs(v - (i === j ? 1 : 0)) < 1e-9))
-    if (!theirs || !upright) return kept
-    centre = theirs.t
-  }
-  for (const { axis } of alignAxesOf(asset, part, target, twisted)) {
-    const k = AXES.indexOf(axis)
-    const off = Math.round((mine.t[k]! - centre[k]!) * 10) / 10
-    if (Math.abs(off) < 0.5) continue
-    kept.align[axis] = 'mm'
-    kept.alignMm[axis] = off
-  }
-  return kept
+  const alignMm = figureFastenKeptPlaceOf(revision.asset, part, target, { ...revision.inputs })
+  return { align: Object.fromEntries(Object.keys(alignMm).map(axis => [axis, 'mm'])) as Partial<Record<Axis, Alignment>>, alignMm, alignInput: {} }
 }
 
 /** The `align` of an attach command from the form's choices: only the axes across that face, and centred ones left out. */
 export function alignOf(
   asset: FigureAsset,
-  part: string,
   target: { part: string; face: string } | 'plane',
   how: Partial<Record<Axis, Alignment>>,
   mm: Partial<Record<Axis, number>>,
-  twisted = false,
   inputs: Partial<Record<Axis, string>> = {}
 ) {
   const align: Partial<Record<Axis, 'min' | 'max' | { mm: number | { from: { of: 'instance'; axis: Axis }; times: number } | { from: { of: 'input'; input: string } } }>> = {}
-  for (const { axis, edges } of alignAxesOf(asset, part, target, twisted)) {
+  for (const { axis, edges } of alignAxesOf(asset, target)) {
     const one = how[axis] ?? 'centre'
     const size = asset.designInputs[`size.${axis}`]
     if (one === 'share' && mm[axis] && hasInstanceSize(asset, axis) && size)
@@ -644,24 +593,20 @@ export function leadersFor(asset: FigureAsset, part: string, kind: MotionForm['k
  * control or limits of its own — its range is the leader's times the multiplier.
  */
 export function motionJoint(joint: FigureJoint, m: MotionForm, part: string): FigureJoint {
+  /* Where it is fastened -- its row and its frame's own words too -- is the kernel's to keep (`figureJointWithMotion`, ADR-0140 D6). */
   const moving = {
-    id: joint.id,
-    body0: joint.body0,
-    body1: joint.body1,
-    ...(joint.origin ? { origin: joint.origin } : {}),
-    /* A row keeps being a row when it is given a motion: dropped here, the row went with it (designer 2026-09-27). */
-    ...(joint.repeat ? { repeat: joint.repeat } : {}),
     type: m.kind === 'slide' ? ('prismatic' as const) : ('revolute' as const),
     axis: (m.axisVector ?? m.axis.toUpperCase()) as FigureJoint['axis']
   }
-  if (m.follow) return { ...moving, mimic: { joint: m.follow, multiplier: m.multiplier, ...(m.offset ? { offset: m.offset } : {}) } }
-  if (m.followSum) return { ...moving, mimic: { sum: m.followSum, ...(m.offset ? { offset: m.offset } : {}) } }
-  if (m.kind === 'slide' && m.travelSum && !m.travel) return { ...moving, travel: m.travelSum, state: { id: m.id || `${part}-${m.kind}` } }
+  const given = (motion: Omit<Parameters<typeof figureJointWithMotion>[1], 'type' | 'axis'>) => figureJointWithMotion(joint, { ...moving, ...motion })
+  if (m.follow) return given({ mimic: { joint: m.follow, multiplier: m.multiplier, ...(m.offset ? { offset: m.offset } : {}) } })
+  if (m.followSum) return given({ mimic: { sum: m.followSum, ...(m.offset ? { offset: m.offset } : {}) } })
+  if (m.kind === 'slide' && m.travelSum && !m.travel) return given({ travel: m.travelSum, state: { id: m.id || `${part}-${m.kind}` } })
   if (m.kind === 'slide' && m.travel) {
     const [of, axis] = m.travel.split(':')
-    return { ...moving, travel: { source: { of: 'part', part: of!, axis: axis as Axis }, ...(m.travelPlus ? { plus: m.travelPlus } : {}) }, state: { id: m.id || `${part}-${m.kind}` } }
+    return given({ travel: { source: { of: 'part', part: of!, axis: axis as Axis }, ...(m.travelPlus ? { plus: m.travelPlus } : {}) }, state: { id: m.id || `${part}-${m.kind}` } })
   }
-  return { ...moving, ...(m.kind === 'continuous' ? {} : { lowerLimit: m.min, upperLimit: m.max }), state: { id: m.id || `${part}-${m.kind}` } }
+  return given({ ...(m.kind === 'continuous' ? {} : { lowerLimit: m.min, upperLimit: m.max }), state: { id: m.id || `${part}-${m.kind}` } })
 }
 
 /**
@@ -832,14 +777,5 @@ export function turnsAboutAJoint(asset: FigureAsset): boolean {
   return modelOf(asset).nodes.some(n => n.op === 'axis-turn@1')
 }
 
-/** The joint made still: its fastening, its place and its row kept, its motion gone. */
-export function fixedJointOf(joint: FigureJoint): FigureJoint {
-  return {
-    id: joint.id,
-    type: 'fixed',
-    body0: joint.body0,
-    body1: joint.body1,
-    ...(joint.origin ? { origin: joint.origin } : {}),
-    ...(joint.repeat ? { repeat: joint.repeat } : {})
-  } as FigureJoint
-}
+/** The joint made still: its fastening, its place and its row kept, its motion gone (the kernel's `figureJointAsFixed`, ADR-0140 D6). */
+export const fixedJointOf = figureJointAsFixed

package/client/modeller/refusals.ts

@@ -56,18 +56,14 @@ export function narrowingRetryOf<A extends { kind: string }>(action: A, error: u
 }
 
 /**
- * A placement refused because a part is fastened to the mounting plane by a face the new plane does not take (a bottom
+ * A placement refused because a part is fastened to the mounting plane in a way the new plane does not take (standing
  * on the floor, when the figure is to hang on a wall), said in the author's words with the parts it names.
  */
 export function placementRefusalOf(error: unknown, say: Say): string | null {
   if (codeOf(error) !== 'PLACEMENT_PLANE') return null
   const misfit = detailsOf(error, 'placement-face')
   if (!misfit) return null
-  return say('figure.text.placement-plane-refused', {
-    parts: misfit.parts.map(p => `${p.part} (${p.face})`).join(', '),
-    placement: say('figure.label.placement-' + misfit.placement, {}),
-    faces: misfit.takes.join(', ')
-  })
+  return say('figure.text.placement-plane-refused', { parts: misfit.parts.map(p => p.part).join(', ') })
 }
 
 /** A refusal carried on in a record (an AI proposal's outcome) in figure-model's own shape: its code and details. */

package/dist-client/modeller/editor.js

@@ -1450,11 +1450,14 @@ let FigureEditor = class FigureEditor extends LitElement {
             const asset = shown.asset;
             const say = (k, params) => i18next.t(k, params);
             const where = (o) => ({ 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) => !!o && o.on !== 'plane';
             const sides = (o) => o.sides.map(s => say(`figure.text.overhang-side-${s.side}`, { axis: s.axis.toUpperCase(), mm: String(s.mm) })).join(', ');
             const words = [];
             const note = [];
             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)
@@ -1466,8 +1469,10 @@ let FigureEditor = class FigureEditor extends LitElement {
                     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?.state === 'out' || o?.state === 'possible');
+                const past = held.filter((o) => 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(', ') }));
             }