@things-factory/figure-ui 10.1.270 → 10.1.272

package/dist-client/types.d.ts

@@ -125,6 +125,8 @@ export interface FigureGateFinding {
     /** 갈라진 부품 이름들, 또는 정본 안의 경로. */
     at?: string;
     blocking: boolean;
+    /** 발행 계약이 깨짐 — 새 피규어 타입으로 저장하면 발행되고, 놓인 피규어는 옛 정의를 유지한다. */
+    asNewType?: boolean;
 }
 /** 발행해도 되나. `blocked` 면 서버가 거절한다. */
 export interface FigureInspection {

package/dist-client/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../client/types.ts"],"names":[],"mappings":"AAAA;;GAEG","sourcesContent":["/**\n * 화면이 다루는 모양. 피규어 자산의 타입은 `@hatiolab/figure-model` 이 정한다 — 여기서 다시 적지 않는다.\n */\n\n/** 서버가 돌려주는 Figure 한 벌. `source` 는 상세 또는 저작면을 열 때만 받는다. */\nexport interface Figure {\n  id: string\n  /** 컴포넌트 타입 이름. **만든 뒤에 고칠 수 없다.** */\n  type: string\n  /** Namespace of the full name {namespace}/{type} (ADR-0114). */\n  namespace?: string | null\n  name: string\n  description?: string\n  /** 분류 하나 — 팔레트에서 묶어 보이는 기준. */\n  category?: string\n  /** 태그 여럿 — 분류로는 못 하는 찾기. */\n  tags?: string[]\n  state?: 'draft' | 'released'\n  /** 재활용 점수 0~100. 서버가 정본에서 계산한다 — 화면이 보내는 값이 아니다. */\n  score?: number\n  triangles?: number\n  groups?: number\n  thumbnail?: string\n  thumbnailUpdatedAt?: string\n  updatedAt?: string\n  updater?: { id: string; name: string }\n  /** 피규어 자산 JSON 문자열. 목록 질의에는 실려 오지 않는다. */\n  source?: string\n  properties?: string\n  version?: number\n  /** Retired: still released and served, no longer offered for new use. */\n  deprecated?: boolean\n  /** The type to use instead of a retired figure, in the same domain. */\n  supersededBy?: string | null\n  /** Public: other domains read its releases and draw it by full name (LV figure-server design G2). */\n  public?: boolean\n  /** The domain it belongs to; carried by another domain's public figure, so a screen says whose it is. */\n  domain?: { id: string; name?: string; subdomain?: string } | null\n}\n\n/**\n * 발행된 버전 하나.\n *\n * 저작 중 저장은 여기 오지 않는다 — 버전은 발행에서만 생긴다.\n */\nexport interface FigureVersion {\n  version: number\n  /** 발행하며 남긴 말. */\n  comment?: string\n  state?: 'draft' | 'released'\n  updatedAt?: string\n  updater?: { id: string; name: string }\n  score?: number\n  triangles?: number\n  groups?: number\n}\n\nexport interface FigureListResult {\n  items: Figure[]\n  total: number\n}\n\n/**\n * 새 Figure.\n *\n * `score`·`triangles`·`groups` 가 없다 — **서버가 정본에서 계산한다.** 화면이 보내면\n * 거짓이 들어오고 목록이 실물과 다른 것을 보여 준다.\n */\nexport interface NewFigure {\n  type: string\n  name: string\n  description?: string\n  category?: string\n  tags?: string[]\n  source: string\n  properties?: string\n  state?: 'draft' | 'released'\n  thumbnail?: string\n}\n\n/**\n * 수정.\n *\n * `type` 이 없다 — 저장되는 식별자라 고칠 수 없다. 배치된 도면이 그 이름으로 타입을\n * 찾으므로, 바꾸면 그 도면이 빈 화면이 된다.\n */\nexport interface FigurePatch {\n  /** 발행 전 초안에서만 받는다 — 발행된 뒤에는 문이 거절한다(ADR-0063 결정 4). */\n  type?: string\n  name?: string\n  description?: string\n  category?: string\n  /** 빈 배열은 「전부 지운다」, 안 주는 것은 「건드리지 않는다」. */\n  tags?: string[]\n  source?: string\n  properties?: string\n  state?: 'draft' | 'released'\n  thumbnail?: string\n}\n\n/** 검증 결과 한 줄. 코드는 figure-model 의 것을 그대로 쓴다. */\nexport interface FigureFinding {\n  code: string\n  message: string\n  at?: string\n}\n\n/**\n * 발행 판정 한 줄.\n *\n * `FigureFinding` 과 달리 **`blocking` 이 있다.** 저장 쪽 발견은 정의상 막지 않는 것들이고,\n * 발행 판정은 막는 것과 알리는 것을 함께 내므로 어느 쪽인지를 값이 스스로 말한다 — 코드를 보고\n * 화면이 다시 분류하면 규칙이 두 벌이 된다.\n */\nexport interface FigureGateFinding {\n  code: string\n  message: string\n  /** 왜 그것이 문제인가 — 사람이 무엇을 보게 되나. */\n  why?: string\n  /** 무엇을 바꾸면 되나 — 부품 이름과 값으로. */\n  how?: string\n  /** 갈라진 부품 이름들, 또는 정본 안의 경로. */\n  at?: string\n  blocking: boolean\n}\n\n/** 발행해도 되나. `blocked` 면 서버가 거절한다. */\nexport interface FigureInspection {\n  blocked: boolean\n  findings: FigureGateFinding[]\n}\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../client/types.ts"],"names":[],"mappings":"AAAA;;GAEG","sourcesContent":["/**\n * 화면이 다루는 모양. 피규어 자산의 타입은 `@hatiolab/figure-model` 이 정한다 — 여기서 다시 적지 않는다.\n */\n\n/** 서버가 돌려주는 Figure 한 벌. `source` 는 상세 또는 저작면을 열 때만 받는다. */\nexport interface Figure {\n  id: string\n  /** 컴포넌트 타입 이름. **만든 뒤에 고칠 수 없다.** */\n  type: string\n  /** Namespace of the full name {namespace}/{type} (ADR-0114). */\n  namespace?: string | null\n  name: string\n  description?: string\n  /** 분류 하나 — 팔레트에서 묶어 보이는 기준. */\n  category?: string\n  /** 태그 여럿 — 분류로는 못 하는 찾기. */\n  tags?: string[]\n  state?: 'draft' | 'released'\n  /** 재활용 점수 0~100. 서버가 정본에서 계산한다 — 화면이 보내는 값이 아니다. */\n  score?: number\n  triangles?: number\n  groups?: number\n  thumbnail?: string\n  thumbnailUpdatedAt?: string\n  updatedAt?: string\n  updater?: { id: string; name: string }\n  /** 피규어 자산 JSON 문자열. 목록 질의에는 실려 오지 않는다. */\n  source?: string\n  properties?: string\n  version?: number\n  /** Retired: still released and served, no longer offered for new use. */\n  deprecated?: boolean\n  /** The type to use instead of a retired figure, in the same domain. */\n  supersededBy?: string | null\n  /** Public: other domains read its releases and draw it by full name (LV figure-server design G2). */\n  public?: boolean\n  /** The domain it belongs to; carried by another domain's public figure, so a screen says whose it is. */\n  domain?: { id: string; name?: string; subdomain?: string } | null\n}\n\n/**\n * 발행된 버전 하나.\n *\n * 저작 중 저장은 여기 오지 않는다 — 버전은 발행에서만 생긴다.\n */\nexport interface FigureVersion {\n  version: number\n  /** 발행하며 남긴 말. */\n  comment?: string\n  state?: 'draft' | 'released'\n  updatedAt?: string\n  updater?: { id: string; name: string }\n  score?: number\n  triangles?: number\n  groups?: number\n}\n\nexport interface FigureListResult {\n  items: Figure[]\n  total: number\n}\n\n/**\n * 새 Figure.\n *\n * `score`·`triangles`·`groups` 가 없다 — **서버가 정본에서 계산한다.** 화면이 보내면\n * 거짓이 들어오고 목록이 실물과 다른 것을 보여 준다.\n */\nexport interface NewFigure {\n  type: string\n  name: string\n  description?: string\n  category?: string\n  tags?: string[]\n  source: string\n  properties?: string\n  state?: 'draft' | 'released'\n  thumbnail?: string\n}\n\n/**\n * 수정.\n *\n * `type` 이 없다 — 저장되는 식별자라 고칠 수 없다. 배치된 도면이 그 이름으로 타입을\n * 찾으므로, 바꾸면 그 도면이 빈 화면이 된다.\n */\nexport interface FigurePatch {\n  /** 발행 전 초안에서만 받는다 — 발행된 뒤에는 문이 거절한다(ADR-0063 결정 4). */\n  type?: string\n  name?: string\n  description?: string\n  category?: string\n  /** 빈 배열은 「전부 지운다」, 안 주는 것은 「건드리지 않는다」. */\n  tags?: string[]\n  source?: string\n  properties?: string\n  state?: 'draft' | 'released'\n  thumbnail?: string\n}\n\n/** 검증 결과 한 줄. 코드는 figure-model 의 것을 그대로 쓴다. */\nexport interface FigureFinding {\n  code: string\n  message: string\n  at?: string\n}\n\n/**\n * 발행 판정 한 줄.\n *\n * `FigureFinding` 과 달리 **`blocking` 이 있다.** 저장 쪽 발견은 정의상 막지 않는 것들이고,\n * 발행 판정은 막는 것과 알리는 것을 함께 내므로 어느 쪽인지를 값이 스스로 말한다 — 코드를 보고\n * 화면이 다시 분류하면 규칙이 두 벌이 된다.\n */\nexport interface FigureGateFinding {\n  code: string\n  message: string\n  /** 왜 그것이 문제인가 — 사람이 무엇을 보게 되나. */\n  why?: string\n  /** 무엇을 바꾸면 되나 — 부품 이름과 값으로. */\n  how?: string\n  /** 갈라진 부품 이름들, 또는 정본 안의 경로. */\n  at?: string\n  blocking: boolean\n  /** 발행 계약이 깨짐 — 새 피규어 타입으로 저장하면 발행되고, 놓인 피규어는 옛 정의를 유지한다. */\n  asNewType?: boolean\n}\n\n/** 발행해도 되나. `blocked` 면 서버가 거절한다. */\nexport interface FigureInspection {\n  blocked: boolean\n  findings: FigureGateFinding[]\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.270",
+  "version": "10.1.272",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -42,11 +42,11 @@
     "@operato/slot-layout-editor": "^10.29.58",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.270",
-    "@things-factory/figure-service": "^10.1.270",
+    "@things-factory/ai-assistant": "^10.1.272",
+    "@things-factory/figure-service": "^10.1.272",
     "@things-factory/figure-viewer": "^10.1.266",
-    "@things-factory/setting-base": "^10.1.270",
+    "@things-factory/setting-base": "^10.1.271",
     "three": "^0.185.1"
   },
-  "gitHead": "9fb23e57702302f1a6c6572d9f0f37ef6f12b446"
+  "gitHead": "f87fefe0687eedf52a25cda1c54d59efabaf3dc2"
 }

