@things-factory/figure-ui 10.1.74 → 10.1.76

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

@@ -1,18 +1,18 @@
 import {
-  compileV3Asset,
-  compileV3Document,
+  compileFigureAsset,
+  compileFigureDocument,
   LIMITS,
   SEGMENT_PRESETS,
-  V3_BUDGET_KEYS,
-  V3_GRADE_SCALE,
-  v3CostOf,
-  v3GradeOf,
-  v3MaterialKeyOf,
-  v3ScoreOf,
-  v3WorldBoxesOf,
-  v3WritersOf
+  FIGURE_BUDGET_KEYS,
+  FIGURE_GRADE_SCALE,
+  figureCostOf,
+  figureGradeOf,
+  figureMaterialKeyOf,
+  figureScoreOf,
+  figureWorldBoxesOf,
+  figureWritersOf
 } from '@hatiolab/figure-model'
-import type { V3Asset, V3AssetGeometry, V3BudgetKey, V3BudgetUse, V3Cost, V3Geometry, V3Score } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureAssetGeometry, FigureBudgetKey, FigureBudgetUse, FigureCost, FigureGeometry, FigureScore } from '@hatiolab/figure-model'
 
 import { capacityFrom } from './scene-budget.js'
 import type { FigureCapacity } from './scene-budget.js'
@@ -21,40 +21,40 @@ import type { FigureCapacity } from './scene-budget.js'
  * The modeller's maturity report, read off the evaluated asset (user, 2026-09-24: the tab showed a count and nothing
  * else — 「왜 이렇게 너프되었는지」):
  *
