@things-factory/figure-ui 10.1.204 → 10.1.205

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

@@ -267,8 +267,8 @@ export class FigureSectionEditor extends localize(i18next)(LitElement) {
   @property({ attribute: false }) body?: { id: string; shape: FigureEvaluatedShape }
   /** Which of its measures can be set (figure-model's `figureSectionMeasuresOf`). */
   @property({ attribute: false }) measures?: { measures: Record<Axis, FigureSectionMeasure>; round: boolean }
-  /** Along the push, the face a length change keeps: 1 its start, -1 its end, 0 its centre; undefined when it cannot be said. */
-  @property({ attribute: false }) kept?: -1 | 0 | 1
+  /** What a length typed keeps: the part's middle, or its fastening (ADR-0140 4.1); undefined when it keeps no point. */
+  @property({ attribute: false }) kept?: 'centre' | 'relation' | 'none'
   /** Why a push's end cannot be drawn to a point now, in the kernel's words (what is fastened to it); empty when it can. */
   @property({ attribute: false }) pointBlocked = ''
   /** The figure's revision now; the editor remembers the one it opened at. */
@@ -490,10 +490,10 @@ export class FigureSectionEditor extends localize(i18next)(LitElement) {
     return { h: Math.round(p.x), v: Math.round(p.y) }
   }
 
-  /** What a measure's field says under it: following another value, or for the length the face it keeps. */
-  private noteWords(axis: Axis, kept?: -1 | 0 | 1): string {
-    const note = measureNoteOf(this.measures?.measures[axis], kept, axis)
-    return note ? i18next.t(note.key, note.face ? { face: i18next.t('figure.label.face-' + note.face) } : {}) : ''
+  /** What a measure's field says under it: following another value, or for the length what it keeps. */
+  private noteWords(axis: Axis, kept?: 'centre' | 'relation' | 'none'): string {
+    const note = measureNoteOf(this.measures?.measures[axis], kept)
+    return note ? i18next.t(note.key) : ''
   }
 
   render() {

package/client/modeller/figure-slot-layout-panel.ts

@@ -169,7 +169,7 @@ export class FigureSlotLayoutPanel extends localize(i18next)(LitElement) {
     const anchorFaces = anchorFacesOf(form.anchors, geometry)
     const value = {
       canUseDefault: false,
-      presets: slotPresetsOf(form.anchors, key => i18next.t(key)),
+      presets: slotPresetsOf(form.anchors),
       /* The first anchor's face is the size a preset is laid out over; the slot height is the author's. */
       presetSize: anchorFaces[form.anchors[0]?.id ?? ''] ?? {},
       anchors: form.anchors.map(a => ({ id: a.id, label: `${a.id} · ${a.part} ${i18next.t('figure.label.face-' + a.face)}` })),

package/client/modeller/gizmo.ts

@@ -1,5 +1,5 @@
 import { figureAttachmentsOf, figureShapeProviderOf } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureInputChange } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureSizeKeep } from '@hatiolab/figure-model'
 
 /**
  * What the gizmo may write for a part: move · turn · size, on a asset.
@@ -115,6 +115,17 @@ export interface GizmoResult {
   position?: [number, number, number]
   rotation?: [number, number, number]
   scale?: [number, number, number]
+  /** The handle a size drag held, per own axis -1 · 0 · 1 (the scene's `scaleGrab`): what figure-model keeps from. */
+  grab?: { x: number; y: number; z: number }
+}
+
+/**
+ * What a size drag keeps (ADR-0140 4.1): the side opposite a handle on one axis; the middle for the uniform handle, or
+ * when no handle is known -- figure-model's own words for it, so the drag and its commit ask the same.
+ */
+export function sizeKeepOf(grab: GizmoResult['grab']): FigureSizeKeep {
+  const held = (['x', 'y', 'z'] as const).filter(axis => grab?.[axis])
+  return held.length === 1 ? { keep: 'opposite', axis: held[0]!, side: grab![held[0]!]! > 0 ? 1 : -1 } : { keep: 'centre' }
 }
 
 /**

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, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion } from '@hatiolab/figure-model'
+import { FIGURE_FACES, figureShapeFaces, figurePartsExtentOf, compileFigureAsset, figureFollowOf, proposeFigureProportion, defaultInstanceSizeRange, foldInstanceSizeRange, figureAttachmentsOf, figureBindingsOf, figureInstanceSizeLimitsOf, figureFollowableAxesOf, figureShapeProviderOf, figureMimicTermsOf, figureFastenKeptPlaceOf, figureFastenAxesOf, figureJointAsFixed, figureJointWithMotion, figureSurfaceOf } from '@hatiolab/figure-model'
 import type { FigureFollow, FigureSizeRange } from '@hatiolab/figure-model'
-import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureFacing, FigureJoint } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureAuthoringAction, FigureBindingPlace, FigureDimensionSource, FigureFace, FigureFacing, FigureJoint, FigureSurfacePlace } from '@hatiolab/figure-model'
 import { startingShapeKindOf } from './starting-shape.js'
 import { boxOf } from './align.js'
 import { graphValuesOf, type FigureRevision } from './revision.js'
@@ -35,6 +35,23 @@ export function followOf(asset: FigureAsset, part: string, axis: Axis): Follow {
   return figureFollowOf(asset, part, axis)
 }
 
+/**
+ * The parts whose size follows the figure's size on some axis, in the model's order: the ones that change when the
+ * figure is resized on a drawing. Read by figure-model's own follow (`figureFollowOf`), not worked out again here.
+ */
+export function sizeFollowersOf(asset: FigureAsset): string[] {
+  const parts = (modelOf(asset).nodes as Array<{ id: string; op: string }>).filter(n => n.op === 'place@1').map(n => n.id)
+  return parts.filter(part =>
+    AXES.some(axis => {
+      try {
+        return figureFollowOf(asset, part, axis).of === 'instance'
+      } catch {
+        return false
+      }
+    })
+  )
+}
+
 /** Whether the asset declares an instance size on an axis — only then can a dimension follow it. */
 export const hasInstanceSize = (asset: FigureAsset, axis: Axis) => modelOf(asset).inputs.some(i => i.id === `size.${axis}` && i.role === 'design')
 
@@ -224,7 +241,14 @@ export function measureNow(revision: FigureRevision, part: string, axis: Axis):
  */
 export function facesOf(asset: FigureAsset, part: string): string[] {
   const shape = modelOf(asset).nodes.find(n => n.id === `${part}.shape`)
-  return inScreenOrder(Object.keys((shape && figureShapeFaces(shape as never)) ?? {}))
+  const faces = (shape && figureShapeFaces(shape as never)) ?? {}
+  /* A cylinder's curved side is no face: a part is fastened to a point on it (ADR-0140 3.9, `surfaceOf`). */
+  return inScreenOrder(Object.keys(faces).filter(f => faces[f]!.contact !== 'line'))
+}
+
+/** The curved surface a part offers to be fastened to at a point: a cylinder's side or a sphere's round (ADR-0140 3.9). */
+export function surfaceOf(asset: FigureAsset, part: string): { form: 'around' | 'toward'; axis: Axis } | undefined {
+  return figureSurfaceOf(asset, part)
 }
 
 /** Faces in the order the screen lists them: the six outer ones left to front, then the rest as the shape gives them. */
@@ -242,7 +266,7 @@ export function faceAxisOf(asset: FigureAsset, part: string, face: string): Axis
 
 /** Whether `attach` can take this part: any part whose shape has a flat face. */
 export function canFasten(asset: FigureAsset, part: string): boolean {
-  return facesOf(asset, part).length > 0
+  return facesOf(asset, part).length > 0 || !!surfaceOf(asset, part)
 }
 
 const OUTER: Record<Axis, [string, string]> = { x: ['left', 'right'], y: ['bottom', 'top'], z: ['back', 'front'] }
@@ -267,13 +291,15 @@ export function rowAxesOf(asset: FigureAsset, part: string): Axis[] {
  * Why a part cannot be made into a row here, in the terms `rowAxesOf` refuses it: said, not hidden (ADR-0097 §5.5).
  * Nothing when it can, or when it already is a row (that row is shown where it stands).
  */
-export function rowBlockOf(asset: FigureAsset, part: string): 'unfastened' | 'on-plane' | 'holds-parts' | 'at-origin' | undefined {
+export function rowBlockOf(asset: FigureAsset, part: string): 'unfastened' | 'on-plane' | 'holds-parts' | 'at-origin' | 'on-surface' | undefined {
   const joints = asset.joints ?? []
   const j = joints.find(o => o.body1.part === part)
   if (!j) return 'unfastened'
   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'
+  /* On a point of a curved surface a row has no face to run across (ADR-0140 3.9): the kernel refuses it. */
+  if ('surface' in j.body0) return 'on-surface'
   if (!('face' in j.body0) || 'at' in j.body1) return 'at-origin'
   return undefined
 }
@@ -372,13 +398,29 @@ export function fasteningOf(
   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. */
   atOrigin?: true
+  /** On a point of the target's curved surface (ADR-0140 3.9), as the record says it. */
+  surface?: FigureSurfacePlace
 } | null {
   const record = revision.asset.joints?.find(j => j.body1.part === part)
   if (!record) return null
   const toPlane = 'plane' in record.body0
   const target = 'part' in record.body0 ? record.body0.part : ''
+  const surface = 'surface' in record.body0 ? record.body0.surface : undefined
   const targetFace = 'face' in record.body0 ? record.body0.face : 'top'
-  const atOrigin = !('plane' in record.body0) && (!('face' in record.body0) || 'at' in record.body1)
+  const atOrigin = !('plane' in record.body0) && ((!('face' in record.body0) && !surface) || 'at' in record.body1)
+  if (surface)
+    return {
+      toPlane,
+      target,
+      targetFace,
+      facing: record.origin?.facing ?? 'meet',
+      gap: typeof record.origin?.gap === 'number' ? record.origin.gap : 0,
+      ...(record.origin?.gap !== undefined && typeof record.origin.gap !== 'number' ? { gapKept: record.origin.gap } : {}),
+      align: {},
+      alignMm: {},
+      surface,
+      ...(atOrigin ? { atOrigin: true as const } : {})
+    }
   /* 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 })
   for (const [axis, how] of Object.entries(record.origin?.align ?? {}) as Array<[Axis, unknown]>) {

package/client/modeller/section-drawing.ts

@@ -1,6 +1,5 @@
 import { FIGURE_SECTION_PLANE, FIGURE_SECTION_POINT_LIMIT, checkFigureSection, figureExtrusionFeaturesOf, figureSectionSidesOf } from '@hatiolab/figure-model'
 import type { FigureAuthoringAction, FigureCavityRequest, FigureEvaluatedShape, FigureSection, FigureSectionIssue, FigureSectionMeasure, FigureSectionPoint } from '@hatiolab/figure-model'
-import { END_FACE } from './section-controls.js'
 
 /*
  * What the section editor does to a drawn section's points, and how it says what is wrong with them (ADR-0100 §3.2).
@@ -218,14 +217,15 @@ export function sectionActionOf(part: string, kind: FigureSection['kind'] | unde
 }
 
 /**
- * What a measure's field says under it: that it follows another value, or -- given where along the push a length
- * change keeps the part (1 its start, -1 its end, 0 its centre) -- the face it keeps; null when there is nothing to say.
+ * What a measure's field says under it: that it follows another value, or what a measure typed keeps -- the part's
+ * middle, or its fastening (ADR-0140 4.1, figure-model's `figureSizeEditOf`); null when there is nothing to say.
  */
-export function measureNoteOf(measure: FigureSectionMeasure | undefined, kept: -1 | 0 | 1 | undefined, axis: Axis): { key: string; face?: string } | null {
+export function measureNoteOf(measure: FigureSectionMeasure | undefined, kept: 'centre' | 'relation' | 'none' | undefined): { key: string } | null {
   if (measure === 'linked') return { key: 'figure.text.section-editor-linked' }
-  if (kept === undefined) return null
-  if (kept === 0) return { key: 'figure.text.section-editor-keeps-centre' }
-  return { key: 'figure.text.section-editor-keeps', face: END_FACE(axis, kept === 1 ? 'start' : 'end') }
+  if (kept === 'centre') return { key: 'figure.text.size-keeps-centre' }
+  if (kept === 'relation') return { key: 'figure.text.size-keeps-fastening' }
+  if (kept === 'none') return { key: 'figure.text.size-keeps-none' }
+  return null
 }
 
 /** The words beside a drawn section's edit button: how many points it has, and the apex when its end is one point. */

package/client/modeller/size-drag.ts

@@ -0,0 +1,112 @@
+import { compileFigureDocument, figurePlacementOf, figureShapeReachOf, figureSizeEditOf, figureSizeEditorOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureSizeKeep } from '@hatiolab/figure-model'
+
+import { ownerOf } from './fields.js'
+import type { FigureRenderPart } from './renderer.js'
+
+/*
+ * A size drag drawn from figure-model, frame by frame (ADR-0140 4.4). The gizmo says only which handle and how far; the
+ * one size function (`figureSizeEditorOf`) turns the sizes into the changes a commit writes, and the instance evaluator
+ * the figure is compiled into once, when the drag begins, steps to them (`advance`). What is drawn while dragging is
+ * what the release writes: the same function, the same sizes, the same keep. Nothing drawn goes back into what the
+ * gizmo computes (2026-09-24: the gizmo fought the modeller when evaluations were written back onto it).
+ */
+
+export interface SizeDragFrame {
+  /** What a release now would write: the sizes and, for a free part, its own position. */
+  changes: FigureInputChange[]
+  /**
+   * Every body moved or reshaped since the drag began, by id: its pose and shape at this frame as figure-model evaluates
+   * them. The evaluator tells only what changed since the frame before; a body that moved and then stood still is kept.
+   */
+  moved: Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>
+}
+
+export interface SizeDrag {
+  part: string
+  keep: FigureSizeKeep
+  frame(sizes: readonly FigureInputChange[]): SizeDragFrame
+}
+
+type Pose = FigureRenderPart['pose']
+
+/** The drag of `part`'s size from `inputs` (the figure's inputs as it is drawn), keeping what `keep` says. */
+export function startSizeDrag(asset: FigureAsset, part: string, inputs: Record<string, number>, keep: FigureSizeKeep): SizeDrag {
+  const edit = figureSizeEditorOf(asset, part)
+  const evaluator = compileFigureDocument(asset.document).evaluator({ changes: true })
+  const base = { ...asset.designInputs, ...asset.stateDefaults, ...inputs }
+  /* The bodies as the evaluator numbers its slots: the order of this first evaluation. */
+  let ids = evaluator.evaluate(base).geometry.map(g => (g as { id: string }).id)
+  const moved = new Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>()
+  return {
+    part,
+    keep,
+    frame(sizes) {
+      const { changes } = edit(sizes, keep)
+      const next = { ...base }
+      for (const c of changes) next[c.input] = c.value as number
+      const step = evaluator.advance(next)
+      if (step.kind === 'changes' && step.structure) ids = step.structure.ids
+      for (let k = 0; k < step.bodies.length; k++) {
+        const id = ids[step.bodies[k]!]
+        const p = step.poses.subarray(k * 12, k * 12 + 12)
+        if (id === undefined || Number.isNaN(p[0]!)) continue
+        const pose: Pose = { r: [[p[0]!, p[1]!, p[2]!], [p[3]!, p[4]!, p[5]!], [p[6]!, p[7]!, p[8]!]], t: [p[9]!, p[10]!, p[11]!] }
+        /* The evaluator's shapes are frozen; the scene's builder writes into what it is given, so the canvas gets its own copy. */
+        const frozen = step.kind === 'changes' ? step.shapes[k] : undefined
+        const shape = frozen ? structuredClone(frozen) : undefined
+        const had = moved.get(id)
+        moved.set(id, { pose, ...(shape ? { shape: shape as unknown as FigureRenderPart['shape'] } : had?.shape ? { shape: had.shape } : {}) } as Pick<FigureRenderPart, 'pose' | 'shape'>)
+      }
+      return { changes, moved: new Map(moved) }
+    }
+  }
+}
+
+/**
+ * What a size typed for this part keeps, in figure-model's words: its middle (`centre`), its fastening (`relation`), or
+ * no point -- its position is worked out, and only the size changes (`none`). The words beside the size fields (ADR-0140
+ * 4.1, chief architect 10-20); nothing when the part cannot be asked.
+ */
+export function keptBySizeOf(asset: FigureAsset, part: string): 'centre' | 'relation' | 'none' | undefined {
+  try {
+    const kept = figureSizeEditOf(asset, part, [], { keep: 'centre' }).kept
+    return kept === 'opposite' ? undefined : kept
+  } catch {
+    return undefined
+  }
+}
+
+/** The words for what a size keeps, by `keptBySizeOf`'s answer. */
+export const SIZE_KEEPS_WORDS = { centre: 'figure.text.size-keeps-centre', relation: 'figure.text.size-keeps-fastening', none: 'figure.text.size-keeps-none' } as const
+
+/** The parts drawn this frame: each one the frame moved, with its new pose and shape; every other one as it was. */
+export function partsAtFrame(parts: readonly FigureRenderPart[], moved: SizeDragFrame['moved']): FigureRenderPart[] {
+  if (!moved.size) return parts as FigureRenderPart[]
+  return parts.map(part => {
+    const now = moved.get(part.id)
+    return now ? { ...part, pose: now.pose, ...(now.shape ? { shape: now.shape } : {}) } : part
+  })
+}
+
+/** The side of its mounting plane a figure uses (ADR-0097 4.2): up from a floor, down from a ceiling, out of a wall. */
+const USED: Record<string, [number, number, number] | undefined> = { floor: [0, 1, 0], ceiling: [0, -1, 0], wall: [0, 0, 1], center: undefined }
+
+/**
+ * How far a free part goes past its figure's mounting plane, in millimetres, as drawn: its real shape's extreme against
+ * the side the placement uses (figure-model's reach, the rule a fastening stands a part by). 0 when it does not, for a
+ * fastened part -- its fastening places it -- and for a figure placed by its centre (ADR-0140 5).
+ */
+export function throughPlaneOf(asset: FigureAsset, parts: readonly FigureRenderPart[], part: string): number {
+  const n = USED[figurePlacementOf(asset)]
+  if (!n || (asset.joints ?? []).some(j => j.body1.part === part)) return 0
+  let lowest = Infinity
+  for (const body of parts) {
+    if (ownerOf(body.id) !== part) continue
+    const { r, t } = body.pose
+    /* The side's direction in the body's own frame: rᵀ n. */
+    const d = [0, 1, 2].map(j => r[0]![j]! * n[0] + r[1]![j]! * n[1] + r[2]![j]! * n[2]) as [number, number, number]
+    lowest = Math.min(lowest, t[0]! * n[0] + t[1]! * n[1] + t[2]! * n[2] + figureShapeReachOf(body.shape as never, d).min)
+  }
+  return Number.isFinite(lowest) && lowest < 0 ? Math.round(-lowest * 10) / 10 : 0
+}

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

@@ -66,14 +66,14 @@ export function anchorFacesOf(anchors: readonly SlotAnchor[], geometry: readonly
  * a one-anchor preset on the first, a twin fork on the first two. A single slot stands on a top and hangs from a bottom.
  * The editor's own controls then make it what the equipment is.
  */
-export function slotPresetsOf(anchors: readonly SlotAnchor[], say: (key: string) => string) {
+export function slotPresetsOf(anchors: readonly SlotAnchor[]) {
   const first = anchors[0]
   const on = { ...(first ? { anchor: first.id } : {}), ...(anchors.length >= 2 ? { forks: [anchors[0]!.id, anchors[1]!.id] as [string, string] } : {}) }
   const mount = first?.face === 'bottom' ? ('HANG' as const) : ('ON' as const)
   return SLOT_LAYOUT_PRESET_KEYS.map(key => ({
     key,
-    label: say(`figure.label.slot-preset-${key}`),
-    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, label: say(`figure.label.slot-preset-param-${p.key}`), integer: p.integer })),
+    /* The editor names a preset and its values from their keys (@operato/slot-layout-editor's own words). */
+    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, integer: p.integer })),
     build: (size: SlotPresetSize, params: Record<string, number>) => slotLayoutPreset(key, size, params, { ...on, mount })
   }))
 }

package/client/modeller/stage-model.ts

@@ -64,16 +64,13 @@ function colours(part: FigureRenderPart, palette: Record<string, string>) {
   return { color: palette[m.token] ?? '#9a9a9a', preset: m.preset, transparent: !!m.transparent, ...(glow ? { glow } : {}) }
 }
 
-/** Per axis of the body's own frame, the face a size drag keeps: 1 the low face, -1 the high face, 0 the centre. */
-export type ScaleAnchor = Record<'x' | 'y' | 'z', -1 | 0 | 1>
-
 /**
- * The component state that draws a body where figure-model put it. With `anchor` -- figure-model's
- * `figureScaleAnchorOf` for its part -- the scene's scale gizmo keeps that face while it is dragged, the face the model
- * keeps when the drag is written; without it the gizmo keeps the face across from the handle held, and the part jumped
- * on release (designer 2026-09-27). Body x · y · z are the component's width · depth · height, as the scene's axes are.
+ * The component state that draws a body where figure-model put it. A part the author edits is `owned`: while its size
+ * is dragged the scene does not move it and tells the handle held (`scaleGrab`), and the modeller draws where
+ * figure-model's size function puts it, every frame (ADR-0140 4.4). Body x · y · z are the component's width · depth ·
+ * height, as the scene's axes are.
  */
-export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, anchor?: ScaleAnchor): Record<string, unknown> | null {
+export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, owned = false): Record<string, unknown> | null {
   const frame = frameOf(part)
   if (!frame) return null
   const { centre, extent, rotation, origin } = frame
@@ -97,7 +94,7 @@ export function componentOf(part: FigureRenderPart, palette: Record<string, stri
     rotationX: round(euler.x),
     rotation: round(-euler.y),
     rotationY: round(euler.z),
-    ...(anchor ? { scaleAnchor: { ...anchor } } : {})
+    ...(owned ? { scalePlacement: 'owner' } : {})
   }
 }
 

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

@@ -147,8 +147,6 @@ export class FigureModellerPage extends PageView {
   @state() private commandError = ''
   /** What the verdict says blocks release now, handed to the editor's bar. */
   @state() private releaseBlockers: FigureGateFinding[] = []
-  /** The verdict's count, handed to the editor's verdict tab. */
-  @state() private instances?: number
   @state() private budget?: FigureBudgetLine
   private wasDirty = false
   private titled?: string | null
@@ -532,7 +530,7 @@ export class FigureModellerPage extends PageView {
     if (this.error) return html`<p role="alert" class="error">${this.error}</p>`
     const view = this.session.read()
     /* A new figure's third way to start: the app's assistant dock, with a request put in its input for the author to finish and send (B, U04). */
-    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .instances=${this.instances} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
+    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
       ${this.commandError ? html`<p slot="notice" fit-error role="alert">${this.commandError}</p>` : ''}
       <figure-properties
         slot="figure"
@@ -562,7 +560,6 @@ export class FigureModellerPage extends PageView {
         .figureId=${view.id}
         .figureType=${this.row.type}
         @capacity-changed=${(event: CustomEvent) => {
-          this.instances = event.detail.instances
           this.budget = event.detail.budget
         }}
         @fit-base-to-parts=${this.fitToParts}

package/dist-client/modeller/canvas.d.ts

@@ -2,16 +2,19 @@ import { LitElement, type PropertyValues } from 'lit';
 import type { GizmoReach } from './gizmo.js';
 import type { FigureRenderPart } from './renderer.js';
 import { type ViewSettings } from '@things-factory/figure-viewer/dist-client/figure-view.js';
-import { type ScaleAnchor } from './stage-model.js';
 export declare class FigureCanvas extends LitElement {
     static styles: import("lit").CSSResult;
     parts: FigureRenderPart[];
     palette: Record<string, string>;
-    /** The face a size drag keeps, per part (figure-model's `figureScaleAnchorOf`), so the drag shows what is written. */
-    anchors: Record<string, ScaleAnchor>;
     /** Which figure is open. Another one stands the board up again. */
     context: string;
     selected: string;
+    /**
+     * The fastening window is open (ADR-0140 stage 4): a part pressed is aimed at, not chosen -- told out as `part-aimed`
+     * with where the press landed (the scene's `pickedAt`: the point and the drawn triangle's outward normal, in the
+     * figure's frame), and the part being fastened stays chosen.
+     */
+    aiming: boolean;
     /** What the gizmo may write for the selected part; a change beyond it is not applied and the part springs back. */
     reach: GizmoReach;
     view: ViewSettings;
@@ -61,6 +64,13 @@ export declare class FigureCanvas extends LitElement {
      * one that has outgrown it -- standing up again loses the selection and the camera.
      */
     private standUp;
+    /**
+     * A part's component state, kept for the part object it was made from while the palette and the board are the same: a
+     * size drag redraws the board every frame, and only the parts the frame moved are new objects (ADR-0140 4.4).
+     */
+    private made;
+    private madeFor?;
+    private componentFor;
     private components;
     /** The components standing now, by name. Not held between calls: the scene stands its board up again at times. */
     private standing;
@@ -72,9 +82,20 @@ export declare class FigureCanvas extends LitElement {
     private watchScene;
     /** Components the gizmo changed since the last commit, by part name. */
     private pending;
+    /** The handle each size drag held, by part name, from the scene's `scaleGrab` -- told with the release. */
+    private grabs;
+    private sizingFrame?;
+    /** Once an animation frame: where a size drag stands, told so the editor draws figure-model's result for it. */
+    private sizingSoon;
     private pointerDown;
     private commitTimer?;
+    /**
+     * The parts as they stood when the pointer went down. A drag is measured against them: while a size drag is drawn, the
+     * parts given are its frames (ADR-0140 4.4), and measured against those it grew on itself and its release wrote nothing.
+     */
+    private atPress?;
     private onPointerDown;
+    private pressedPart;
     private onPointerUp;
     private commitSoon;
     /** Tell each changed part once, in the inputs' terms; then put the board where the inputs say (a refusal springs back). */