package/test/browser/editing.check.mjs

@@ -353,7 +353,7 @@ describe('the material: colours by purpose, one step each, a glow drawn while dr
   test('a diameter typed on the arrangement tab is written once when it is left, as the radius it halves to', async () => {
     await click(await read(() => probe.tab('figure.label.tab-short-response')))
     const start = await revision()
-    await type('drum X · figure.label.size-diameter figure.label.size-measure', '600')
+    await type('drum X·Z · figure.label.size-diameter figure.label.size-measure', '600')
     assert.equal(await revision(), start, 'nothing written yet')
     await page().keyboard.press('Enter')
     await sleep(400)
@@ -514,7 +514,8 @@ describe('a clip scrubbed and keyed (2026-09-24)', () => {
   const typeInClips = async (label, text) => {
     const field = await page().evaluateHandle(label => {
       const deep = (root = document) => [...root.querySelectorAll('input')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
-      return deep().find(i => i.type === 'number' && i.getAttribute('aria-label') === label && i.getRootNode().host?.localName === 'figure-clips') ?? null
+      /* The clip's own field, not the pose bar's above the clips: the bar keys the clip last scrubbed (tutorial 2026-11-12). */
+      return deep().find(i => i.type === 'number' && i.getAttribute('aria-label') === label && i.getRootNode().host?.localName === 'figure-clips' && !i.closest('div[pose-bar]')) ?? null
     }, label)
     assert.ok(await field.evaluate(i => !!i), `${label} in the clips`)
     await field.evaluate(i => i.scrollIntoView({ block: 'center' }))
@@ -576,12 +577,12 @@ describe('a track moved round its loop, a clip copied (robot dog 2026-11-03)', (
     await button.click()
   }
 
-  test('a clip in a group is copied in one step; one in none is not offered', async () => {
-    /* The left door's clip is in no group, the right one's is in one. */
+  test('a clip in a group is copied in one step; one in none is offered too, and makes its group (review 2026-11-11)', async () => {
+    /* The left door's clip is in no group, the right one's is in one: both may be copied now. */
     assert.equal(await read(() => {
       const deep = (root = document) => [...root.querySelectorAll('button[copy-clip]')].concat(...[...root.querySelectorAll('*')].filter(e => e.shadowRoot).map(e => deep(e.shadowRoot)))
       return deep().map(b => b.disabled).join()
-    }), 'true,false')
+    }), 'false,false')
     const start = await revision()
     await pressIn('button[copy-clip]', 1)
     await until(async () => (await revision()) === start + 1, 'one step')

package/test/browser/section.check.mjs

@@ -748,6 +748,27 @@ describe('the fastening drawing in the fastening window', () => {
     assert.deepEqual(joint.body0, { part: 'frame', face: 'front' })
     assert.deepEqual([joint.body1, joint.origin?.facing], [{ part: 'leaf' }, 'meet'], 'set on the front by its real shape (ADR-0140 3.2)')
   })
+
+  /* Tutorial 2026-11-11: the field a size opened did not take the keys; 600 typed and Enter fastened the part where it was. */
+  test('a size pressed in the drawing opens its field with the keys in it: typed and Enter moves the part there, the window stays', async () => {
+    await change()
+    await until(() => !!findDeep('text[dim]', { within: 'figure-fasten-drawing' }), 'a size in the drawing')
+    const start = await state()
+    await press('text[dim]', { within: 'figure-fasten-drawing' })
+    await until(() => {
+      const field = findDeep('div[where] input', { within: 'figure-fasten-drawing' })
+      return !!field && field.getRootNode().activeElement === field
+    }, 'the size\'s field, with the keys in it')
+    await page().keyboard.type('37')
+    await page().keyboard.press('Enter')
+    await sleep(300)
+    assert.ok(await read(() => !!probe.fastenTargets()), 'the window stays open')
+    assert.equal((await state()).revision, start.revision, 'nothing written before 적용')
+    await press('[apply]', { within: 'figure-fasten-dialog' })
+    await until(r => probe.state().revision === r + 1, 'one step', start.revision)
+    const align = (await read(() => probe.fastening('leaf'))).origin?.align ?? {}
+    assert.ok(Object.values(align).some(a => a?.mm === 37), `the typed size: ${JSON.stringify(align)}`)
+  })
 })
 
 describe('the face choice: asked where the edit was made, and the same edit goes again with it', () => {

package/test/clips.test.ts

@@ -93,7 +93,7 @@ test('a track copied onto another control a while later; a clip copy takes a fre
 })
 
 /* Review 2026-11-09: a track starts from the pose, a pose is kept in one step, a clip on a played control joins a group. */
-import { newClipEdits, newTrackKeys, rememberedPoseEdits } from '../client/modeller/clips.ts'
+import { copyClipEdits, newClipEdits, newTrackKeys, rememberedPoseEdits } from '../client/modeller/clips.ts'
 
 const applied = (asset: FigureAsset, edits: unknown[]) => edits.reduce<FigureAsset>((a, e) => editFigurePart(a, e as never), asset)
 
@@ -103,7 +103,7 @@ test('새 트랙은 지금 자세를 처음부터 끝까지 유지 — 범위
   assert.deepEqual(newTrackKeys({ min: 5, max: 9 }, undefined, 2), [{ seconds: 0, value: 5 }, { seconds: 2, value: 5 }], '값을 모르면 범위의 시작')
   /* The panel's wiring: the default button holds the pose, the range one is the preset. */
   const panel = read('../client/modeller/figure-clips.ts')
-  assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration\)\)/)
+  assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration\), 'smooth'\)/)
   assert.match(panel, /newTrackKeys\(input!, this\.values\[stateId!\], duration, 'range'\)/)
   /* Several edits go up as one step, and the editor applies them as one. */
   assert.match(read('../client/modeller/editor.ts'), /<figure-clips[\s\S]*?@part-edits=\$\{\(e: CustomEvent\) => this\.run\(\(\) => this\.session!\.applyRecipe\(e\.detail\.edits\)\)\}[\s\S]*?<\/figure-clips>/)
@@ -128,13 +128,36 @@ test('재생 중인 조작값에 새 클립 — 그룹 없는 클립과 새 동
   assert.deepEqual(applied(grouped, half.edits).motionGroups!.map(g => g.clips), [['닫기', '열기', '반열기']])
 })
 
+test('이 자세 기억하기 — 되풀이 트랙의 처음과 끝은 한 순간: 둘 중 어디서 기억해도 두 키가 함께 바뀐다', () => {
+  const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 60 }, { seconds: 4, value: 0 }] })
+  const keysOf = (a: FigureAsset) => clipsOf(a)[0]!.tracks[0]!.keys
+  assert.equal(clipsOf(asset)[0]!.tracks[0]!.loop, 'wrap')
+
+  /* Kept at the end: the end reads as the start, yet the pose is kept -- at both ends, so the loop does not jump. */
+  const atEnd = rememberedPoseEdits(asset, 'walk', 4, { shift: 20, spin: 0 }, { shift: 0, spin: 0 })
+  assert.equal(atEnd.edits.length, 1)
+  assert.deepEqual(keysOf(applied(asset, atEnd.edits)), [{ seconds: 0, value: 20 }, { seconds: 2, value: 60 }, { seconds: 4, value: 20 }])
+
+  /* Kept at 0: the end key follows. */
+  const atStart = rememberedPoseEdits(asset, 'walk', 0, { shift: 10, spin: 0 }, { shift: 0, spin: 0 })
+  assert.deepEqual(keysOf(applied(asset, atStart.edits)), [{ seconds: 0, value: 10 }, { seconds: 2, value: 60 }, { seconds: 4, value: 10 }])
+
+  /* Both ends already there: nothing to keep. */
+  assert.deepEqual(rememberedPoseEdits(asset, 'walk', 4, { shift: 0, spin: 0 }, { shift: 0, spin: 0 }).edits, [])
+
+  /* A loop left open on purpose -- a ramp that starts over -- keeps its other end. */
+  const ramp = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 4, value: 60 }] })
+  assert.deepEqual(keysOf(applied(ramp, rememberedPoseEdits(ramp, 'walk', 4, { shift: 50, spin: 0 }, { shift: 0, spin: 0 }).edits)), [{ seconds: 0, value: 0 }, { seconds: 4, value: 50 }])
+  assert.deepEqual(keysOf(applied(ramp, rememberedPoseEdits(ramp, 'walk', 0, { shift: 10, spin: 0 }, { shift: 0, spin: 0 }).edits)), [{ seconds: 0, value: 10 }, { seconds: 4, value: 60 }])
+})
+
 test('이 자세 기억하기 — 바뀐 조작값만, 한 묶음으로; 다른 동작이 쓰는 조작값은 이름만', () => {
   const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'cycle', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 4, value: 60 }] })
   const base = { shift: 30, spin: 0 }
   /* At 2 s the clip has shift at 30: unchanged, no key. spin moved to 45 since: a new track from 0 to 45 at 2 s. */
   const kept = rememberedPoseEdits(asset, 'cycle', 2, { shift: 30, spin: 45 }, base)
   assert.deepEqual(kept.skipped, [])
