@things-factory/figure-ui 10.1.75 → 10.1.76

package/client/figure-assistant.ts

@@ -4,14 +4,14 @@
  *
  * A proposal is a list of the modeller's own commands (ADR-0094). Running it applies them in the modeller as one step
  * of its history: a revision on the figure open there, at the version the model saw; a new figure on a new figure the
- * modeller opens. The outcome is said in words on every branch (`v3-ai-proposal.ts`).
+ * modeller opens. The outcome is said in words on every branch (`ai-proposal.ts`).
  */
 import { i18next } from '@operato/i18n'
 import { navigate } from '@operato/shell'
 import { registerProposalHandler } from '@things-factory/ai-assistant/dist-client/index.js'
 
 import { modellerPathOf } from './modeller/modeller-route.js'
-import { pendNewFigure, runFigureProposal, type FigureApplyDetail } from './modeller/v3-ai-proposal.js'
+import { pendNewFigure, runFigureProposal, type FigureApplyDetail } from './modeller/ai-proposal.js'
 
 export const FIGURE_CANDIDATE_TOOL = 'proposeFigureCandidate'
 
@@ -20,7 +20,7 @@ registerProposalHandler(FIGURE_CANDIDATE_TOOL, async (proposal, context) => {
     proposal,
     {
       offer(detail: FigureApplyDetail) {
-        window.dispatchEvent(new CustomEvent('figure-v3-apply', { detail }))
+        window.dispatchEvent(new CustomEvent('figure-apply', { detail }))
         return detail
       },
       openNew(steps) {

package/client/graphql/{v3-store.ts → store.ts}

@@ -1,10 +1,10 @@
 import gql from 'graphql-tag'
 import { client } from '@operato/graphql'
 import { fetchFigure } from './index.js'
-import type { V3ProductStore, V3ProductRecord } from '../modeller/v3-product-session.js'
+import type { FigureProductStore, FigureProductRecord } from '../modeller/product-session.js'
 
-/** V3 source is sent intact. No conversion into the old parts/base authoring representation. */
-export const v3ProductStore: V3ProductStore = {
+/** source is sent intact. No conversion into the old parts/base authoring representation. */
+export const figureProductStore: FigureProductStore = {
   async load(id) {
     const record = await fetchFigure(id)
     if (!record?.source) throw Error('Figure 정본이 없습니다.')
@@ -13,8 +13,8 @@ export const v3ProductStore: V3ProductStore = {
   async save(request) {
     const response = await client.mutate({
       mutation: gql`
-        mutation SaveFigureV3($source: String!, $id: String, $expectedSource: String, $creationId: String, $thumbnail: String, $type: String) {
-          saveFigureV3(
+        mutation SaveFigure($source: String!, $id: String, $expectedSource: String, $creationId: String, $thumbnail: String, $type: String) {
+          saveFigure(
             source: $source
             id: $id
             expectedSource: $expectedSource
@@ -30,7 +30,7 @@ export const v3ProductStore: V3ProductStore = {
       variables: request
     })
     if (response.errors?.length) throw Error(response.errors.map(e => e.message).join('\n'))
-    const result = response.data?.saveFigureV3 as V3ProductRecord | undefined
+    const result = response.data?.saveFigure as FigureProductRecord | undefined
     if (!result?.id || !result.source) throw Error('서버가 저장 결과를 돌려주지 않았습니다.')
     return result
   }

package/client/modeller/{v3-ai-proposal.ts → ai-proposal.ts}

@@ -5,20 +5,20 @@
  *
  * Kept free of Lit, i18n and the shell so node tests read it directly; the handler and the page pass in what they own.
  */
-import type { V3ProposalStep } from '@hatiolab/figure-model'
+import type { FigureProposalStep } from '@hatiolab/figure-model'
 
 /** What the card carries, as `proposeFigureCandidate` returned it. */
 export interface FigureProposalCard {
-  steps?: V3ProposalStep[]
+  steps?: FigureProposalStep[]
   create?: boolean
   figureId?: string
   context?: string
   revision?: number
 }
 
-/** The `figure-v3-apply` event's detail. The page that takes it sets `applied`, and `error` when refused. */
+/** The `figure-apply` event's detail. The page that takes it sets `applied`, and `error` when refused. */
 export interface FigureApplyDetail {
-  steps: V3ProposalStep[]
+  steps: FigureProposalStep[]
   create: boolean
   context?: string
   revision?: number
@@ -33,7 +33,7 @@ export interface FigureProposalTarget {
   /** Offers the proposal to a modeller on screen. It comes back untouched when none took it. */
   offer(detail: FigureApplyDetail): FigureApplyDetail
   /** Opens a new figure in the modeller and applies the steps there; resolves once the page has, or has not. */
-  openNew(steps: V3ProposalStep[]): Promise<{ applied: boolean; error?: string; code?: string }>
+  openNew(steps: FigureProposalStep[]): Promise<{ applied: boolean; error?: string; code?: string }>
 }
 
 export interface FigureProposalOutcome {
@@ -85,9 +85,9 @@ export async function runFigureProposal(card: FigureProposalCard, target: Figure
   modeller on a new figure; the page takes it once it has started that figure. Left untaken, it lapses -- a later new
   figure must not receive steps nobody is waiting for.
 */
-let pending: { steps: V3ProposalStep[]; settle: (result: { applied: boolean; error?: string; code?: string }) => void } | undefined
+let pending: { steps: FigureProposalStep[]; settle: (result: { applied: boolean; error?: string; code?: string }) => void } | undefined
 
-export function pendNewFigure(steps: V3ProposalStep[], ms = 10_000): Promise<{ applied: boolean; error?: string; code?: string }> {
+export function pendNewFigure(steps: FigureProposalStep[], ms = 10_000): Promise<{ applied: boolean; error?: string; code?: string }> {
   pending?.settle({ applied: false, code: 'not-opened' })
   return new Promise(resolve => {
     const mine = {
@@ -104,7 +104,7 @@ export function pendNewFigure(steps: V3ProposalStep[], ms = 10_000): Promise<{ a
 }
 
 /** For the page, on a new figure it has just started: the steps waiting for it, and where to say how it went. */
-export function takePendingNewFigure(): { steps: V3ProposalStep[]; settle: (result: { applied: boolean; error?: string; code?: string }) => void } | undefined {
+export function takePendingNewFigure(): { steps: FigureProposalStep[]; settle: (result: { applied: boolean; error?: string; code?: string }) => void } | undefined {
   const taken = pending
   pending = undefined
   return taken

package/client/modeller/{v3-align.ts → align.ts}

@@ -1,14 +1,14 @@
-import { compileV3Asset, v3OccupiedBoxesOf, v3WritersOf } from '@hatiolab/figure-model'
-import type { V3Asset, V3InputChange, V3WorldBox } from '@hatiolab/figure-model'
+import { compileFigureAsset, figureOccupiedBoxesOf, figureWritersOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureWorldBox } from '@hatiolab/figure-model'
 
-import type { GizmoReach } from './v3-gizmo.js'
+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.
  *
  * 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 (`v3OccupiedBoxesOf`), so a turned part lands by what it
+ * y 0. The part's box is its evaluated, rotated extent (`figureOccupiedBoxesOf`), so a turned part lands by what it
  * actually covers, not by its unturned size.
  *
  * Every tool writes the part's own position (and, for snap, size) inputs — the same ones the gizmo writes, and only
@@ -18,15 +18,15 @@ export type AlignTool = 'centre-x' | 'centre-z' | 'floor' | 'snap'
 
 const AXES = ['x', 'y', 'z'] as const
 
-export function boxOf(asset: V3Asset, part: string): V3WorldBox | undefined {
-  const geometry = compileV3Asset(asset).evaluate().geometry
-  return v3OccupiedBoxesOf(geometry, v3WritersOf(asset)).find(box => box.part === part)
+export function boxOf(asset: FigureAsset, part: string): FigureWorldBox | undefined {
+  const geometry = compileFigureAsset(asset).evaluate().geometry
+  return figureOccupiedBoxesOf(geometry, figureWritersOf(asset)).find(box => box.part === part)
 }
 
 /** The snapping grid: about five steps across the figure, on 1 · 2 · 5 multiples. */
-export function gridStepOf(asset: V3Asset): number {
-  const geometry = compileV3Asset(asset).evaluate().geometry
-  const boxes = v3OccupiedBoxesOf(geometry, v3WritersOf(asset))
+export function gridStepOf(asset: FigureAsset): number {
+  const geometry = compileFigureAsset(asset).evaluate().geometry
+  const boxes = figureOccupiedBoxesOf(geometry, figureWritersOf(asset))
   if (!boxes.length) return 1
   const span = Math.max(
     ...AXES.map(axis => {
@@ -38,12 +38,12 @@ export function gridStepOf(asset: V3Asset): number {
   return niceStep(span)
 }
 
-export function alignChanges(asset: V3Asset, part: string, reach: GizmoReach, tool: AlignTool): V3InputChange[] {
+export function alignChanges(asset: FigureAsset, part: string, reach: GizmoReach, tool: AlignTool): FigureInputChange[] {
   if (!reach.translate) return []
   const box = boxOf(asset, part)
   if (!box) return []
   const value = (id: string) => asset.designInputs[id] ?? 0
-  const set = (input: string, next: number): V3InputChange => ({ kind: 'set-design', input, unit: 'mm', value: Math.round(next) })
+  const set = (input: string, next: number): FigureInputChange => ({ kind: 'set-design', input, unit: 'mm', value: Math.round(next) })
   const at = (axis: 'x' | 'y' | 'z') => `${part}.position.${axis}`
   switch (tool) {
     case 'centre-x':
@@ -68,7 +68,7 @@ export function alignChanges(asset: V3Asset, part: string, reach: GizmoReach, to
  * 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.
  */
-export function mirrorChanges(asset: V3Asset, part: string, copy: string, axis: 'x' | 'z'): V3InputChange[] {
+export function mirrorChanges(asset: FigureAsset, part: string, copy: string, axis: 'x' | 'z'): FigureInputChange[] {
   const box = boxOf(asset, part)
   if (!box) return []
   const id = `${part}.position.${axis}`
@@ -76,7 +76,7 @@ export function mirrorChanges(asset: V3Asset, part: string, copy: string, axis:
 }
 
 /** Mirroring a part that already sits on the centre plane would put the copy inside it, so it is refused. */
-export function canMirror(asset: V3Asset, part: string, axis: 'x' | 'z', reach: GizmoReach): boolean {
+export function canMirror(asset: FigureAsset, part: string, axis: 'x' | 'z', reach: GizmoReach): boolean {
   const box = reach.translate ? boxOf(asset, part) : undefined
   return !!box && Math.abs(box.centre[axis]) >= 0.5
 }

package/client/modeller/{v3-canvas.ts → canvas.ts}

@@ -3,23 +3,23 @@ import { customElement, property, query } from 'lit/decorators.js'
 import { i18next } from '@operato/i18n'
 import { create, Model, niceGridStep } from '@hatiolab/things-scene'
 
-import type { GizmoReach } from './v3-gizmo.js'
-import type { V3RenderPart } from './v3-renderer.js'
+import type { GizmoReach } from './gizmo.js'
+import type { FigureRenderPart } from './renderer.js'
 import { DEFAULT_VIEW, sceneLook, WORKBENCH, type ViewSettings } from './figure-view.js'
-import { boardFor, changedKeys, componentOf, gizmoResultOf, type Board } from './v3-stage-model.js'
-import { JOINT_FAN } from './v3-joint-fan.js'
-import { ownerOf } from './v3-fields.js'
+import { boardFor, changedKeys, componentOf, gizmoResultOf, type Board } from './stage-model.js'
+import { JOINT_FAN } from './joint-fan.js'
+import { ownerOf } from './fields.js'
 
 /*
  * The modeller's canvas -- a things-scene board in editing mode.
  *
- * Each body figure-model evaluates stands on the board as a `figure-v3-part` component, so everything the canvas
+ * Each body figure-model evaluates stands on the board as a `figure-part` component, so everything the canvas
  * has comes from the scene, not from code of our own: picking and the orange outline, the gizmo with its snapping and
  * live readout, box and shift selection, the camera (damping, zoom toward the cursor, double-click to fit, the six
  * view presets and their keys), the studio environment, the coordinate ground, lights and shadows, supersampling.
  * An earlier canvas drew the bodies with three.js directly and lost all of that (user, 2026-09-24: "why nerf it?").
  *
- * What the gizmo writes back to a component comes out as `part-transformed` in the inputs' terms (`v3-stage-model`),
+ * What the gizmo writes back to a component comes out as `part-transformed` in the inputs' terms (`stage-model`),
  * and the editor turns it into one step of the history; the next evaluation puts the component where the inputs say,
  * so a change a part cannot take (a fastened part moved) springs back.
  */
@@ -53,8 +53,8 @@ const FAN_COLOUR = '#ff8a00'
 /* The 2D side of the board, which the author never sees on this page but the scene paints. */
 const PAPER = '#ffffff'
 
-@customElement('figure-v3-canvas')
-export class FigureV3Canvas extends LitElement {
+@customElement('figure-canvas')
+export class FigureCanvas extends LitElement {
   static styles = css`
     :host {
       position: relative;
@@ -79,7 +79,7 @@ export class FigureV3Canvas extends LitElement {
       color: #f4f4f4;
     }
   `
-  @property({ attribute: false }) parts: V3RenderPart[] = []
+  @property({ attribute: false }) parts: FigureRenderPart[] = []
   @property({ attribute: false }) palette: Record<string, string> = {}
   /** Which figure is open. Another one stands the board up again. */
   @property() context = ''
@@ -89,12 +89,12 @@ export class FigureV3Canvas extends LitElement {
   @property({ attribute: false }) view: ViewSettings = DEFAULT_VIEW
   /**
    * View only: nothing that happens on the board is told out. The card's picture is taken from a second canvas stood up
-   * off screen (`v3-thumbnail.ts`); the scene settles its components as it builds them, and a change told from there
+   * off screen (`thumbnail.ts`); the scene settles its components as it builds them, and a change told from there
    * would reach the editor as an edit.
    */
   @property({ type: Boolean }) viewOnly = false
-  /** Where the selected part turns and how far (`v3-joint-fan`): shown, never picked, never saved. */
-  @property({ attribute: false }) fan: V3RenderPart | null = null
+  /** Where the selected part turns and how far (`joint-fan`): shown, never picked, never saved. */
+  @property({ attribute: false }) fan: FigureRenderPart | null = null
 
   @query('div[stage]') private stage!: HTMLDivElement
 

package/client/modeller/{v3-clips.ts → clips.ts}

@@ -1,5 +1,5 @@
 import { driverValue } from '@hatiolab/figure-model'
-import type { V3Asset, V3Driver, V3InputChange } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureDriver, FigureInputChange } from '@hatiolab/figure-model'
 
 /*
  * The figure's clips: controls played by keys over time, grouped into clips that each run on one
@@ -28,7 +28,7 @@ export interface Clip {
 
 const round = (n: number) => Math.round(n * 1000) / 1000
 
-export function clipsOf(asset: V3Asset): Clip[] {
+export function clipsOf(asset: FigureAsset): Clip[] {
   const inputs = new Map(asset.document.model.inputs.map(i => [i.id, i]))
   const clips = new Map<string, Clip>()
   for (const d of asset.drivers ?? []) {
@@ -51,16 +51,16 @@ export function clipsOf(asset: V3Asset): Clip[] {
 }
 
 /** The controls no clip plays yet -- the ones a new track can take. One driver per control. */
-export function undrivenOf(asset: V3Asset): string[] {
+export function undrivenOf(asset: FigureAsset): string[] {
   const driven = new Set((asset.drivers ?? []).map(d => d.state))
   return asset.document.model.inputs.filter(i => i.role === 'state' && !driven.has(i.id)).map(i => i.id)
 }
 
 /** The pose a clip gives at a moment, as one batch of state changes -- one step of the history. */
-export function poseAt(asset: V3Asset, clip: string, seconds: number): V3InputChange[] {
+export function poseAt(asset: FigureAsset, clip: string, seconds: number): FigureInputChange[] {
   const units = new Map(asset.document.model.inputs.map(i => [i.id, i.unit]))
   return (asset.drivers ?? [])
-    .filter((d: V3Driver) => d.clip === clip)
+    .filter((d: FigureDriver) => d.clip === clip)
     .map(d => {
       const unit = units.get(d.state)!
       return { kind: 'set-state' as const, input: d.state, unit, value: driverValue(d, seconds, unit === 'deg' || unit === 'rad' ? unit : 'other') }

package/client/modeller/{v3-controls.ts → controls.ts}

@@ -1,4 +1,4 @@
-import type { V3Asset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
 
 /*
  * The figure's controls -- its state inputs: the values a board or a connector sets to pose
@@ -23,7 +23,7 @@ export interface Control {
   step: number
 }
 
-export function controlsOf(asset: V3Asset, values: Record<string, number> = {}): Control[] {
+export function controlsOf(asset: FigureAsset, values: Record<string, number> = {}): Control[] {
   return asset.document.model.inputs
     .filter(input => input.role === 'state')
     .map(input => {