- *   grade A–D and its scale   figure-model's `v3ScoreOf`: one screen's target shared per instance (groups,
+ *   grade A–D and its scale   figure-model's `figureScoreOf`: one screen's target shared per instance (groups,
  *                             triangles) and the declared rule limits (independent, transparent)
- *   radar · axes              six axes; reactive is not measured, and detail has no V3 field
+ *   radar · axes              six axes; reactive is not measured, and detail has no field
  *   drawing cost              triangles, distinct shapes, distinct materials
  *   trend                     what grows with the instance count and what the instances share
  *
  * Kept apart from the element so it can be tested without a browser.
  *
- * ## What the V3 renderer shares, which is what the numbers count
+ * ## What the renderer shares, which is what the numbers count
  *
- * things-scene draws one mesh per drawn body (`figure-v3-rig.ts`) — no merging by material — so a body is
- * a draw call. It shares geometry by provider, dimensions, segments and profile (`figure-v3-geometry.ts`, `keyOf`)
+ * things-scene draws one mesh per drawn body (`figure-rig.ts`) — no merging by material — so a body is
+ * a draw call. It shares geometry by provider, dimensions, segments and profile (`figure-geometry.ts`, `keyOf`)
  * and materials by token, preset, transparency and light (`materialFor`). The keys below are those keys; a
  * distinct-shape count that used another key would describe a renderer that does not exist.
  *
- * ## Budgets V3 does not have
+ * ## Budgets does not have
  *
  * Two budgets are not measured here, and are not shown as zero:
- *   - off-palette surfaces: the V3 material has no surface field, so there is nothing to count;
- *   - part count by detail level: V3 does not carry the detail level (chief architect, 2026-09-24, ADR-0087).
+ *   - off-palette surfaces: the material has no surface field, so there is nothing to count;
+ *   - part count by detail level: does not carry the detail level (chief architect, 2026-09-24, ADR-0087).
  */
 
 /*
-  The grade, its budgets and its bounds are figure-model's (`v3ScoreOf`), so the catalogue grades a figure as this tab
+  The grade, its budgets and its bounds are figure-model's (`figureScoreOf`), so the catalogue grades a figure as this tab
   does. The grade is the headroom against one screen's target (`LIMITS.screenInstances`), not a draw-call limit.
 */
-export { V3_BUDGET_KEYS, V3_GRADE_SCALE as GRADE_SCALE, v3GradeOf as gradeOf }
-export type { V3BudgetKey, V3BudgetUse, V3Score }
+export { FIGURE_BUDGET_KEYS, FIGURE_GRADE_SCALE as GRADE_SCALE, figureGradeOf as gradeOf }
+export type { FigureBudgetKey, FigureBudgetUse, FigureScore }
 
-export type V3AxisKey = 'scale' | 'consistency' | 'reuse' | 'detail' | 'reactive' | 'readable'
+export type FigureAxisKey = 'scale' | 'consistency' | 'reuse' | 'detail' | 'reactive' | 'readable'
 
 /** One maturity axis. */
-export interface V3MaturityAxis {
-  key: V3AxisKey
+export interface FigureMaturityAxis {
+  key: FigureAxisKey
   /** 0–1. Absent when the axis cannot be measured. */
   ratio?: number
   reading?: string
@@ -66,7 +66,7 @@ export interface V3MaturityAxis {
 }
 
 /** Instances on one screen, and what each series costs at that count. */
-export interface V3CurvePoint {
+export interface FigureCurvePoint {
   instances: number
   triangles: number
   drawCalls: number
@@ -75,16 +75,16 @@ export interface V3CurvePoint {
   materials: number
 }
 
-export interface V3Report {
-  cost: V3Cost
+export interface FigureReport {
+  cost: FigureCost
   capacity: FigureCapacity
-  score: V3Score
+  score: FigureScore
   /** Distinct shapes and materials among the drawn bodies — the 「그리는 비용」 rows. */
   distinctShapes: number
   distinctMaterials: number
   reuse: { distinct: number; parts: number; saved: number }
-  axes: V3MaturityAxis[]
-  curve: V3CurvePoint[]
+  axes: FigureMaturityAxis[]
+  curve: FigureCurvePoint[]
 }
 
 /** The board target for the scale axis: 500 assets on one drawing (design document §4.15). */
@@ -94,27 +94,27 @@ export const BOARD_ASSETS = 500
  * The report for one asset, or nothing when no body is drawn — then there is nothing to measure, and the screen
  * says so rather than drawing zeros.
  *
- * Evaluated at the asset's own design and state defaults, as `v3CostOf` is.
+ * Evaluated at the asset's own design and state defaults, as `figureCostOf` is.
  */
-export function v3ReportOf(asset: V3Asset): V3Report | undefined {
-  const cost = v3CostOf(asset)
+export function figureReportOf(asset: FigureAsset): FigureReport | undefined {
+  const cost = figureCostOf(asset)
   const capacity = capacityFrom(cost.groups, cost.triangles)
   if (!capacity) return undefined
 
-  const drawn = compileV3Asset(asset)
+  const drawn = compileFigureAsset(asset)
     .evaluate()
     .geometry.filter(body => body.visible !== false)
-  const plan = compileV3Document(asset.document)
-  const writers = v3WritersOf(asset)
+  const plan = compileFigureDocument(asset.document)
+  const writers = figureWritersOf(asset)
 
   const shapes = new Set(drawn.map(shapeKeyOf))
   const materials = new Set(drawn.map(materialKeyOf))
 
-  const score = v3ScoreOf(asset)!
+  const score = figureScoreOf(asset)!
 
   const reuse = { distinct: shapes.size, parts: drawn.length, saved: drawn.length - shapes.size }
 
-  const axes: V3MaturityAxis[] = [
+  const axes: FigureMaturityAxis[] = [
     {
       key: 'scale',
       // The board target filled is 1; room beyond it is better spent on the other axes, so it does not count more.
@@ -154,10 +154,10 @@ export function v3ReportOf(asset: V3Asset): V3Report | undefined {
 }
 
 /**
- * The key things-scene shares a body's geometry by (`figure-v3-geometry.ts` `keyOf`): provider, dimensions to a
+ * The key things-scene shares a body's geometry by (`figure-geometry.ts` `keyOf`): provider, dimensions to a
  * micrometre, segments (12 when unset), and a polygon's corners.
  */
-export function shapeKeyOf(body: V3AssetGeometry | V3Geometry): string {
+export function shapeKeyOf(body: FigureAssetGeometry | FigureGeometry): string {
   if (!('shape' in body)) {
     // A scalar body has no mesh of its own; it is still one drawn body, told apart by what it declares.
     const dims = Object.keys(body.dimensions).sort().map(k => `${k}=${body.dimensions[k]}`).join(',')
@@ -175,21 +175,21 @@ export function shapeKeyOf(body: V3AssetGeometry | V3Geometry): string {
 }
 
 /**
- * The key things-scene shares a material by (`figure-v3-rig.ts` `materialFor`), within one asset: token, preset,
+ * The key things-scene shares a material by (`figure-rig.ts` `materialFor`), within one asset: token, preset,
  * transparency, and the light when it is on. The colour follows from the token, so it is not a second key.
  */
-export function materialKeyOf(body: V3AssetGeometry): string {
-  return v3MaterialKeyOf(body)
+export function materialKeyOf(body: FigureAssetGeometry): string {
+  return figureMaterialKeyOf(body)
 }
 
 /**
  * Does it look like one set — baselines 3 and 4, three checks.
  *
- * Two of them hold by construction in V3: the material has no surface field, so there is no texture, and the
- * format refuses a segment count outside the presets (`compileV3Asset`, `QUALITY`). They are still counted, so
+ * Two of them hold by construction: the material has no surface field, so there is no texture, and the
+ * format refuses a segment count outside the presets (`compileFigureAsset`, `QUALITY`). They are still counted, so
  * the ratio stays one fault in three.
  */
-function consistency(asset: V3Asset, distinctMaterials: number): V3MaturityAxis {
+function consistency(asset: FigureAsset, distinctMaterials: number): FigureMaturityAxis {
   const textures = 0
   const offPreset = asset.appearance.filter(look => look.segments !== undefined && !SEGMENT_PRESETS.includes(look.segments)).length
   const faults = (textures > 0 ? 1 : 0) + (offPreset > 0 ? 1 : 0) + (distinctMaterials > LIMITS.distinctMaterials ? 1 : 0)
@@ -201,7 +201,7 @@ function consistency(asset: V3Asset, distinctMaterials: number): V3MaturityAxis
   }
 }
 
-/** Seen from above, these do not fill their footprint box, by V3 provider name. */
+/** Seen from above, these do not fill their footprint box, by provider name. */
 const ROUND_FOOTPRINT: readonly string[] = ['cylinder', 'ellipticCylinder', 'frustum', 'sphere']
 
 /**
@@ -211,20 +211,20 @@ const ROUND_FOOTPRINT: readonly string[] = ['cylinder', 'ellipticCylinder', 'fru
  * finer segment count does not raise it: H = −Σ p·log p over each material's share of the footprint plus the
  * background, divided by log(`LIMITS.distinctMaterials` + 1), the most this measure can reach.
  *
- * The footprint is the base box: the space the asset declares when it declares one (ADR-0044's box is V3's
+ * The footprint is the base box: the space the asset declares when it declares one (ADR-0044's box is the model's
  * occupancy), otherwise the drawn bodies' own extent. Bodies are their axis-aligned world boxes
- * (`v3WorldBoxesOf`, the gate's reading); the higher one covers the lower.
+ * (`figureWorldBoxesOf`, the gate's reading); the higher one covers the lower.
  */
 function readable(
-  asset: V3Asset,
-  plan: ReturnType<typeof compileV3Document>,
-  drawn: V3AssetGeometry[],
+  asset: FigureAsset,
+  plan: ReturnType<typeof compileFigureDocument>,
+  drawn: FigureAssetGeometry[],
   writers: Map<string, string>
-): V3MaturityAxis {
+): FigureMaturityAxis {
   const placed = drawn
     .filter(body => 'pose' in body)
     // One placed, drawn body gives exactly one box; boxes are taken one by one to keep each with its material.
-    .map(body => ({ body, box: v3WorldBoxesOf([body], writers)[0]! }))
+    .map(body => ({ body, box: figureWorldBoxesOf([body], writers)[0]! }))
   if (placed.length === 0) return { key: 'readable', blocked: 'figure.text.maturity-blocked-no-parts' }
 
   let frame: { x0: number; x1: number; z0: number; z1: number }
@@ -260,7 +260,7 @@ function readable(
 
 /** Which material shows from above, on a 64 × 64 grid over the footprint, over world boxes. */
 function topViewRegions(
-  placed: { body: V3AssetGeometry; box: ReturnType<typeof v3WorldBoxesOf>[number] }[],
+  placed: { body: FigureAssetGeometry; box: ReturnType<typeof figureWorldBoxesOf>[number] }[],
   frame: { x0: number; x1: number; z0: number; z1: number }
 ) {
   const GRID = 64
@@ -320,13 +320,13 @@ export function decadeSteps(from: number, to: number): number[] {
 
 // ─── The trend chart ─────────────────────────────────────────────────────────
 
-export type V3CurveSeries = 'triangles' | 'drawCalls' | 'geometries' | 'materials'
+export type FigureCurveSeries = 'triangles' | 'drawCalls' | 'geometries' | 'materials'
 
 /**
  * The four lines: two that grow with the instance count and two that stay flat — the flat ones are what the
  * instances share. Materials are dashed and drawn last, so a line under them still shows where the two meet.
  */
-export const CURVE_SERIES: readonly { key: V3CurveSeries; flat: boolean; dashed?: boolean }[] = [
+export const CURVE_SERIES: readonly { key: FigureCurveSeries; flat: boolean; dashed?: boolean }[] = [
   { key: 'triangles', flat: false },
   { key: 'drawCalls', flat: false },
   { key: 'geometries', flat: true },
@@ -336,10 +336,10 @@ export const CURVE_SERIES: readonly { key: V3CurveSeries; flat: boolean; dashed?
 /** The chart's size. The chart is shown at this size in a sheet; shrunk into the side, its words are unreadable. */
 export const CURVE_SIZE = { width: 680, height: 380, pad: { top: 52, right: 208, bottom: 44, left: 62 } } as const
 
-export interface V3CurveLayout {
+export interface FigureCurveLayout {
   xTicks: { x: number; label: string }[]
   yTicks: { y: number; label: string }[]
-  lines: { key: V3CurveSeries; d: string; flat: boolean; dashed: boolean; last: number }[]
+  lines: { key: FigureCurveSeries; d: string; flat: boolean; dashed: boolean; last: number }[]
   /** The value the flat lines share when they lie on one another, so the screen can say why one line is missing. */
   overlap?: number
 }
@@ -354,7 +354,7 @@ export function shortNumber(v: number): string {
 }
 
 /** Where the chart puts each line and tick. Both axes are logarithmic. */
-export function curveLayout(points: V3CurvePoint[]): V3CurveLayout | undefined {
+export function curveLayout(points: FigureCurvePoint[]): FigureCurveLayout | undefined {
   if (points.length === 0) return undefined
   const { width, height, pad } = CURVE_SIZE
   const minX = points[0]!.instances
@@ -369,9 +369,9 @@ export function curveLayout(points: V3CurvePoint[]): V3CurveLayout | undefined {
   const px = (v: number) => pad.left + ((log10(v) - log10(minX)) / spanX) * plotW
   const py = (v: number) => pad.top + plotH - (log10(v) / spanY) * plotH
 
-  const yTicks: V3CurveLayout['yTicks'] = []
+  const yTicks: FigureCurveLayout['yTicks'] = []
   for (let e = 0; Math.pow(10, e) <= maxY * 1.001; e++) yTicks.push({ y: py(Math.pow(10, e)), label: shortNumber(Math.pow(10, e)) })
-  const xTicks: V3CurveLayout['xTicks'] = []
+  const xTicks: FigureCurveLayout['xTicks'] = []
   for (let e = 0; Math.pow(10, e) <= maxX * 1.001; e++) {
     const v = Math.pow(10, e)
     if (v >= minX) xTicks.push({ x: px(v), label: shortNumber(v) })
@@ -390,7 +390,7 @@ export function curveLayout(points: V3CurvePoint[]): V3CurveLayout | undefined {
 }
 
 /** What the parts list shows under its title: the cost, how many fit, the grade and what decides it. */
-export interface V3BudgetLine {
+export interface FigureBudgetLine {
   triangles: number
   groups: number
   instances: number
@@ -398,7 +398,7 @@ export interface V3BudgetLine {
   tightest: { key: string; used: number; limit: number }
 }
 
-export function budgetOf(report: V3Report | undefined): V3BudgetLine | undefined {
+export function budgetOf(report: FigureReport | undefined): FigureBudgetLine | undefined {
   if (!report) return undefined
   const { tightest } = report.score
   return {

package/client/modeller/modeller-route.ts

@@ -1,5 +1,5 @@
 /**
- * The one modeller. The catalogue, a new figure and an old address all open the same page. `figure-v3-modeller`
+ * The one modeller. The catalogue, a new figure and an old address all open the same page. `figure-modeller`
  * stays as an alias so a link written under that name still lands.
  */
 export const MODELLER = 'figure-modeller'

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

@@ -1,9 +1,9 @@
-import { parseV3Asset, proposeV3Occupancy, type V3AuthoringAction } from '@hatiolab/figure-model'
+import { parseFigureAsset, proposeFigureOccupancy, type FigureAuthoringAction } from '@hatiolab/figure-model'
 
 /**
- * 「부품에 맞추기」의 V3 짝 — 공간을 지금 부품에서 다시 선언하는 한 걸음.
+ * 「부품에 맞추기」의 짝 — 공간을 지금 부품에서 다시 선언하는 한 걸음.
  *
- * figure-model 은 이것을 둘로 나눠 두었다: 제안(`proposeV3Occupancy`)은 무엇이 선언될지를 보여 주고, 확인
+ * figure-model 은 이것을 둘로 나눠 두었다: 제안(`proposeFigureOccupancy`)은 무엇이 선언될지를 보여 주고, 확인
  * (`declare-occupancy`)은 그 제안이 읽은 모양 그대로일 때만 받는다. 저작자가 누른 단추가 그 확인이다. 제안과 확인
  * 사이에 모델이 바뀌면 figure-model 이 `OCCUPANCY_STALE` 로 거절하므로, 여기서는 누른 순간의 원본으로 둘을 한
  * 번에 만든다.
@@ -16,11 +16,11 @@ export function occupancyFromParts(
   source: string,
   /** A different face to place it by — the properties tab's choice. Absent keeps the declared one. */
   placement?: 'floor' | 'ceiling' | 'center' | 'wall'
-): Extract<V3AuthoringAction, { kind: 'declare-occupancy' }> {
-  const asset = parseV3Asset(source)
+): Extract<FigureAuthoringAction, { kind: 'declare-occupancy' }> {
+  const asset = parseFigureAsset(source)
   return {
     kind: 'declare-occupancy',
-    proposal: proposeV3Occupancy(asset, { over: 'range' }),
+    proposal: proposeFigureOccupancy(asset, { over: 'range' }),
     placement: placement ?? asset.occupancy?.placement ?? 'floor'
   }
 }

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

@@ -1,12 +1,12 @@
-import type { V3PrimitiveCreation } from '@hatiolab/figure-model'
+import type { FigurePrimitiveCreation } from '@hatiolab/figure-model'
 
-import type { V3PaletteKind } from './figure-v3-parts.js'
+import type { FigurePaletteKind } from './figure-parts.js'
 
 /**
  * What a palette button makes: the part at a starting size a person then changes. Standing on the floor (its lowest
  * point at y 0) where the provider's frame is centred; a portal's frame already rises from its bottom.
  */
-export function paletteRecipe(kind: V3PaletteKind, id: string): V3PrimitiveCreation {
+export function paletteRecipe(kind: FigurePaletteKind, id: string): FigurePrimitiveCreation {
   const standing = (height: number) => ({ id, position: { x: 0, y: height / 2, z: 0 } })
   switch (kind) {
     case 'box':

package/client/modeller/{v3-preview-model.ts → preview-model.ts}

@@ -1,7 +1,7 @@
-import { compileV3Asset, v3OccupiedBoxesOf, v3WritersOf, V3_INSTANCE_SIZE_INPUTS } from '@hatiolab/figure-model'
-import type { V3Asset } from '@hatiolab/figure-model'
+import { compileFigureAsset, figureOccupiedBoxesOf, figureWritersOf, FIGURE_INSTANCE_SIZE_INPUTS } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
 
-/* The preview's arithmetic, apart from the element so it is tested without a browser (see figure-v3-preview.ts). */
+/* The preview's arithmetic, apart from the element so it is tested without a browser (see figure-preview.ts). */
 
 export const PREVIEW_FACTOR = 2
 
@@ -17,12 +17,12 @@ export const PREVIEW_WAYS: readonly { name: string; axes: readonly ('x' | 'y' |
 ]
 
 /** The size the figure was made at: its instance size when it declares one, else the room its bodies take. */
-export function authoredSizeOf(asset: V3Asset): { x: number; y: number; z: number } {
+export function authoredSizeOf(asset: FigureAsset): { x: number; y: number; z: number } {
   const d = asset.designInputs
-  const declared = (['x', 'y', 'z'] as const).map(axis => d[V3_INSTANCE_SIZE_INPUTS[axis]])
+  const declared = (['x', 'y', 'z'] as const).map(axis => d[FIGURE_INSTANCE_SIZE_INPUTS[axis]])
   if (declared.every(v => typeof v === 'number' && v > 0)) return { x: declared[0]!, y: declared[1]!, z: declared[2]! }
   /* No declared size: the room its bodies take up, so the instance is placed at the size it draws. */
-  const boxes = v3OccupiedBoxesOf(compileV3Asset(asset).evaluate().geometry, v3WritersOf(asset))
+  const boxes = figureOccupiedBoxesOf(compileFigureAsset(asset).evaluate().geometry, figureWritersOf(asset))
   const span = (axis: 'x' | 'y' | 'z') =>
     boxes.length ? Math.max(...boxes.map(b => b.centre[axis] + b.extent[axis] / 2)) - Math.min(...boxes.map(b => b.centre[axis] - b.extent[axis] / 2)) : 0
   return { x: Math.max(1, Math.round(span('x'))), y: Math.max(1, Math.round(span('y'))), z: Math.max(1, Math.round(span('z'))) }
@@ -59,13 +59,13 @@ export function previewInstances(type: string, size: { x: number; y: number; z:
  * it is drawn as asked. A figure that follows its height only is drawn at its one width in the wider variants, and
  * the preview says so rather than drawing them as though they grew.
  */
-export function previewClampsOf(asset: V3Asset, size: { x: number; y: number; z: number }): Record<string, Array<{ axis: 'x' | 'y' | 'z'; asked: number; used: number }>> {
+export function previewClampsOf(asset: FigureAsset, size: { x: number; y: number; z: number }): Record<string, Array<{ axis: 'x' | 'y' | 'z'; asked: number; used: number }>> {
   const inputs = asset.document.model.inputs
   return Object.fromEntries(
     PREVIEW_WAYS.map(way => [
       way.name,
       (['x', 'y', 'z'] as const).flatMap(axis => {
-        const input = inputs.find(i => i.id === V3_INSTANCE_SIZE_INPUTS[axis])
+        const input = inputs.find(i => i.id === FIGURE_INSTANCE_SIZE_INPUTS[axis])
         if (!input) return []
         const asked = Math.round(size[axis] * (way.axes.includes(axis) ? PREVIEW_FACTOR : 1))
         const used = Math.round(Math.min(Math.max(asked, input.min ?? -Infinity), input.max ?? Infinity))

package/client/modeller/{v3-product-session.ts → product-session.ts}

@@ -1,23 +1,23 @@
 import {
-  createV3Asset,
-  createV3EditorWorkspace,
-  serializeV3Asset,
-  parseV3Asset,
-  type V3InputChange,
-  type V3PrimitiveCreation,
-  type V3PartEdit,
-  type V3AuthoringAction,
-  type V3ProposalStep
+  createFigureAsset,
+  createFigureEditorWorkspace,
+  serializeFigureAsset,
+  parseFigureAsset,
+  type FigureInputChange,
+  type FigurePrimitiveCreation,
+  type FigurePartEdit,
+  type FigureAuthoringAction,
+  type FigureProposalStep
 } from '@hatiolab/figure-model'
 
-export interface V3ProductRecord {
+export interface FigureProductRecord {
   id: string
   source: string
 }
 
 /** Persistence is injected; neither the model engine nor the renderer owns the product ID. */
-export interface V3ProductStore {
-  load(id: string): Promise<V3ProductRecord>
+export interface FigureProductStore {
+  load(id: string): Promise<FigureProductRecord>
   save(request: {
     id?: string
     source: string
@@ -27,12 +27,12 @@ export interface V3ProductStore {
     thumbnail?: string
     /** The type name a new figure is created under (the first save asks for it). Not sent for an existing one. */
     type?: string
-  }): Promise<V3ProductRecord>
+  }): Promise<FigureProductRecord>
 }
 
 /** Product lifecycle boundary. A late response can never change another editor's asset or ID. */
-export function createV3ProductSession(store: V3ProductStore) {
-  const workspace = createV3EditorWorkspace()
+export function createFigureProductSession(store: FigureProductStore) {
+  const workspace = createFigureEditorWorkspace()
   let epoch = 0,
     id: string | undefined,
     baseline: string | undefined
@@ -69,7 +69,7 @@ export function createV3ProductSession(store: V3ProductStore) {
       ++epoch
       clear()
       loading = false
-      workspace.open(serializeV3Asset(createV3Asset('새 Figure')))
+      workspace.open(serializeFigureAsset(createFigureAsset('새 Figure')))
       creationId = crypto.randomUUID()
       return read()
     },
@@ -99,7 +99,7 @@ export function createV3ProductSession(store: V3ProductStore) {
       loading = false
       return read()
     },
-    apply(changes: V3InputChange[], origin: 'ui' | 'ai' = 'ui', expectedRevision?: number, context?: string) {
+    apply(changes: FigureInputChange[], origin: 'ui' | 'ai' = 'ui', expectedRevision?: number, context?: string) {
       const control = writable()
       // AI must supply the context AND revision captured when it started. Never substitute current values.
       if (origin === 'ai' && (context === undefined || expectedRevision === undefined))
@@ -116,7 +116,7 @@ export function createV3ProductSession(store: V3ProductStore) {
      * An AI proposal (ADR-0094): the modeller's commands, as one step of the history, on the version the model saw.
      * Never on the current one instead -- a person's edit in between makes the proposal stale, and it is refused.
      */
-    applyProposal(steps: readonly V3ProposalStep[], expectedRevision: number, context: string) {
+    applyProposal(steps: readonly FigureProposalStep[], expectedRevision: number, context: string) {
       writable()
       return workspace.applyProposal({ origin: 'ai', context, expectedRevision, steps })
     },
@@ -124,18 +124,18 @@ export function createV3ProductSession(store: V3ProductStore) {
      * A recipe put in by the person (ADR-0095): its resolved commands, as one step of the history, on the version open
      * now. The same path as a proposal; the person is its origin.
      */
-    applyRecipe(steps: readonly V3ProposalStep[]) {
+    applyRecipe(steps: readonly FigureProposalStep[]) {
       const at = writable()
       return workspace.applyProposal({ origin: 'ui', context: at.context, expectedRevision: at.expectedRevision, steps })
     },
-    add(part: V3PrimitiveCreation) {
+    add(part: FigurePrimitiveCreation) {
       return workspace.addPrimitive({ ...writable(), part })
     },
-    edit(edit: V3PartEdit) {
+    edit(edit: FigurePartEdit) {
       return workspace.editPart({ ...writable(), edit })
     },
     /** One authoring command — what a person means, not a graph edit — as one step of the same history. */
-    command(action: V3AuthoringAction) {
+    command(action: FigureAuthoringAction) {
       return workspace.command({ ...writable(), action })
     },
     undo() {
@@ -153,7 +153,7 @@ export function createV3ProductSession(store: V3ProductStore) {
      *
      * The picture is the caller's because taking it needs a canvas, and this session is the place that knows
      * nothing about drawing. A save with no picture is a save: a tab in the background cannot draw, and the
-     * source matters more than the card (see `v3-thumbnail.ts`).
+     * source matters more than the card (see `thumbnail.ts`).
      */
     async save({ thumbnail, type }: { thumbnail?: string; type?: string } = {}) {
       const control = writable(),
@@ -164,7 +164,7 @@ export function createV3ProductSession(store: V3ProductStore) {
         const record = await store.save({ id, source: exported.text, expectedSource: baseline, creationId, thumbnail, ...(id || !type ? {} : { type }) })
         if (requestEpoch !== epoch) return read()
         if (!record.id || (id !== undefined && record.id !== id)) throw Error('저장 응답의 Figure 대상이 다릅니다.')
-        if (serializeV3Asset(parseV3Asset(record.source)) !== exported.text)
+        if (serializeFigureAsset(parseFigureAsset(record.source)) !== exported.text)
           throw Error('저장 응답이 보낸 모델과 다릅니다. 저장 상태를 다시 확인해 주세요.')
         workspace.acknowledgeSaved(exported)
         id = record.id
@@ -176,4 +176,4 @@ export function createV3ProductSession(store: V3ProductStore) {
     }
   }
 }
-export type V3ProductSession = ReturnType<typeof createV3ProductSession>
+export type FigureProductSession = ReturnType<typeof createFigureProductSession>

package/client/modeller/{v3-recipe-source.ts → recipe-source.ts}

@@ -1,9 +1,9 @@
 import { fetchRecipeGuide, fetchRecipeTemplates } from '../graphql/index.js'
-import { templatesOf, type RecipeTemplate } from './v3-recipes.js'
+import { templatesOf, type RecipeTemplate } from './recipes.js'
 
 /**
  * Where the modeller gets its recipe templates: the server's static files (ADR-0095, amended 2026-09-26). The one place
- * they are read -- the rules in `v3-recipes.ts` stay free of the network so they are tested without it.
+ * they are read -- the rules in `recipes.ts` stay free of the network so they are tested without it.
  */
 export async function availableRecipes(lang: string): Promise<RecipeTemplate[]> {
   return templatesOf(await fetchRecipeTemplates(lang))

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

@@ -1,11 +1,11 @@
-import { describeV3Recipe } from '@hatiolab/figure-model'
-import type { V3Recipe, V3RecipeParam, V3RecipeValue } from '@hatiolab/figure-model'
+import { describeFigureRecipe } from '@hatiolab/figure-model'
+import type { FigureRecipe, FigureRecipeParam, FigureRecipeValue } from '@hatiolab/figure-model'
 
 import type { RecipeTemplateRow } from '../graphql/index.js'
 
 /** A template in the catalog: the server's row, its recipe parsed. */
 export interface RecipeTemplate extends Omit<RecipeTemplateRow, 'source'> {
-  recipe: V3Recipe
+  recipe: FigureRecipe
 }
 
 /*
@@ -30,11 +30,11 @@ export function templatesOf(rows: ReadonlyArray<RecipeTemplateRow>): RecipeTempl
 export const recipePartName = (part: string) => part.replace(/^\{id\}-/, '')
 
 /**
- * How a template works, in lines the catalog shows -- worked out from its steps (figure-model `describeV3Recipe`), each
+ * How a template works, in lines the catalog shows -- worked out from its steps (figure-model `describeFigureRecipe`), each
  * a translation key and its words.
  */
-export function recipeWorkings(recipe: V3Recipe): Array<{ key: string; words: Record<string, string | number> }> {
-  const d = describeV3Recipe(recipe)
+export function recipeWorkings(recipe: FigureRecipe): Array<{ key: string; words: Record<string, string | number> }> {
+  const d = describeFigureRecipe(recipe)
   const lines: Array<{ key: string; words: Record<string, string | number> }> = []
   for (const m of d.moves)
     lines.push(
@@ -55,7 +55,7 @@ export function recipeWord(words: Record<string, string> | undefined, language:
 }
 
 /** Whether a recipe can be put in now: one for a part needs a part chosen. */
-export function recipeReady(recipe: Pick<V3Recipe, 'target'>, selected: string): boolean {
+export function recipeReady(recipe: Pick<FigureRecipe, 'target'>, selected: string): boolean {
   return recipe.target === 'figure' || !!selected
 }
 
@@ -63,7 +63,7 @@ export function recipeReady(recipe: Pick<V3Recipe, 'target'>, selected: string):
  * A field's value as the recipe takes it. A ratio is shown and typed as a percentage (35 for 0.35), since that is how a
  * person says a share; the rest are taken as they are. A number field left empty or not a number keeps the default.
  */
-export function recipeValueOf(param: V3RecipeParam, typed: string | boolean): V3RecipeValue {
+export function recipeValueOf(param: FigureRecipeParam, typed: string | boolean): FigureRecipeValue {
   if (param.kind === 'flag') return typed === true || typed === 'true'
   if (param.kind === 'ratio' || param.kind === 'mm') {
     const n = typeof typed === 'string' && typed.trim() !== '' ? Number(typed) : NaN
@@ -75,7 +75,7 @@ export function recipeValueOf(param: V3RecipeParam, typed: string | boolean): V3
 }
 
 /** What a field shows for a value: a ratio as a percentage. */
-export function recipeFieldOf(param: V3RecipeParam, value: V3RecipeValue): string {
+export function recipeFieldOf(param: FigureRecipeParam, value: FigureRecipeValue): string {
   if (param.kind === 'ratio' && typeof value === 'number') return String(Math.round(value * 1e6) / 1e4)
   return String(value)
 }