-  assert.deepEqual(kept.edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 45 }] }])
+  assert.deepEqual(kept.edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 45 }], interpolation: 'smooth' }])
   const after = applied(asset, kept.edits)
   assert.equal(poseAt(after, 'cycle', 2).find(c => c.input === 'spin')!.value, 45)
 
@@ -148,7 +171,7 @@ test('이 자세 기억하기 — 바뀐 조작값만, 한 묶음으로; 다른
   assert.deepEqual(rememberedPoseEdits(after, 'cycle', 2, { shift: 30, spin: 45 }, { shift: 30, spin: 45 }).edits, [])
 
   /* At 0 a new track holds the pose throughout. */
-  assert.deepEqual(rememberedPoseEdits(asset, 'cycle', 0, { shift: 0, spin: 10 }, base).edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 10 }, { seconds: 4, value: 10 }] }])
+  assert.deepEqual(rememberedPoseEdits(asset, 'cycle', 0, { shift: 0, spin: 10 }, base).edits, [{ kind: 'set-driver', state: 'spin', clip: 'cycle', keys: [{ seconds: 0, value: 10 }, { seconds: 4, value: 10 }], interpolation: 'smooth' }])
 
   /* spin played by another clip in no group: not taken, named. */
   const other = editFigurePart(asset, { kind: 'set-driver', state: 'spin', clip: 'turn', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 90 }] })
