@things-factory/figure-ui 10.1.44 → 10.1.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.44",
+  "version": "10.1.46",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -26,7 +26,7 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.42",
+    "@hatiolab/figure-model": "^0.1.48",
     "@hatiolab/things-scene": "^10.1.26",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.0.0",
@@ -37,8 +37,8 @@
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
-    "@things-factory/figure-service": "^10.1.44",
+    "@things-factory/figure-service": "^10.1.46",
     "three": "^0.185.1"
   },
-  "gitHead": "7c95c4e75e155e51c714409e865d96f317232c23"
+  "gitHead": "d3467cde550453f3348fed0ed6c79a12a6ba0db4"
 }

package/test/ai-proposal-contract.test.ts

@@ -137,17 +137,6 @@ test('피드백은 후보 세션의 선택과 측정값만 전송한다', () =>
  * as it stands right now — unsaved edits included — so the candidate is a revision of what is open
  * rather than something invented from the prompt alone. And it saves nothing by itself.
  */
-test('모델러는 AI 문을 스스로 두지 않고, 물으면 지금 정본을 답한다', () => {
-  const path = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-
-  assert.doesNotMatch(source, /openOverlay\('figure-ai-dock'/, '앱 머리줄에 이미 있는 문을 여기 또 두지 않는다')
-  assert.match(source, /addEventListener\('figure-ai-context-request'/)
-  assert.match(source, /detail: \{ figureId: this\.figure\?\.id, source: this\.folded \}/)
-  assert.doesNotMatch(source, /<figure-ask/, 'the inline ask form is gone; the dock is the entrance')
-  assert.doesNotMatch(source, /proposeFigure\(/, 'the page must not call the propose mutation itself')
-})
-
 test('그림이 붙은 AI 요청은 JSON이 아니라 GraphQL multipart Upload 링크를 탄다', () => {
   const path = fileURLToPath(new URL('../client/graphql/index.ts', import.meta.url))
   const source = readFileSync(path, 'utf8')
@@ -156,83 +145,6 @@ test('그림이 붙은 AI 요청은 JSON이 아니라 GraphQL multipart Upload
   assert.match(propose, /context: \{ hasUpload: !!request\.image \}/)
 })
 
-test('모델러의 수락·거절 피드백은 다음 인라인 후보 요청에도 같은 Figure 세션에서만 전달한다', () => {
-  const path = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-
-  assert.match(source, /new CustomEvent\('figure-ai-feedback'/)
-  assert.doesNotMatch(source, /<figure-ask/)
-  assert.match(source, /this\.proposalFeedback = \[\.\.\.this\.proposalFeedback, feedback\]\.slice\(-5\)/)
-  assert.match(source, /changed\.has\('figure'\).*this\.proposalFeedback = \[\]/s)
-})
-
-test('발행 게이트 수정안은 원본을 바꾸지 않고 후보로만 연다', () => {
-  const historyPath = fileURLToPath(new URL('../client/modeller/figure-history-panel.ts', import.meta.url))
-  const modellerPath = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const sessionPath = fileURLToPath(new URL('../client/modeller/proposal-session.ts', import.meta.url))
-  const history = readFileSync(historyPath, 'utf8')
-  const modeller = readFileSync(modellerPath, 'utf8')
-  const session = readFileSync(sessionPath, 'utf8')
-
-  assert.match(history, /i18next\.t\('figure\.button\.preview-fix'/)
-  assert.equal(JSON.parse(readFileSync(new URL('../translations/ko.json', import.meta.url), 'utf8'))['figure.button.preview-fix'].startsWith('수정안 미리보기'), true)
-  assert.match(history, /i18next\.t\('figure\.button\.apply-fix'/)
-  assert.match(history, /new CustomEvent\('apply-sizing-fix'/)
-  assert.match(history, /new CustomEvent\('preview-sizing-fix'/)
-  assert.match(modeller, /@preview-sizing-fix=\$\{\(e: CustomEvent\) => this\.previewSizingFix\(e\.detail\)\}/)
-  assert.match(modeller, /private previewSizingFix\(fix: FigureGateFix\)/)
-  assert.match(modeller, /private applySizingFix\(fix: FigureGateFix\)/)
-  assert.match(modeller, /if \(!fix\.safe \|\| !this\.folded\) return/)
-  assert.match(modeller, /this\.proposalSession = proposalSessions\.openSizingFix\(this\.folded, fix\)/)
-  assert.match(modeller, /private take\(\)[\s\S]*applyProposal\(this\.folded, this\.proposalSession\.source, this\.proposalSession\.picked\)[\s\S]*this\.dirty = true/)
-  assert.match(session, /export function openSizingFix[\s\S]*anchor: \{ \.\.\.\(part\.anchor \?\? \{\}\), \[fix\.axis\]: fix\.to \}/)
-})
-
-test('새 Figure 경로는 MDI에 남아 있는 직전 Figure를 재사용하지 않고 빈 초안을 만든다', () => {
-  const path = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-  const pageUpdated = source.slice(source.indexOf('async pageUpdated'), source.indexOf('  private async load'))
-  const startNew = source.slice(source.indexOf('  private startNew()'), source.indexOf('  private rename'))
-
-  // resourceId가 없다는 것은 명시적으로 「새 Figure」를 뜻한다.
-  assert.match(pageUpdated, /if \(!this\.figure\)[\s\S]*this\.startNew\(\)/)
-  assert.match(pageUpdated, /if \(this\.figure\.id\)[\s\S]*this\.startNew\(\)/)
-  // 새 초안은 저장 식별자·선택·기존 부품·진단을 모두 초기화한다.
-  assert.match(startNew, /this\.figure = \{ id: '', type: draftType, name: '' \}/)
-  assert.match(startNew, /const \{ draft, parts \} = startingModel\(draftType\)/)
-  assert.match(startNew, /this\.selected = -1/)
-  assert.match(startNew, /this\.dirty = true/)
-  assert.match(startNew, /this\.violations = \[\]/)
-})
-
-test('빈 새 Figure는 캔버스의 직전 씬을 폐기하고 안내 상태로 전환한다', () => {
-  const path = fileURLToPath(new URL('../client/modeller/figure-canvas.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-  const standUp = source.slice(source.indexOf('  private standUp()'), source.indexOf('  /**\n   * 지금 판 위에'))
-
-  assert.match(standUp, /if \(!draft\) \{[\s\S]*this\.teardown\(\)/)
-  assert.match(standUp, /if \(this\.parts\.length === 0\) \{[\s\S]*this\.teardown\(\)[\s\S]*canvas-appears-once-a-part-exists/)
-})
-
-test('캔버스는 figureId를 판별에 포함하고 없어진 부품을 씬에서 완전 제거한다', () => {
-  const canvasPath = fileURLToPath(new URL('../client/modeller/figure-canvas.ts', import.meta.url))
-  const canvasSource = readFileSync(canvasPath, 'utf8')
-  const modellerPath = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
-  const modellerSource = readFileSync(modellerPath, 'utf8')
-
-  // figureId 변경 시 새 씬을 세우도록 signature에 figureId가 포함된다
-  assert.match(canvasSource, /@property\(\{ type: String \}\) figureId\?: string/)
-  assert.match(canvasSource, /signature = `\$\{this\.figureId \?\? ''\}:\$\{draft\.width\}x\$\{draft\.height\}x\$\{draft\.depth\}/)
-  
-  // 없어진 부품은 root.removeComponent와 component.dispose로 제거된다
-  assert.match(canvasSource, /root\.removeComponent\?\.\(component\)/)
-  assert.match(canvasSource, /component\.dispose\?\.\(\)/)
-
-  // 모델러 페이지는 figure-canvas에 figureId를 전달한다
-  assert.match(modellerSource, /\.figureId=\$\{this\.figure\?\.id \|\| this\.figure\?\.type\}/)
-})
-
-
 /*
  * ── The whole round trip, not just one hop ───────────────────────────────────
  *

package/test/figure-source.test.ts

@@ -502,112 +502,10 @@ describe('배치는 씬의 좌표 모드가 아니다', () => {
     )
   })
 
-  it('편집 캔버스가 씬에 배치를 안 싣는다', () => {
-    const source = read('../client/modeller/figure-canvas.ts')
-
-    assert.doesNotMatch(
-      source,
-      /placement:/,
-      '편집 캔버스가 배치를 씬에 실으면 저작자가 적은 높이의 뜻이 드롭다운마다 바뀐다'
-    )
-  })
-
-  it('setPlacement 가 부품을 안 건드린다', () => {
-    const source = read('../client/modeller/figure-inspector.ts')
-    const body = source.slice(source.indexOf('private setPlacement'), source.indexOf('private setPlacement') + 500)
-
-    assert.match(body, /detail: \{ draft \}/, '배치는 필드 하나만 쓴다')
-    assert.doesNotMatch(body, /zPos/, '배치를 바꾸면서 부품 높이를 다시 계산하면 안 된다')
-  })
-})
-
-describe('미리보기가 높이를 씬에게 맡긴다', () => {
-  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
-  const preview = read('../client/modeller/figure-preview.ts')
-
-  /*
-    배치 기준을 높이로 옮기는 규칙은 씬이 갖는다 — `FigureRealObject.effectiveZPos` 가 청사진의
-    `placement` 와 레이어의 `heights` 로 정한다(ADR-0045). 미리보기는 「도면에 놓았을 때」를
-    말하는 자리이므로 도면과 같은 길로 세워야 한다.
-
-    이 화면이 규칙을 한 벌 더 들고 있었다. 그러면 씬의 규칙이 바뀌어도 이 화면만 옛 답을 내고,
-    저작자는 도면에 놓고 나서야 다르다는 것을 안다.
-  */
-  it('인스턴스에 zPos 를 적지 않는다 — 적으면 적은 값이 이긴다', () => {
-    const at = preview.indexOf('const components = PREVIEW_WAYS.map')
-    const built = preview.slice(at, preview.indexOf('const draft = {', at))
-
-    assert.doesNotMatch(built, /zPos/, '여기서 높이를 정하면 씬이 무엇을 할지가 이 화면에서만 안 보인다')
-  })
-
-  it('배치를 높이로 옮기는 계산을 들고 있지 않다', () => {
-    assert.doesNotMatch(preview, /bottomOf|zPosOf/, '규칙이 두 벌이면 갈린다')
-  })
-
-  it('천장 높이를 씬에 실어 준다 — 값이 사는 자리가 거기다', () => {
-    assert.match(preview, /heights: \{ floor: 0, ceiling: view\.ceilingHeight \}/)
-  })
-
-  it('미리보기가 좌표 모드를 보기 설정에서 받는다 — 도형에서가 아니라', () => {
-    assert.match(preview, /placement: view\.placement/, '보기 설정의 좌표 모드를 씬에 실어야 한다')
-    assert.doesNotMatch(preview, /placement: (source|toScenePlacement)/, '도형의 배치를 씬 모드로 쓰면 안 된다')
-  })
-
-  it('미리보기가 보기 설정의 조명·환경을 따른다', () => {
-    assert.match(preview, /\.\.\.sceneLook\(view\)/, '하드코딩하면 편집 캔버스와 두 화면이 갈린다')
-    assert.doesNotMatch(preview, /environment: 'studio'/, '환경이 하드코딩으로 남아 있다')
-  })
 })
 
 describe('보기 설정이 편집 캔버스로 새지 않는다', () => {
   const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
 
-  it('sceneLook 이 좌표 모드와 천장 높이를 뺀다', () => {
-    const view = read('../client/modeller/figure-view.ts')
-    assert.match(view, /const \{ placement, ceilingHeight, \.\.\.look \} = view/)
-  })
-
-  it('편집 캔버스가 rest spread 로 보기 설정을 넘기지 않는다', () => {
-    /*
-      한동안 `const { grid, ..., ...light } = view` 였다. 그러면 설정을 하나 더할 때마다
-      그것이 두 화면에 **말없이** 실린다 — 좌표 모드가 바로 그 길로 들어갈 뻔했다.
-    */
-    const canvas = read('../client/modeller/figure-canvas.ts')
-    const fn = canvas.slice(canvas.indexOf('private sceneView'), canvas.indexOf('private sceneView') + 200)
-
-    assert.match(fn, /sceneLook\(/)
-    assert.doesNotMatch(fn, /\.\.\.light/, '나머지를 통째로 넘기면 새 설정이 조용히 실린다')
-  })
 })
 
-/*
- * ── 막는 것과 알리는 것을 화면이 갈라야 한다 ──────────────────────────────────
- *
- * 판정 패널은 위반을 전부 같은 `info` 로 그렸다. 기준 상자 위반 둘이 발행을 막게 된 뒤에도
- * 그대로라, 저작자는 다섯 줄의 알림을 보고 **발행을 눌러 보고 나서야** 막힌 것을 안다.
- *
- * 등급은 형식이 안다(`blocksRelease`). 화면이 제 목록을 들면 코드가 하나 늘 때 조용히
- * 「알림」 쪽으로 떨어진다 — 안전하지 않은 쪽으로 기우는 기본값이다.
- */
-describe('판정 패널이 발행을 막는 것을 갈라 보인다', () => {
-  const read = (rel: string) => readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), 'utf8')
-  const report = read('../client/modeller/figure-report.ts')
-
-  it('등급을 형식에서 받는다 — 제 목록을 들지 않는다', () => {
-    assert.match(report, /blocksRelease/, '형식이 어느 위반이 막는지 안다')
-    assert.doesNotMatch(
-      report,
-      /'part-outside-base'|'parts-off-placement-face'/,
-      '화면이 코드 이름을 적으면 형식과 두 벌이 된다'
-    )
-  })
-
-  it('막는 것은 다른 아이콘으로 그린다', () => {
-    assert.match(report, /v\.blocking \? 'block' : 'info'/, '같은 아이콘이면 갈린 뜻이 화면에 안 나온다')
-  })
-
-  it('얼마나 넘쳤는지 보여 준다', () => {
-    /* 「상자를 벗어난다」만으로는 2mm 인지 250mm 인지 모르고, 그 둘은 고치는 품이 다르다. */
-    assert.match(report, /v\.actual/, '넘친 양을 버리면 저작자가 무엇부터 고칠지 못 고른다')
-  })
-})

package/test/i18n-prefix-guard.test.ts

@@ -122,23 +122,6 @@ test('★ 한국어를 defaultValue 로 들고 있지 않다 — 번역 파일
   assert.deepEqual(hard, [], `한국어 defaultValue:\n  ${hard.join('\n  ')}`)
 })
 
-/*
-  이어 붙이는 자리는 값을 코드에서 읽어야 알 수 있어 여기서 전수 검사하지 않는다. 대신 **통이
-  갈린 짝**을 못 박는다 — 사다리 이름은 `label`, 그 설명은 `text` 다. 한 번 어긋났고, 그때
-  사다리 설명 세 줄이 화면에 키로 떴다. 넓은 앞머리(`figure.text.`)가 미사용 검사를 덮어
-  통과시켰다.
-*/
-test('★ 통이 갈린 짝 — 사다리 이름과 설명', () => {
-  for (const rung of ['none', 'hold', 'flow']) {
-    assert.ok(`figure.label.rung-${rung}` in KO, `figure.label.rung-${rung} 이 없다`)
-    assert.ok(`figure.text.rung-${rung}-note` in KO, `figure.text.rung-${rung}-note 이 없다`)
-  }
-
-  const source = readFileSync(join(CLIENT, 'modeller/figure-capabilities.ts'), 'utf-8')
-  assert.ok(source.includes('figure.label.rung-${which}'), '사다리 이름을 label 통에서 찾지 않는다')
-  assert.ok(source.includes('figure.text.rung-${which}-note'), '사다리 설명을 text 통에서 찾지 않는다')
-})
-
 /*
   애니메이션 탭도 열거 값을 키에 이어 붙인다. 사다리와 **같은 모양의 함정**이라 같은 못을 박는다.
 
@@ -168,13 +151,6 @@ test('★ 열거 값마다 짝이 다 있다 — 경로 · 보간', () => {
   assert.deepEqual(missing, [], `이어 붙여 부르는 키가 번역에 없다:\n  ${missing.join('\n  ')}`)
 })
 
-test('★ 애니메이션 탭이 그 통에서 찾는다 — 이름은 label, 설명은 text', () => {
-  const source = readFileSync(join(CLIENT, 'modeller/figure-animations.ts'), 'utf-8')
-
-  assert.ok(source.includes("'figure.label.path-' + path"), '경로 이름을 label 통에서 찾지 않는다')
-  assert.ok(source.includes("'figure.text.path-' + channel.path + '-unit'"), '단위 설명을 text 통에서 찾지 않는다')
-})
-
 /*
   대체 언어(`fallbackLng`)는 **en** 이다 — 클라이언트(`@operato/i18n` 의 config)와 서버
   (`i18n-base` 의 미들웨어) 양쪽 다.

package/test/modeller-route.test.ts

@@ -1,42 +1,31 @@
 /*
- * **목록이 도형을 그 형식을 고칠 수 있는 모델러로 연다** (2026-09-24, 사용자 지시).
- *
- * 목록은 모든 도형을 V2 모델러로 보냈다. V3 로 바꾼 복사본에서는 어느 카드를 눌러도 V2 화면이 「Figure를 열지
- * 못했습니다 — Cannot read properties of undefined (reading 'x')」로 멈췄고, V3 모델러는 주소를 쳐야만 닿았다.
+ * One modeller since ADR-0087 step 5 (2026-09-24, user decision: V2 is not kept). The catalogue, a new figure and
+ * an old address all open it.
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 
-import { isV3Source, modellerPathOf } from '../client/modeller/modeller-route.ts'
+import { modellerPathOf } from '../client/modeller/modeller-route.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
 
-test('V3 도형은 V3 모델러로, V2 는 V2 로, 새 도형은 V3 로', () => {
-  assert.equal(modellerPathOf({ id: 'a', format: 'v3' }), 'figure-v3-modeller/a')
-  assert.equal(modellerPathOf({ id: 'a', format: 'v2' }), 'figure-modeller/a')
-  assert.equal(modellerPathOf(), 'figure-v3-modeller')
-  assert.equal(modellerPathOf({ id: 'a', format: null }), 'figure-modeller/a', '서버가 형식을 모르면 V2 화면이 읽지 못한 까닭을 말한다')
+test('every figure and a new one open the one modeller', () => {
+  assert.equal(modellerPathOf({ id: 'a' }), 'figure-modeller/a')
+  assert.equal(modellerPathOf(), 'figure-modeller')
 })
 
-test('V3 원본은 자기 판으로 알아본다', () => {
-  assert.equal(isV3Source(JSON.stringify({ version: 'figure-v3-asset-1' })), true)
-  assert.equal(isV3Source(JSON.stringify({ version: 2 })), false)
-  assert.equal(isV3Source('not json'), false)
-  assert.equal(isV3Source(undefined), false)
+test('the route and the shell table send both addresses to the V3 page, and the V2 page is gone', () => {
+  const route = read('../client/route.ts')
+  assert.doesNotMatch(route, /figure-modeller-page/)
+  const config = read('../things-factory.config.js')
+  assert.match(config, /tagname: 'figure-v3-modeller-page', page: 'figure-modeller'/)
+  assert.match(config, /tagname: 'figure-v3-modeller-page', page: 'figure-v3-modeller'/)
+  assert.doesNotMatch(config, /'figure-modeller-page'/)
 })
 
-test('목록은 카드와 새 도형 단추 모두 형식으로 고른다', () => {
+test('the catalogue opens figures through the one path', () => {
   const list = read('../client/pages/figure-list-page.ts')
   assert.match(list, /navigate\(modellerPathOf\(figure\)\)/)
-  assert.match(list, /this\.openModeller\(record\)/, '카드는 id 가 아니라 형식을 가진 행을 넘긴다')
-  assert.doesNotMatch(list, /navigate\(id \? `figure-modeller/)
-  assert.match(read('../client/graphql/index.ts'), /groups\s+format\s+thumbnailUpdatedAt/, '목록 질의가 형식을 받는다')
-})
-
-test('V2 주소로 온 V3 도형은 V3 모델러로 넘긴다 — 뒤로 가기가 다시 V2 로 돌지 않게 바꿔 넣는다', () => {
-  const v2 = read('../client/pages/figure-modeller-page.ts')
-  const load = v2.slice(v2.indexOf('private async load('), v2.indexOf('fromFigureSource(JSON.parse'))
-  assert.match(load, /if \(isV3Source\(figure\.source\)\) \{\s*navigate\(modellerPathOf\(\{ id, format: 'v3' \}\), true\)\s*return/)
 })

package/test/part-edits.test.ts

@@ -89,13 +89,6 @@ describe('씬에서 온 부품을 밀리미터로 맞춘다', () => {
     expect(roundPart(once)).toEqual(once)
   })
 
-  it('캔버스가 씬의 변경을 받을 때 그것을 지난다 — 안 부르면 위 넷이 전부 초록인 채로 소수가 남는다', () => {
-    const canvas = readFileSync(fileURLToPath(new URL('../client/modeller/figure-canvas.ts', import.meta.url)), 'utf8')
-
-    assert.ok(/roundPart/.test(canvas), 'import')
-    assert.ok(/this\.tell\('part-changed', \{ name, part: roundPart\(/.test(canvas), '올려 보내기 전에 맞춘다')
-  })
-
   it('크기·자리 밖의 값은 건드리지 않는다', () => {
     const kept = roundPart(part({ name: 'arm', token: 'palette.dark', segments: 12, zPos: 3.4 }))
     expect(kept.name).toBe('arm')

package/test/scene-budget.test.ts

@@ -66,13 +66,6 @@ describe('한 화면이 감당하는 양', () => {
 describe('놓는 개수 기준 문구가 화면에 없다', () => {
   const HERE = fileURLToPath(new URL('.', import.meta.url))
 
-  it('보고서가 「N개 기준」 칸을 그리지 않는다', () => {
-    const report = readFileSync(join(HERE, '../client/modeller/figure-report.ts'), 'utf8')
-
-    assert.ok(!/at-100|at-10k/.test(report), '개수 기준 칸')
-    assert.ok(!/costOf\(blueprint, \d/.test(report), '개수를 넣어 셈하지 않는다')
-  })
-
   it('번역에 그 낱말이 남아 있지 않다', () => {
     const ko = JSON.parse(readFileSync(join(HERE, '../translations/ko.json'), 'utf8')) as Record<string, string>
     const left = Object.entries(ko).filter(([key]) => /at-100|at-10k/.test(key))

package/test/v3-gizmo.test.ts

@@ -95,3 +95,13 @@ test('기즈모의 말은 다섯 말 모두에 있다', () => {
     for (const mode of ['translate', 'rotate', 'scale']) assert.ok(table[`figure.label.gizmo-${mode}`], `${lang}: ${mode}`)
   }
 })
+
+test('떼어 낸 부품은 다시 옮길 수 있다 — 움직임이 있는 부품은 아니다', () => {
+  let asset = probe()
+  asset = addV3Box(asset, { id: 'lid', size: { x: 100, y: 20, z: 100 }, position: { x: 0, y: 300, z: 0 } })
+  const fastened = applyV3Authoring(asset, { kind: 'attach', part: 'lid', face: 'bottom', to: { part: 'body', face: 'top' } })
+  const free = applyV3Authoring(fastened, { kind: 'detach', part: 'lid' })
+  assert.equal(gizmoReachOf(free as never, 'lid').translate, true)
+  const moving = applyV3Authoring(free, { kind: 'add-motion', part: 'lid', motion: { kind: 'slide', axis: 'x' }, state: { id: 'lid-slide', unit: 'mm', min: 0, max: 100, start: 0 } })
+  assert.equal(gizmoReachOf(moving as never, 'lid').translate, false)
+})

package/test/v3-links.test.ts

@@ -0,0 +1,163 @@
+/*
+ * **V3 부품이 무엇에 묶여 있나 — 크기 따르기 · 붙이기 · 움직임** (V3 동등표 ④ ⑤ ⑥, 2026-09-24).
+ *
+ * 세 칸이 보여 주는 것은 figure-model 명령이 남긴 그래프를 거꾸로 읽은 것이다. 명령을 실제로 적용한 뒤 읽어서,
+ * 화면이 명령과 같은 말을 하는지 잰다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addV3Box, addV3Primitive, applyV3Authoring, createV3Asset } from '@hatiolab/figure-model'
+import type { V3Asset } from '@hatiolab/figure-model'
+
+import { acceptsOf, canFasten, canFollow, fastenedTo, followOf, hasInstanceSize, holdsThings, motionOf, placeFacesOf, placeIdFor, placesOn, positionsWorkedOut } from '../client/modeller/v3-links.ts'
+
+const pair = (): V3Asset => {
+  let asset = createV3Asset('Pair')
+  asset = addV3Box(asset, { id: 'plate', size: { x: 600, y: 100, z: 400 }, position: { x: 0, y: 50, z: 0 } })
+  asset = addV3Box(asset, { id: 'block', size: { x: 200, y: 60, z: 120 }, position: { x: 0, y: 130, z: 0 } })
+  const model = asset.document.model
+  for (const axis of ['x', 'y', 'z']) {
+    model.inputs.push({ id: `size.${axis}`, unit: 'mm', min: 100, max: 20000, role: 'design' } as never)
+    asset.designInputs[`size.${axis}`] = axis === 'y' ? 100 : axis === 'x' ? 600 : 400
+  }
+  return asset
+}
+
+test('크기 — 제 치수 · 인스턴스 크기 · 다른 부품의 치수를 가려 읽는다', () => {
+  const asset = pair()
+  assert.deepEqual(followOf(asset, 'plate', 'x'), { of: 'own' })
+  const byInstance = applyV3Authoring(asset, { kind: 'link-dimension', part: 'plate', axis: 'x', source: { of: 'instance', axis: 'x' } })
+  assert.deepEqual(followOf(byInstance, 'plate', 'x'), { of: 'instance', axis: 'x' })
+  const byPart = applyV3Authoring(byInstance, { kind: 'link-dimension', part: 'block', axis: 'x', source: { of: 'part', part: 'plate', axis: 'x' }, times: 0.5 })
+  assert.deepEqual(followOf(byPart, 'block', 'x'), { of: 'part', part: 'plate', axis: 'x' }, '배율이 끼어도 원천을 찾는다')
+  const back = applyV3Authoring(byPart, { kind: 'unlink-dimension', part: 'block', axis: 'x', mm: 300 })
+  assert.deepEqual(followOf(back, 'block', 'x'), { of: 'own' }, '떼면 다시 제 치수')
+  assert.equal(hasInstanceSize(asset, 'y'), true)
+  assert.equal(hasInstanceSize(createV3Asset('Bare'), 'y'), false)
+})
+
+test('붙이기 — 누구에게 붙었나, 붙일 수 있는 모양인가', () => {
+  const asset = pair()
+  assert.equal(fastenedTo(asset, 'block'), null)
+  const fastened = applyV3Authoring(asset, { kind: 'attach', part: 'block', face: 'bottom', to: { part: 'plate', face: 'top' } })
+  assert.equal(fastenedTo(fastened, 'block'), 'plate')
+  assert.equal(fastenedTo(applyV3Authoring(fastened, { kind: 'detach', part: 'block' }), 'block'), null)
+  const withDrum = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 50, length: 100 }, position: { x: 0, y: 50, z: 0 } })
+  assert.equal(canFasten(withDrum, 'block'), true)
+  assert.equal(canFasten(withDrum, 'drum'), true, '원기둥도 면으로 붙인다(figure-model 0.1.47)')
+  assert.equal(canFollow(withDrum, 'drum'), false, '원기둥의 치수 셋은 X·Y·Z 가 아니라 따르기는 상자만')
+})
+
+test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는다', () => {
+  const asset = pair()
+  assert.equal(motionOf(asset, 'block'), undefined)
+  const sliding = applyV3Authoring(asset, {
+    kind: 'add-motion',
+    part: 'block',
+    motion: { kind: 'slide', axis: 'x' },
+    state: { id: 'travel', unit: 'mm', min: 0, max: 300, start: 0 }
+  })
+  const motion = motionOf(sliding, 'block')!
+  assert.equal(motion.kind, 'slide')
+  assert.equal(motion.axis, 'x')
+  assert.equal(motion.control?.id, 'travel')
+  assert.equal(motion.control?.max, 300)
+  const turning = applyV3Authoring(asset, {
+    kind: 'add-motion',
+    part: 'block',
+    motion: { kind: 'turn', axis: 'y' },
+    state: { id: 'swing', unit: 'deg', min: -90, max: 90, start: 0 }
+  })
+  assert.deepEqual([motionOf(turning, 'block')!.kind, motionOf(turning, 'block')!.axis], ['turn', 'y'])
+  assert.equal(motionOf(applyV3Authoring(sliding, { kind: 'remove-motion', part: 'block' }), 'block'), undefined)
+})
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { choiceOf } from '../client/modeller/v3-links.ts'
+
+const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
+
+test('고르개의 값은 지금 따르는 것을 가리킨다', () => {
+  assert.equal(choiceOf({ of: 'own' }), 'own')
+  assert.equal(choiceOf({ of: 'instance', axis: 'y' }), 'instance:y')
+  assert.equal(choiceOf({ of: 'part', part: 'plate', axis: 'x' }), 'part:plate:x')
+})
+
+test('편집기는 세 칸의 명령을 세션의 이력 하나로 돌리고, 만날 수 있는 거절을 사람의 말로 한다', () => {
+  const editor = read('../client/modeller/v3-editor.ts')
+  assert.match(editor, /@v3-command=\$\{\(e: CustomEvent\) => this\.linkCommand\(e\.detail\.action\)\}/)
+  assert.match(editor, /this\.session!\.command\(action\)/)
+  assert.match(editor, /code === 'DIMENSION_CYCLE'[\s\S]*?figure\.text\.follow-would-loop/)
+  assert.match(editor, /code === 'ATTACH_CYCLE'[\s\S]*?figure\.text\.fasten-would-loop/)
+})
+
+test('떼면 지금 크기로 고정한다 — 따르던 값을 잃지 않는다', () => {
+  const links = read('../client/modeller/figure-v3-links.ts')
+  assert.match(links, /kind: 'unlink-dimension', part: this\.partId, axis, mm \}/)
+  assert.match(links, /this\.dims\?\.\[AXES\.indexOf\(axis\)\]/)
+})
+
+test('세 칸의 말은 다섯 말 모두에 있다', () => {
+  const links = read('../client/modeller/figure-v3-links.ts')
+  const keys = [...links.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1])
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
+    const table = JSON.parse(read(`../translations/${lang}.json`))
+    for (const key of [...keys, 'figure.text.follow-would-loop', 'figure.text.fasten-would-loop', 'figure.label.motion-slide', 'figure.label.motion-turn', 'figure.label.place-grip', 'figure.label.place-seat'])
+      assert.ok(table[key], `${lang}: ${key}`)
+  }
+})
+
+test('도형 크기를 따라 움직이는 자리를 가려 읽고, 여기에 고정하면 사라진다 — 드라이룸 램프의 길', () => {
+  let asset = pair()
+  asset = addV3Box(asset, { id: 'lamp', size: { x: 40, y: 20, z: 40 }, position: { x: 0, y: 10, z: 0 } })
+  const model = asset.document.model
+  model.nodes.push({ id: 'lamp.lift', op: 'add@1', args: ['size.y', 'lamp.position.y'], outputs: { value: 'lamp.lift.value' } } as never)
+  model.nodes.find(n => n.id === 'lamp.pose')!.args[1] = 'lamp.lift.value'
+  assert.deepEqual(positionsWorkedOut(asset, 'lamp'), ['y'])
+  assert.deepEqual(positionsWorkedOut(asset, 'plate'), [], '제 숫자로 놓인 부품에는 없다')
+  const fixed = applyV3Authoring(asset, { kind: 'fix-position', part: 'lamp', axis: 'y' })
+  assert.deepEqual(positionsWorkedOut(fixed, 'lamp'), [])
+  assert.equal(fixed.designInputs['lamp.position.y'], 110, '지금 자리 그대로 — 100 + 10')
+})
+
+test('자리 — 부품의 면에 둔 집는 자리·놓는 자리를 그 부품에서 읽는다', () => {
+  let asset = pair()
+  asset = addV3Primitive(asset, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 300 }, position: { x: 0, y: 400, z: 0 } } as never)
+  assert.deepEqual(placeFacesOf(asset, 'block'), ['left', 'right', 'bottom', 'top', 'back', 'front'])
+  assert.deepEqual(placeFacesOf(asset, 'drum'), [], '둥근 몸에는 자리를 권하지 않는다 — 명령이 거절할 것이다')
+
+  assert.equal(placeIdFor(asset, 'block', 'grip'), 'block-grip')
+  asset = applyV3Authoring(asset, { kind: 'add-binding', id: placeIdFor(asset, 'block', 'grip'), label: '집는 자리', role: 'grip', part: 'block', face: 'top', accepts: acceptsOf(' BOX, TOTE,, BOX '), capacity: 2 })
+  assert.equal(placeIdFor(asset, 'block', 'grip'), 'block-grip-2', '같은 부품에 둘째 자리는 다른 id')
+  assert.deepEqual(
+    placesOn(asset, 'block').map(p => [p.id, p.role, p.face, p.accepts, p.capacity]),
+    [['block-grip', 'grip', 'top', ['BOX', 'TOTE'], 2]]
+  )
+  assert.deepEqual(placesOn(asset, 'plate'), [], '다른 부품의 자리는 안 섞인다')
+})
+
+test('담는 능력이 없는 도형은 자리가 있어도 보드가 아무것도 넘기지 않는다 — 화면이 그것을 말한다', () => {
+  const asset = pair()
+  assert.equal(holdsThings(asset), false)
+  asset.document.capabilities.names = ['Capacity', 'Holdable']
+  assert.equal(holdsThings(asset), true)
+  asset.document.capabilities.names = ['FlowNode']
+  assert.equal(holdsThings(asset), true, 'FlowNode 는 Capacity 를 품는다')
+
+  const links = read('../client/modeller/figure-v3-links.ts')
+  assert.match(links, /holdsThings\(asset\)/)
+  assert.match(links, /kind: 'set-capabilities', names/)
+  const editor = read('../client/modeller/v3-editor.ts')
+  /* A slice and `includes`, not a lazy regex over the whole editor: that hangs when it does not match. */
+  const start = editor.indexOf('<figure-v3-links')
+  const block = editor.slice(start, editor.indexOf('</figure-v3-links>', start))
+  assert.ok(start >= 0 && block.includes('@v3-part-edit=${(e: CustomEvent) => this.run(() => this.session!.edit(e.detail.edit))}'), '자리 절의 능력 선언이 편집기에 닿는다')
+})
+
+test('받는 종류가 없으면 자리를 만들지 않는다 — 형식에 「아무거나」가 없다', () => {
+  const links = read('../client/modeller/figure-v3-links.ts')
+  assert.match(links, /\?disabled=\$\{this\.locked \|\| !accepts\.length \|\| !capacityOk\}/)
+  assert.deepEqual(acceptsOf(' , ,'), [])
+})

package/things-factory.config.js

@@ -5,11 +5,8 @@ export default {
   route,
   routes: [
     { tagname: 'figure-list-page', page: 'figure-list' },
-    { tagname: 'figure-modeller-page', page: 'figure-modeller' },
-    /*
-      The V3 modeller under its own name until the catalogue's assets are V3 (ADR-0087 step 5). Without this row
-      the URL changes and no element is made — the shell builds the DOM from this table, not from route().
-    */
+    /* One modeller since ADR-0087 step 5; the old V3 address is an alias. The shell builds the DOM from this table. */
+    { tagname: 'figure-v3-modeller-page', page: 'figure-modeller' },
     { tagname: 'figure-v3-modeller-page', page: 'figure-v3-modeller' }
   ],
   bootstrap

package/translations/en.json

@@ -14,6 +14,7 @@
   "figure.button.discard": "discard",
   "figure.button.duplicate-part": "duplicate",
   "figure.button.fit-base-to-parts": "fit to parts",
+  "figure.button.fix-position": "fix here",
   "figure.button.mirror-x": "mirror X",
   "figure.button.mirror-z": "mirror Z",
   "figure.button.move-part-down": "move down",
@@ -37,13 +38,18 @@
   "figure.button.snap": "snap",
   "figure.button.take-n-changes": "apply {n}",
   "figure.label.declared-space": "declared space",
+  "figure.label.follows-expression": "set by an expression",
   "figure.label.gizmo-rotate": "turn",
   "figure.label.gizmo-scale": "size",
   "figure.label.gizmo-translate": "move",
+  "figure.label.position-worked-out": "moves with the figure size",
   "figure.label.primitive-rounded-box": "rounded box",
   "figure.text.catalog-needs-a-save": "can be set once the figure is saved.",
   "figure.text.declared-space-declared": "declared from the parts.",
   "figure.text.declared-space-none": "not declared yet.",
+  "figure.text.fasten-would-loop": "that part is already fastened to this one, so it cannot be fastened the other way.",
+  "figure.text.follow-would-loop": "that dimension already follows this part, so the two cannot follow each other.",
+  "figure.text.links-need-a-box": "size following works on box-shaped parts, fastening on boxes and cylinders.",
   "figure.text.mounting-face-needs-space": "declare the space first to choose one.",
   "figure.text.part-is-referenced": "'{part}' cannot be deleted: another part is fastened to it or follows its size. Undo that link first.",
   "figure.text.part-name-invalid": "'{name}' cannot be a part name. Start with a letter and use letters, digits, - and _.",
@@ -559,5 +565,19 @@
   "figure.label.state-inputs": "state inputs",
   "figure.label.design-inputs": "design inputs",
   "figure.text.release-blocked": "Release is blocked — {count}",
-  "figure.text.release-ready": "Ready to release"
+  "figure.text.release-ready": "Ready to release",
+  "figure.label.places": "Places",
+  "figure.text.places-need-a-box": "A place sits on a face of a box-shaped part.",
+  "figure.label.place-grip": "Grip",
+  "figure.label.place-seat": "Seat",
+  "figure.label.place-holds": "up to {count}",
+  "figure.button.remove-place": "Remove place",
+  "figure.text.place-explained": "Where a board sets or holds things on this part. When the part moves, what it holds moves with it.",
+  "figure.text.place-needs-holding": "This figure does not declare that it holds things, so a board hands nothing to its places.",
+  "figure.button.declare-holding": "Make it hold things",
+  "figure.label.place-name": "Name",
+  "figure.label.place-accepts": "Takes",
+  "figure.label.place-capacity": "How many",
+  "figure.text.place-accepts-needed": "Name at least one type it takes, separated by commas.",
+  "figure.button.add-place": "Add place"
 }