@@ -174,3 +197,25 @@ test('키 사이 움직임 — 트랙마다 일정한 속도 · 부드럽게 ·
   assert.match(panel, /\['linear', 'smooth', 'step'\] as const/)
   assert.match(panel, /\?disabled=\$\{this\.locked \|\| same \|\| !!fits\}/)
 })
+
+test('a clip in no group is copied in one step: a group is made with a name of its own, and both are in it (review 2026-11-11)', () => {
+  const asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 60 }, { seconds: 4, value: 0 }] })
+  const after = applied(asset, copyClipEdits(asset, 'walk'))
+  assert.deepEqual(clipsOf(after).map(c => c.name), ['walk', 'walk-copy'])
+  assert.deepEqual(after.motionGroups!.map(g => [g.label, g.clips, g.defaultClip]), [['motion', ['walk', 'walk-copy'], 'walk']])
+  /* A second group takes the next free name. */
+  const taken = { ...asset, motionGroups: [{ id: 'motion', label: 'motion', clips: ['lift'], defaultClip: 'lift', transitionSeconds: 0.2 }] }
+  assert.equal((copyClipEdits(taken, 'walk', 'motion')[0] as { group: { label: string } }).group.label, 'motion 2')
+  /* Already in a group: only the copy. */
+  assert.equal(copyClipEdits(after, 'walk').length, 1)
+})
+
+test('a clip lists its tracks in the order of the controls, however its drivers were last written (tutorial 2026-11-12)', () => {
+  const keys = [{ seconds: 0, value: 0 }, { seconds: 2, value: 10 }]
+  let asset = editFigurePart(machine(), { kind: 'set-driver', state: 'shift', clip: 'walk', duration: 2, keys })
+  asset = editFigurePart(asset, { kind: 'set-driver', state: 'spin', clip: 'walk', duration: 2, keys })
+  /* The first track keyed again: its driver is written anew. */
+  const shift = clipsOf(asset)[0]!.tracks.find(t => t.state === 'shift')!
+  asset = editFigurePart(asset, trackEdit(clipsOf(asset)[0]!, shift, { keys: withKey(shift.keys, { seconds: 1, value: 5 }) }) as never)
+  assert.deepEqual(clipsOf(asset)[0]!.tracks.map(t => t.state), ['shift', 'spin'])
+})

package/test/data-motion.test.ts

@@ -33,6 +33,7 @@ import {
   tableWithLook,
   tableWithTargets,
   sampleOf,
+  sampledStatesOf,
   schemaWithField,
   schemaWithoutField,
   typedValueOf,
@@ -363,3 +364,10 @@ test('the value data gives a row is read down its accessor; left out or null, th
   assert.equal(dataValueAt(data, 'missing.deep'), undefined)
   assert.equal(dataValueAt(null, 'status'), undefined)
 })
+
+test('the preview says the state inputs a sample sets, not a slider at their default (tutorial 2026-11-11)', () => {
+  /* The dog's head follows headAngle: a sample giving it sets the head; none, or one the figure refuses, sets nothing. */
+  assert.deepEqual(sampledStatesOf(DOG, { headAngle: 10 }), { head: 10 })
+  assert.deepEqual(sampledStatesOf(DOG, null), {})
+  assert.deepEqual(sampledStatesOf(DOG, { headAngle: 999 }), {}, 'refused whole, as a board refuses it')
+})

package/test/fasten-form.test.ts

@@ -203,3 +203,60 @@ test("pressed on the canvas: the face or the point pressed, read in that part's
   const corner = aimFastenAt(r, 'tag', freshFasten(), { id: 'soft', point: [145, 100, 1645], normal: [Math.SQRT1_2, 0, Math.SQRT1_2] })
   assert.deepEqual([corner.note, corner.form?.target], ['aim-not-here', 'soft'], 'a rounded corner: aimed at the part, said')
 })
+
+test('a part still where the palette put it goes to the centre of the face; one the author moved keeps its place across it (review 2026-11-11)', () => {
+  /* A thigh 85 mm left of the middle of a pelvis 880 mm up; a shin and an arm added from the palette at (0, 50, 0). */
+  let a = fasten(box(createFigureAsset('Humanoid'), 'pelvis', [300, 180, 200], [0, 970, 0]), 'pelvis', 'plane', { gap: 880 })
+  a = applyFigureAuthoring(box(a, 'thigh', [130, 420, 140], [-85, 670, 0]), { kind: 'attach', part: 'thigh', to: { part: 'pelvis', face: 'bottom' }, facing: 'meet', align: { x: { mm: -85 } } } as never)
+  a = box(box(a, 'shin', [110, 420, 120], [0, 50, 0]), 'arm', [90, 300, 90], [0, 50, 0])
+  const r = revisionOf(a)
+  const shin = aimFasten(r, 'shin', fastenFormOf(r, 'shin'), { part: 'thigh' })
+  const onBottom = aimFasten(r, 'shin', shin, { targetFace: 'bottom' })
+  assert.deepEqual([onBottom.align, onBottom.alignMm], [{}, {}], 'on the centre of the thigh, not 85 mm off it')
+  const arm = aimFasten(r, 'arm', aimFasten(r, 'arm', fastenFormOf(r, 'arm'), { part: 'pelvis' }), { targetFace: 'left' })
+  assert.deepEqual([arm.align, arm.alignMm], [{}, {}], 'on the side, not 920 mm below it')
+  /* Moved by the author first, it keeps where it stands across the face. */
+  const moved = revisionOf(box(a, 'tag', [40, 40, 40], [-60, 500, 30]))
+  const kept = aimFasten(moved, 'tag', aimFasten(moved, 'tag', fastenFormOf(moved, 'tag'), { part: 'thigh' }), { targetFace: 'bottom' })
+  assert.deepEqual(kept.alignMm, { x: 25, z: 30 })
+})
+
+test('a part still where the palette put it is fastened on the face; one the author moved keeps its place (tutorial 2026-11-11)', () => {
+  /* A body on the floor; a mast added from the palette stands inside it, at the palette's place (0, 50, 0). */
+  let a = fasten(box(createFigureAsset('Fork AGV'), 'body', [1000, 300, 700], [0, 150, 0]), 'body', 'plane')
+  a = box(a, 'mast', [80, 1500, 700], [0, 50, 0])
+  const r = revisionOf(a)
+  const aimed = keptGapOf(r, 'mast', aimFasten(r, 'mast', fastenFormOf(r, 'mast'), { part: 'body' }))
+  assert.equal(aimed.gap, 0, 'on the face, not 550 mm inside the body')
+  /* Moved by the author, it is fastened where it stands (user 2026-10-20 「현재 상태로 붙이기」). */
+  const moved = revisionOf(box(fasten(box(createFigureAsset('Fork AGV'), 'body', [1000, 300, 700], [0, 150, 0]), 'body', 'plane'), 'mast', [80, 1500, 700], [0, 1100, 0]))
+  const kept = keptGapOf(moved, 'mast', aimFasten(moved, 'mast', fastenFormOf(moved, 'mast'), { part: 'body' }))
+  assert.equal(kept.gap, 50, 'the 50 mm its bottom stands above the body')
+})
+
+test('aimed at a part, the form starts on a face nothing is fastened to yet (review 2026-11-11)', () => {
+  let a = fasten(box(createFigureAsset('Humanoid'), 'pelvis', [300, 180, 200], [0, 970, 0]), 'pelvis', 'plane', { gap: 880 })
+  a = applyFigureAuthoring(box(a, 'torso', [340, 500, 200], [0, 50, 0]), { kind: 'attach', part: 'torso', to: { part: 'pelvis', face: 'top' } } as never)
+  a = box(a, 'thigh', [130, 420, 140], [0, 50, 0])
+  const r = revisionOf(a)
+  const thigh = aimFasten(r, 'thigh', fastenFormOf(r, 'thigh'), { part: 'pelvis' })
+  assert.equal(thigh.targetFace, 'bottom', 'across from the top, where the body stands')
+  assert.equal(aimFasten(r, 'torso', fastenFormOf(r, 'torso'), { part: 'pelvis' }).targetFace, 'top', 'a part keeps the face it is fastened to')
+  const head = aimFasten(r, 'thigh', fastenFormOf(r, 'thigh'), { part: 'torso' })
+  assert.equal(head.targetFace, 'top', 'a free top is taken as asked')
+  /* A shin aimed at a thigh hung under the pelvis: the thigh's top touches the pelvis, so the shin goes under it. */
+  let b = applyFigureAuthoring(a, { kind: 'attach', part: 'thigh', to: { part: 'pelvis', face: 'bottom' } } as never)
+  b = box(b, 'shin', [110, 420, 120], [0, 50, 0])
+  const rb = revisionOf(b)
+  assert.equal(aimFasten(rb, 'shin', fastenFormOf(rb, 'shin'), { part: 'thigh' }).targetFace, 'bottom')
+  /* A forearm aimed at an upper arm hung by its side from the torso: on down, under the arm (tutorial run 2026-11-12). */
+  let c = applyFigureAuthoring(box(a, 'upperarm', [90, 300, 90], [0, 50, 0]), { kind: 'attach', part: 'upperarm', to: { part: 'torso', face: 'left' } } as never)
+  c = box(c, 'forearm', [80, 280, 80], [0, 50, 0])
+  const rc = revisionOf(c)
+  assert.equal(aimFasten(rc, 'forearm', fastenFormOf(rc, 'forearm'), { part: 'upperarm' }).targetFace, 'bottom')
+  /* A flat part hung by its side is not a limb: what goes on it keeps the face asked. */
+  let d = applyFigureAuthoring(box(a, 'shelf', [300, 40, 200], [0, 50, 0]), { kind: 'attach', part: 'shelf', to: { part: 'torso', face: 'left' } } as never)
+  d = box(d, 'cup', [60, 80, 60], [0, 50, 0])
+  const rd = revisionOf(d)
+  assert.equal(aimFasten(rd, 'cup', fastenFormOf(rd, 'cup'), { part: 'shelf' }).targetFace, 'top')
+})

package/test/fasten-geometry.test.ts

@@ -11,7 +11,7 @@ import assert from 'node:assert/strict'
 import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
 
-import { alignmentAt, faceViewOf, facesAsDrawnOf, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
+import { alignmentAt, drawingSpanOf, faceViewOf, facesAsDrawnOf, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
 import { revisionOf } from './revision-of.ts'
 
 const scene = (lidRotation?: { x: number; y: number; z: number }): FigureAsset => {
@@ -97,3 +97,27 @@ test('붙일 면 그림은 그려진 자세대로 — 눕힌 원기둥의 위·
   assert.ok(!['top', 'bottom'].includes(drawn.top) && !['top', 'bottom'].includes(drawn.bottom), `화면의 위·아래는 원기둥의 면이 아니다: ${drawn.top}, ${drawn.bottom}`)
   assert.deepEqual([drawn.front, drawn.back], ['front', 'back'])
 })
+
+test('a part bigger than the face is caught level with its edges too -- a mast flush with the bottom of a low body (tutorial 2026-11-11)', () => {
+  /* A 1500 mm mast on the 300 mm high side of a body: its bottom level with the body's is its centre 600 mm up. */
+  assert.deepEqual(alignmentAt(595, 300, 1500, true, 10), { how: 'min', caught: 'inside' })
+  assert.deepEqual(alignmentAt(-603, 300, 1500, true, 10), { how: 'max', caught: 'inside' })
+  assert.equal(offsetOf('min', undefined, 300, 1500), 600)
+  /* What the drawing names, the kernel does: the mast's bottom on the body's bottom, the floor. */
+  let a = addFigureBox(createFigureAsset('Fork AGV'), { id: 'body', size: { x: 1000, y: 300, z: 700 }, position: { x: 0, y: 150, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
+  a = addFigureBox(a, { id: 'mast', size: { x: 80, y: 1500, z: 700 }, position: { x: 0, y: 750, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'mast', to: { part: 'body', face: 'left' }, facing: 'meet', align: { y: 'min', z: 'centre' } } as FigureAuthoringAction)
+  const t = at(a, 'mast')
+  assert.ok(Math.abs(t[1]! - 750) < 1e-6, `mast centre ${t[1]} mm high`)
+  assert.ok(Math.abs(t[0]! - -540) < 1e-6, `mast against the left face, ${t[0]}`)
+})
+
+test('the face drawing shows a part bigger than the face whole when lined up with an edge', () => {
+  /* The mast's top at its centre 600 mm up, half of 1500 above that: 1350 mm from the drawing's middle, inside half its span. */
+  const span = drawingSpanOf(300, 1500)
+  assert.ok(span / 2 >= Math.abs(offsetOf('min', undefined, 300, 1500)) + 1500 / 2, `span ${span}`)
+  /* A part smaller than the face keeps the room it had: the face and half the part past each edge. */
+  assert.equal(drawingSpanOf(600, 300), 900)
+  assert.equal(drawingSpanOf(undefined, 200), 600)
+})

package/test/first-part-on-plane.test.ts

@@ -0,0 +1,52 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { compileFigureAsset, parseFigureAsset } from '@hatiolab/figure-model'
+import { createFigureProductSession } from '../client/modeller/product-session.js'
+import { firstPartFastensToPlane, paletteRecipe } from '../client/modeller/palette.js'
+
+/*
+ * A figure that stands on the floor starts with its base: the first box the author adds and then sizes stays on the floor
+ * (tutorial 2026-11-11: a 1000 x 300 x 700 box added from the start dialog sank 100 mm through the floor).
+ */
+const session = () => createFigureProductSession({ load: async () => ({ id: 'x', source: '' }), save: async q => ({ id: 'x', source: q.source }) })
+
+/** The bottom of the part, in mm above the mounting plane, once its height is `height` */
+function bottomAt(source: string, part: string, height: number) {
+  const asset = parseFigureAsset(source)
+  const key = Object.keys(asset.designInputs).find(k => k.startsWith(part) && /size\.y$|dimension\.y$|height$/.test(k))
+  assert.ok(key, `the part's height input among ${Object.keys(asset.designInputs).join(', ')}`)
+  const g = compileFigureAsset({ ...asset, designInputs: { ...asset.designInputs, [key]: height } })
+    .evaluate()
+    .geometry.find(g => g.id === part)!
+  return g.pose.t[1] - height / 2
+}
+
+test('only the first part of a figure on a plane is fastened to it', () => {
+  assert.equal(firstPartFastensToPlane([], undefined), true)
+  assert.equal(firstPartFastensToPlane([], 'floor'), true)
+  assert.equal(firstPartFastensToPlane([], 'ceiling'), true)
+  assert.equal(firstPartFastensToPlane([], 'wall'), true)
+  assert.equal(firstPartFastensToPlane([], 'center'), false)
+  assert.equal(firstPartFastensToPlane([{ id: 'body' }], 'floor'), false)
+})
+
+test('the first box, added fastened to the floor, stays on it when its height changes; one undo takes it away', () => {
+  const s = session()
+  s.startNew({ name: 'fork AGV' })
+  const empty = s.source()
+  const part = paletteRecipe('box', 'body')
+  s.applyRecipe([
+    { kind: 'add-part', part },
+    { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } }
+  ])
+  for (const height of [100, 300, 1200]) assert.ok(Math.abs(bottomAt(s.source(), 'body', height)) < 1e-6, `bottom on the floor at ${height} mm`)
+  s.undo()
+  assert.equal(s.source(), empty)
+})
+
+test('a box added without fastening sinks as it grows -- what the first part no longer does', () => {
+  const s = session()
+  s.startNew({ name: 'fork AGV' })
+  s.add(paletteRecipe('box', 'body'))
+  assert.ok(bottomAt(s.source(), 'body', 300) < -50)
+})

package/test/first-save.test.ts

@@ -5,7 +5,7 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { placeholderType } from '@hatiolab/figure-model'
-import { firstSaveRefusalOf, releasableType, typeOf } from '../client/modeller/first-save.ts'
+import { firstSaveRefusalOf, releasableType, typeOf, typingTypeOf } from '../client/modeller/first-save.ts'
 import { createFigureProductSession, type FigureProductStore } from '../client/modeller/product-session.ts'
 
 test('치는 대로 타입의 모양이 된다 — 소문자 · 숫자 · 하이픈 하나', () => {
@@ -14,6 +14,16 @@ test('치는 대로 타입의 모양이 된다 — 소문자 · 숫자 · 하이
   assert.equal(typeOf('-Roller  Conveyor-'), 'roller-conveyor')
 })
 
+test('하이픈을 칠 수 있다 — 한 글자씩 쳐도 끝의 하이픈이 남고, 저장할 때 다듬는다', () => {
+  let typed = ''
+  for (const key of 'fork-agv-tutorial') typed = typingTypeOf(typed + key)
+  assert.equal(typed, 'fork-agv-tutorial')
+  let trailing = ''
+  for (const key of 'Fork AGV ') trailing = typingTypeOf(trailing + key)
+  assert.equal(trailing, 'fork-agv-')
+  assert.equal(typeOf(trailing), 'fork-agv')
+})
+
 test('발행할 수 없는 이름은 미리 말한다 — 임시 이름 · 형식 · 길이', () => {
   assert.equal(releasableType('agv-lifter'), true)
   assert.equal(releasableType(placeholderType()), false, '서버가 붙이는 임시 이름')

package/test/pivot.test.ts

@@ -0,0 +1,57 @@
+/*
+ * Named points a turn's axis may pass (`pivot.ts`): worked out from the part as it rests, they keep the named point
+ * still as the joint turns -- whatever the face, the alignment, the slider.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset } from '@hatiolab/figure-model'
+
+import { motionJoint } from '../client/modeller/links.ts'
+import { pivotPointOf, pivotPointsOf } from '../client/modeller/pivot.ts'
+import { revisionOf } from './revision-of.ts'
+
+const box = (a: FigureAsset, id: string, [x, y, z]: number[], at = [0, 0, 0]) => addFigureBox(a, { id, size: { x, y, z }, position: { x: at[0]!, y: at[1]!, z: at[2]! } })
+const turn = (through = {}) => ({ kind: 'turn', axis: 'x', id: 'sh', min: -90, max: 90, follow: '', multiplier: 1, offset: 0, travel: '', travelPlus: 0, through }) as never
+
+/* An arm of 300 mm hung by its side from a torso, level with its top -- the lesson's upper arm -- or under it. */
+function arm(face: 'left' | 'bottom', align?: object) {
+  const a = box(createFigureAsset('H'), 'torso', [340, 500, 200], [0, 1000, 0])
+  return applyFigureAuthoring(box(a, 'arm', [90, 300, 90], [0, 50, 0]), { kind: 'attach', part: 'arm', to: { part: 'torso', face }, ...(align ? { align } : {}) } as never)
+}
+const endsAt = (a: FigureAsset, through: object, value: number) => {
+  const joint = a.joints!.find(j => j.body1.part === 'arm')!
+  const b = applyFigureAuthoring(a, { kind: 'set-joint', joint: motionJoint(joint, turn(through), 'arm') } as never)
+  const g = (revisionOf(b, { sh: value }).geometry as Array<{ id: string; pose: { r: number[][]; t: number[] } }>).find(p => p.id === 'arm')!.pose
+  /* The arm's top and bottom end centres in the figure's frame. */
+  return [150, -150].map(y => [0, 1, 2].map(i => g.r[i]![1]! * y + g.t[i]!))
+}
+const near = (a: number[], b: number[]) => a.every((v, i) => Math.abs(v - b[i]!) < 0.5)
+
+test('a named pivot stays where it is as the joint turns: top, middle, bottom of a side-hung or an under-hung arm (tutorial 2026-11-12)', () => {
+  for (const [face, align] of [['left', { y: 'max' }], ['left', undefined], ['bottom', undefined]] as const) {
+    const a = arm(face, align)
+    const points = pivotPointsOf(revisionOf(a), 'arm', 'x')!
+    assert.ok(points, `${face}: points`)
+    const [top0, bottom0] = endsAt(a, points.top, 0)
+    assert.ok(near(endsAt(a, points.top, 70)[0]!, top0!), `${face} ${JSON.stringify(align)}: the top end stays`)
+    assert.ok(near(endsAt(a, points.bottom, 70)[1]!, bottom0!), `${face} ${JSON.stringify(align)}: the bottom end stays`)
+    assert.ok(!near(endsAt(a, points.middle, 70)[0]!, top0!), `${face}: about the middle the top end moves`)
+  }
+})
+
+test('the lesson upper arm, level with the torso top, already turns about its top end: no number is needed', () => {
+  const points = pivotPointsOf(revisionOf(arm('left', { y: 'max' })), 'arm', 'x')!
+  assert.deepEqual(points, { top: {}, middle: { y: -150 }, bottom: { y: -300 } })
+  assert.equal(pivotPointOf(points, {}, 'x'), 'top')
+  assert.equal(pivotPointOf(points, { y: 120 }, 'x'), undefined, 'Y 120 put the axis above the shoulder')
+})
+
+test('a part fastened to nothing, or a slider left turned, has no wrong points', () => {
+  assert.equal(pivotPointsOf(revisionOf(box(createFigureAsset('H'), 'solo', [10, 10, 10])), 'solo'), null)
+  const a = arm('bottom')
+  const joint = a.joints!.find(j => j.body1.part === 'arm')!
+  const b = applyFigureAuthoring(a, { kind: 'set-joint', joint: motionJoint(joint, turn(), 'arm') } as never)
+  assert.deepEqual(pivotPointsOf(revisionOf(b, { sh: 60 }), 'arm'), pivotPointsOf(revisionOf(b), 'arm'))
+})

package/test/save-landed.test.ts

@@ -258,7 +258,6 @@ test('a conflict kept as a copy: a new figure under a new creation id, the edits
   const session = createFigureProductSession(store)
   await session.open('a')
   const opened = session.read().creationId
-  assert.throws(() => session.detachAsCopy(), { code: 'SESSION_NO_CONFLICT' }, 'only after a conflict')
   session.command({ kind: 'rename', name: 'Mine' } as never)
   session.editCatalog({ category: 'equipment', tags: ['new-tag'], type: 'gate-2' }, { type: 'gate' })
   const theirs = serializeFigureAsset(createFigureAsset('Theirs'))
@@ -289,3 +288,23 @@ test('the latest not readable: the conflict stands, and it cannot be written ove
   assert.deepEqual(session.read().conflict, { latest: undefined })
   assert.throws(() => session.overwriteConflict(), { code: 'SESSION_NO_CONFLICT' })
 })
+
+test('edits a released figure cannot take kept as a new figure type: no conflict needed, the released one untouched', async () => {
+  const s = server()
+  const saved: { id?: string; creationId?: string; type?: string }[] = []
+  const store = {
+    ...s.store,
+    save: async (q: { id?: string; source: string; creationId?: string; type?: string }) => (saved.push(q), q.id ? s.store.save(q) : { id: q.creationId!, source: q.source })
+  }
+  const session = createFigureProductSession(store)
+  assert.throws(() => session.detachAsCopy(), { code: 'SESSION_NOT_SAVED' }, 'nothing opened, nothing to keep apart')
+  await session.open('a')
+  const before = s.row()
+  session.command({ kind: 'rename', name: 'Mine' } as never)
+  const copy = session.detachAsCopy()
+  assert.equal(copy.id, undefined)
+  assert.equal(copy.name, 'Mine')
+  await session.save({ type: 'gate-v2' })
+  assert.deepEqual(saved.at(-1), { ...saved.at(-1), id: undefined, creationId: copy.creationId, type: 'gate-v2' })
+  assert.equal(s.row(), before, 'the figure it came from is as the server had it')
+})

package/test/size-response.test.ts

@@ -1,7 +1,8 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { applyFigureAuthoring, compileFigureAsset, figureRowOf, figureFollowOf } from '@hatiolab/figure-model'
-import { sizeRelationSteps, sizeRelationOf, sizeInputOf } from '../client/modeller/size-response.ts'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset, figureRowOf, figureFollowOf } from '@hatiolab/figure-model'
+import { sizeAxisWord, sizeRelationSteps, sizeRelationOf, sizeInputOf } from '../client/modeller/size-response.ts'
+import { followableAxes } from '../client/modeller/links.ts'
 import type { FigureRevision } from '../client/modeller/revision.ts'
 import { multipartResponseFixture } from './multipart-response-fixture.js'
 const revision = (asset: ReturnType<typeof multipartResponseFixture>) => ({ asset, inputs: asset.designInputs } as FigureRevision)
@@ -47,3 +48,10 @@ test('repeat settings can change count, direction and mode without losing the at
  assert.deepEqual(a.joints!.find(j=>j.body1.part==='legLeft')!.body0,initial.body0)
  assert.deepEqual(figureFollowOf(a,'brace','x'),{of:'part',part:'tabletop',axis:'x',plus:-200})
 })
+
+test('a round body names the diameter that sets the axis it has no row for: X·Z across, Y up (tutorial 2026-11-12)', () => {
+  const ball = addFigurePrimitive(createFigureAsset('Ball'), { id: 'ball', kind: 'sphere', dimensions: { radius: 100, radiusY: 120 }, position: { x: 0, y: 0, z: 0 } } as never)
+  assert.deepEqual(followableAxes(ball, 'ball').map(a => sizeAxisWord(ball, 'ball', a, '지름')), ['X·Z · 지름', 'Y · 지름'])
+  const block = addFigureBox(createFigureAsset('Block'), { id: 'block', size: { x: 10, y: 20, z: 30 }, position: { x: 0, y: 0, z: 0 } })
+  assert.deepEqual(followableAxes(block, 'block').map(a => sizeAxisWord(block, 'block', a, '지름')), ['X', 'Y', 'Z'])
+})

package/test/stage-model.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict'
 import { addFigureBox, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 
 import { drawableFigureParts } from '../client/modeller/renderer.ts'
-import { boardFor, needsRefit } from '../client/modeller/stage-model.ts'
+import { boardFor, drawnSpanOf, needsRefit, outgrowsFit } from '../client/modeller/stage-model.ts'
 
 const partsOf = (height: number) =>
   drawableFigureParts(
@@ -33,3 +33,25 @@ test('a size typed far from the view brings the camera to it; a nudge does not (
   assert.equal(needsRefit(boardFor(parts(3000, 800, 600)), boardFor(parts(100, 100, 100))), true, 'shrunk far: fitted again')
   assert.equal(needsRefit(undefined, boardFor(parts(3000, 800, 600))), false, 'never fitted: the first standing fits it')
 })
+
+test('the view follows a figure that grows past the fit, or stands higher off the floor (review 2026-11-11)', () => {
+  const at = (height: number, y: number) =>
+    drawableFigureParts(compileFigureAsset(addFigureBox(createFigureAsset('P'), { id: 'p', size: { x: 300, y: height, z: 200 }, position: { x: 0, y, z: 0 } })).evaluate().geometry)
+  /* A pelvis 180 mm tall put 880 mm up: as tall as it stands from the floor, not as its own height. */
+  const onFloor = boardFor(at(180, 90))
+  const raised = boardFor(at(180, 970))
+  assert.ok(raised.depth >= 1060, `reached from the floor: ${raised.depth}`)
+  assert.equal(needsRefit(onFloor, raised), true, 'raised far: the view follows it up')
+  /* A head added on a 1.56 m body: 1.8 m runs past the fit's margin. */
+  assert.equal(needsRefit(boardFor(at(680, 1220)), boardFor(at(920, 1340))), true)
+  /* A nudge inside the fit's margin leaves the camera where the author put it. */
+  assert.equal(needsRefit(boardFor(at(680, 1220)), boardFor(at(700, 1230))), false)
+})
+
+test('the view follows a part hung below what it was fitted round (review 2026-11-11)', () => {
+  const body = drawnSpanOf(partsOf(500))
+  const longer = drawnSpanOf(partsOf(800))
+  assert.equal(outgrowsFit(body, longer), true, 'reaching 300 mm past the top')
+  assert.equal(outgrowsFit(body, drawnSpanOf(partsOf(520))), false, 'a little taller stays in view')
+  assert.equal(outgrowsFit(undefined, longer), false)
+})

package/translations/en.json

@@ -484,6 +484,8 @@
   "figure.text.pick-a-shape-above-to-start": "pick a shape above to add the first part.",
   "figure.text.placement-explained": "sets the anchor plane in 3D scene (floor: AGV/conveyor, ceiling: OHT/hoist, center: sensor/drone).",
   "figure.text.pose-as-default-explained": "Writes the pose you have set as the parameters’ defaults, so the figure stands like this when nobody gives it a value.",
+  "figure.text.control-played": "Playing",
+  "figure.text.control-played-explained": "The {clip} clip is moving this control. Stop the clip to give it a value.",
   "figure.text.clear-tried-explained": "clears the control values tried here. the saved default pose is unchanged, and the clips move the figure again.",
   "figure.text.preview-blocked-by-errors": "cannot show the preview because of format errors. see the check tab for the reason.",
   "figure.text.put-on-floor": "Moves the part once so its bottom is on the floor (Y=0). It does not stay there when the size changes; for that, use “Follow size, attached to the floor”.",
@@ -715,6 +717,10 @@
   "figure.label.motion-own-control": "its own control",
   "figure.label.motion-multiplier": "multiplier",
   "figure.label.motion-offset": "offset",
+  "figure.label.pivot-at": "turn about",
+  "figure.label.pivot-top": "top end",
+  "figure.label.pivot-middle": "middle",
+  "figure.label.pivot-bottom": "bottom end",
   "figure.label.motion-through": "axis passes through",
   "figure.label.motion-follows": "moves with {joint} × {multiplier} + {offset}",
   "figure.label.face-opening-left": "opening left",
@@ -1020,6 +1026,7 @@
   "figure.text.slot-id-taken": "{slot} is already the name of a place in this figure.",
   "figure.label.placement": "fastening",
   "figure.label.motion-groups": "motion groups",
+  "figure.label.motion-group-named": "motion",
   "figure.label.motion-group": "motion group",
   "figure.label.no-motion-group": "no group",
   "figure.label.motion-group-name": "name",
@@ -1281,6 +1288,7 @@
   "figure.text.conflict-other-changed": "Settings outside the parts (name, inputs, capabilities...) differ too.",
   "figure.text.conflict-latest-unread": "The latest could not be read, so it was not compared. It cannot be overwritten.",
   "figure.button.save-as-copy": "save as a copy",
+  "figure.button.save-as-new-type": "save as a new figure type",
   "figure.button.open-latest": "open the latest in a new tab",
   "figure.button.overwrite-latest": "overwrite with my edits",
   "figure.text.overwrite-latest-warning": "What changed in the latest is replaced by your edits and not kept. Overwrite?",
@@ -1321,6 +1329,7 @@
   "figure.button.shift-track": "shift",
   "figure.button.copy-track-apply": "copy",
   "figure.text.copy-clip-needs-group": "A copy plays the same controls, so only a clip in a motion group can be copied.",
+  "figure.text.copy-clip-makes-group": "Copies every track into a clip with a new name. The copy moves the same controls, so both go into a new motion group named after this clip (one plays at a time).",
   "figure.label.primitive-pipe": "pipe",
   "figure.label.primitive-duct": "duct",
   "figure.label.primitive-tapered-box": "tapered box",