@things-factory/figure-ui 10.1.208 → 10.1.210

package/docs/multipart-response-review-2026-10-24.md

@@ -0,0 +1,77 @@
+> 후속 구현: [크기와 반복 배치 UX](size-and-repeat-ux-2026-10-24.md). 이 문서의 이전 화면 제안은 후속 구현 문서와 구분해 읽어야 합니다.
+
+# 여러 부품의 관계에서 반응형 UI 점검
+
+## 범위
+
+사용자의 요청에 따라 단일 부품 검증의 한계를 보완했다. 제품 UI는 추가 수정하지 않았다. 상판(tabletop), 보강대(brace), 다리(legLeft/legRight) 네 부품을 figure-model API로 구성한 재현 fixture를 실제 figure-ui 편집기에 열었다. 이는 관계의 표현과 조작을 점검한 것으로, 사용자가 빈 피규어에서 이 조립체를 쉽게 제작할 수 있다는 검증은 아니다. 저장소는 메모리다. 운영 데이터 변경 및 배포는 없다.
+
+figure-model 0.10.0, things-scene 10.1.99는 operato-application 설치본을 사용했다. figure-ui / figure-viewer는 things-factory 현재 소스를 빌드했다.
+
+## 모델의 의미와 측정
+
+| 부품 | 치수 규칙 | 위치 규칙 | 피규어 너비 1500 → 3000 mm |
+| --- | --- | --- | --- |
+| 상판 | 너비는 피규어 너비, 두께 80·깊이 600 고정 | 기준 위치 유지 | 너비 1500 → 3000 |
+| 보강대 | 너비 = 상판 너비 − 200, 높이 60·깊이 40 고정 | 상판 아랫면, Z 최소 가장자리 | 너비 1300 → 2800 |
+| 왼쪽 다리 | 80 × 700 × 80 고정 | 상판 아랫면, X 최소·Z 최대 가장자리 | 중심 X −710 → −1460 |
+| 오른쪽 다리 | 80 × 700 × 80 고정 | 상판 아랫면, X 최대·Z 최대 가장자리 | 중심 X 710 → 1460 |
+
+자동 검사 3개 통과. 브라우저에서 보강대/다리 선택, 반응형 및 속성 탭 확인, 전체 적용과 undo, 피규어 너비 미리보기 3000을 조작했다. 숫자별 geometry/pose는 자동 검사에서 검증했다. 브라우저 캔버스에서는 조립체 렌더링을 확인했다.
+
+## 발견한 문제
+
+### 1. 참조 대상과 연산은 별개의 정보다
+
+반응형 탭 상단 문장은 보강대를 ‘tabletop의 너비에 -200 mm를 더한 값’이라고 정확히 설명한다. 반면 같은 화면의 치수 행은 ‘tabletop의 X’만 표시한다. 상세를 펼쳐야 -200 입력을 수정할 수 있다. `followWordsOf`는 part의 times/plus를 생략하고, `renderDimensions`의 following 판정도 같은 축의 instance이면 배율과 오프셋을 생략해 ‘함께 변경’으로 표시한다.
+
+정보가 전혀 없는 것이 아니라, 상단 문장·치수 요약·상세 입력이 각기 다른 수준으로 관계를 표현한다. 고정/비례만으로 치환하면 ‘어느 부품의 어떤 치수를, 어느 규칙으로 따르는가’를 잃는다.
+
+### 2. 전체 적용이 기존 관계를 덮어쓴다
+
+보강대에서 기존 ‘도형 크기에 맞추기’를 클릭했다. 화면은 너비를 피규어 너비의 86.7%로, 높이를 피규어 높이의 75%로, 깊이를 피규어 깊이의 6.7%로 변경했고, -200 입력은 0이 됐다. 실행 취소로 원래 관계를 복원했다.
+
+`figure-links.ts`가 axes 없는 follow-size를 보내고, figure-model `authoring-actions.ts`의 followSize가 replace:true로 모든 편집 치수를 연결한다. 의도된 명령 동작이지만 UI에서 참조 대상 교체와 기존 규칙 제거가 분명하지 않다. 피규어 너비 3000에서 원래 보강대는 2800, 버튼 적용 뒤는 약 2600이다. 따라서 단순히 ‘같은 설정을 한 번에 하는 중복 버튼’이라고 설명한 이전 판단은 불충분했다.
+
+### 3. 크기 고정과 위치 고정은 다르다
+
+다리의 반응형 탭에는 세 치수가 모두 고정으로 나온다. 그러나 다리는 상판 가장자리를 따라 이동한다. 부품 목록에는 상판 아랫면 부착이 표시되고, 속성 탭에는 부착 설정이 있지만, 반응형 탭 자체에는 이 예의 부착에 따른 위치 반응이 나오지 않는다.
+
+`render()`의 response는 positionsWorkedOut가 반환하는 위치 계산식만 표시하고, renderFastening은 shape(속성)에 둔다. ‘반응형’이 치수만 뜻하는지 부품의 전체 반응을 뜻하는지 사용자에게 명확하지 않다. 고정을 위치까지 고정한다는 의미로 읽지 않도록 해야 한다.
+
+### 4. 기준 치수와 미리보기 결과가 함께 나오지만 구분 표시가 없다
+
+미리보기의 피규어 너비는 3000인데 오른쪽 보강대 치수는 기준값 1300으로 남는다. 평가 결과의 보강대 너비는 2800이다. 반응형 패널은 편집 revision을 읽으며 미리보기의 trying 값을 반영하지 않는다. 화면에 기준 치수라는 표기가 없으므로 변경이 적용되지 않은 것처럼 읽힐 수 있다.
+
+### 5. 선택 대상과 관계 상대를 찾는 부담
+
+오른쪽 상단은 선택된 부품 이름 brace 대신 형태 이름 ‘상자’를 표시한다. 목록에서 선택을 추적해야 한다. 상세 선택지는 다른 모든 부품의 X/Y/Z를 평면적으로 나열한다. 이 예는 3개 상대 × 3축에 피규어 6개 선택지와 고정을 더해 축마다 16개 항목이다. 부품이 늘 때 사용자가 관계 대상을 찾는 부담이 커진다.
+
+## UI 판단
+
+현재 UI는 기존 관계를 편집할 수는 있지만, 여러 부품의 관계를 이해하고 유지하며 변경하기에는 불충분하다. 단순 고정/비례 토글은 치수가 자기 값을 유지하거나 피규어를 단순 비례로 따르는 경우에만 적합하다. 다른 부품 참조, 일정 차이, 수식에 같은 토글을 강제로 적용해서는 안 된다.
+
+다음 설계의 검증 기준:
+
+1. 선택한 부품 이름을 표시한다.
+2. 크기 관계는 ‘기준 대상 → 대상 치수 → 규칙’으로 읽히게 한다. 예: 보강대 너비 = 상판 너비 − 200 mm. 기존 관계를 다른 대상으로 바꾸는 조작은 단순 상태 변경과 구별한다.
+3. 위치 관계는 따로 명시한다. 예: 다리 치수 고정 / 상판 아랫면의 가장자리 따라가기. 부착 편집을 중복 구현하지 않고 기존 편집으로 이어지게 한다.
+4. 기준 치수와 미리보기 결과를 구분한다. 가능하면 ‘1300 → 2800 mm’처럼 결과를 함께 보여준다.
+5. 부품 참조를 ‘사용자 설정’ 하나로 숨기지 않는다. 무엇을 따르는지 기본 화면에서 읽을 수 있어야 한다.
+
+이번 점검으로 반복 개수, 회전된 로컬 축, 관절 및 홀딩의 UI까지 검증했다고 보지 않는다.
+
+## 재현
+
+figure-ui 패키지에서:
+
+```sh
+PORT=4392 \
+FIGURE_MODEL=/Users/super/Documents/GitHub/operato-application/node_modules/@hatiolab/figure-model \
+THINGS_SCENE=/Users/super/Documents/GitHub/operato-application/node_modules/@hatiolab/things-scene \
+node test/browser/serve-response.mjs multipart-response-page.js
+```
+
+http://127.0.0.1:4392/ 에서 brace 선택 → 반응형 → 상세 펼치기. 전체 적용은 관계를 바꾸므로 확인 후 undo한다. legLeft 선택 → 반응형과 속성을 비교한다. 미리보기 너비를 3000으로 바꾼다. 새로고침은 fixture 초기 상태로 돌아간다.
+
+검사: `test/multipart-response.test.ts`, 모델: `test/multipart-response-fixture.js`, 화면: `evidence/2026-10-24/multipart-response.png`.

package/docs/response-authoring-2026-10-24.md

@@ -0,0 +1,46 @@
+> 후속 구현: [크기와 반복 배치 UX](size-and-repeat-ux-2026-10-24.md). 이 문서의 이전 화면 제안은 후속 구현 문서와 구분해 읽어야 합니다.
+
+# 반응형 제작 첫 단계 — 축별 크기 반응
+
+## 확인한 문제와 코드 근거
+
+figure.hatiolab.com의 새 Figure에서 상자를 직접 추가하고 1500 × 80 × 600 mm로 편집했다. 반응형 → 크기 반응 정하기를 먼저 열었을 때, 도형의 size 입력이 아직 없으면 축별 선택지는 고정뿐이었다. 별도의 ‘도형 크기에 맞추기’를 사용하면 모든 축이 함께 연결되어, 너비만 반응시키려는 작업에도 불필요한 해제가 필요했다.
+
+- `client/modeller/figure-links.ts`: 기존 renderDimensions는 모두 고정이면 치수 요약을 숨겼고, 전체 축 follow-size만 노출했다. 고급 선택지는 hasInstanceSize로 제한했다.
+- figure-model `src/authoring-actions.ts`의 followSize: 이미 axes를 지원한다. 필요한 size 입력을 선언하고 선택한 축의 현재 치수/도형 크기 비율로 link-dimension을 만든다. 따라서 새 모델 표현이나 렌더링 구현은 필요하지 않았다.
+- 브라우저 자동화의 fill로 입력한 숫자가 실제 모델에 반영되지 않은 현상은 native 키 입력에서는 재현되지 않았다. 제품 입력 결함으로 판단하지 않았다.
+
+## 반영한 변경
+
+실제 figure-ui 편집기의 반응형 패널에 너비·높이·깊이의 현재 치수와 고정 여부를 처음부터 표시한다. 각 고정 치수에 ‘비례 변경’을 제공하고 기존 follow-size 명령에 해당 축만 전달한다. 설정 직후 치수와 위치를 유지하며 한 번의 undo로 복구된다. 기존 전체 축 설정, 고급 수식/다른 부품 연결, 고정으로 되돌리기는 유지한다. 잠긴 모델과 uniform 크기 방식에서는 새 설정 버튼도 비활성화한다. 여섯 언어의 문구를 추가했다.
+
+비례 변경은 해당 도형 축을 따라가는 치수 규칙이다. 부품을 면에 붙이거나 위치를 비례 이동시키는 설정은 아니다. 원형 부품은 기존 provider가 제공하는 편집 치수를 사용하며, 회전된 부품의 방향 대응을 새로 추정하지 않는다.
+
+## 검증 결과
+
+- 관련 단위 테스트 56개 통과: 기존 설치 figure-model 0.9.6 및 앱의 0.10.0 각각 실행.
+- 추가 회귀 검증: 새 1500 × 80 × 600 mm 프레임에 X만 설정. 설정 직후 geometry/pose 동일. 도형 세 축 입력을 모두 두 배로 주면 geometry는 3000 × 80 × 600 mm. 한 번의 undo로 size 선언까지 복구, redo 동일.
+- 실제 editor 소스를 빌드한 로컬 fixture를 Chrome에서 조작: 너비 비례 변경 → 미리보기 너비 3000 → 편집 → undo → redo 확인. 별도 샘플 모델러가 아닌 제품 editor와 things-scene을 사용한다. fixture의 저장소는 메모리이며 운영 저장·재접속 검증은 하지 않았다.
+- 캡처: `evidence/2026-10-24/width-preview.png`. 왼쪽 3000은 미리보기 입력, 오른쪽 1500은 편집 기준 치수다.
+
+## 검증 환경의 불일치
+
+이 날짜의 things-factory node_modules는 figure-model 0.9.6 / things-scene 10.1.95, operato-application node_modules는 0.10.0 / 10.1.99였다. 전자의 조합으로 만든 로컬 미리보기에서 `SCHEMA: input: missing min`이 발생했다. 후자의 두 패키지로 빌드하면 발생하지 않았다. 구버전 내부의 정확한 오류 발생 위치까지 규명한 것은 아니며, 이 UI 변경으로 스키마를 완화하지 않았다.
+
+기본 tsc는 mountingFace 타입 및 설치된 figure-viewer의 bodyAtSize/sizeSpanOf export 불일치 세 건으로 실패했다. 임시 tsconfig에서 figure-model을 앱의 0.10.0 선언으로, figure-viewer를 현재 소스로 연결하면 전체 client noEmit 검사가 통과했다. 설치 의존성이나 lockfile을 변경하지 않았다. 따라서 기본 설치 환경의 빌드 문제는 여전히 별도 정리가 필요하다.
+
+## 화면 재현
+
+figure-ui 패키지에서 실행한다. 경로는 현재 로컬 체크아웃 기준이며, 같은 버전이 설치된 환경에서는 override를 생략할 수 있다.
+
+```sh
+FIGURE_MODEL=/Users/super/Documents/GitHub/operato-application/node_modules/@hatiolab/figure-model \
+THINGS_SCENE=/Users/super/Documents/GitHub/operato-application/node_modules/@hatiolab/things-scene \
+node test/browser/serve-response.mjs
+```
+
+http://127.0.0.1:4391/ 에서 frame 선택 → 반응형 → 너비 비례 변경 → 미리보기 → 너비 슬라이더 끝(3000). 저장소가 메모리이므로 새로고침하면 초기 상태로 돌아간다. UI 자체의 저장 버튼도 운영 저장은 하지 않는다.
+
+## 범위와 다음 점검
+
+운영 사이트에는 배포하지 않았다. 이번 확인으로 컨베이어 제작 전체가 쉬워졌다고 판단하지 않는다. 다음 순서는 원기둥 하나를 실제로 추가해 프레임 면에 붙이고, 간격과 길이 변화에 따른 반복 개수 및 끝 여백을 설정하는 과정이다. 그 과정에서 발견한 혼란도 figure-model의 기존 규칙과 편집기의 노출 방식을 구분해 고친다. 관절·애니메이션·홀딩은 아직 이 변경의 검증 범위 밖이다.

package/docs/size-and-repeat-ux-2026-10-24.md

@@ -0,0 +1,67 @@
+# 크기와 반복 배치 편집 개선 (2026-10-24)
+
+상태: 실제 figure-ui 소스에 구현, 로컬 브라우저 검증 완료. 운영 배포·커밋 없음.
+이 문서는 response-authoring-2026-10-24.md의 축별 버튼/고급 설정 제안을 대체한다.
+
+## 크기
+
+배치 > 크기에서 축별 크기(mm), 가변 여부, 상대 부품, 상대 축을 함께 설정한다.
+가변 축만 상대와 비례 유지/차이 유지 선택을 표시한다. 비율·차이 수치를 따로 편집하지 않는다.
+상대 또는 방식을 바꾸면 현재 크기를 보존해 규칙을 계산한다. 크기 입력을 바꾸면 선택한 규칙을 갱신한다.
+붙이기의 상대와 크기의 상대는 독립적이다. 새 가변 설정에서 붙인 상대를 제안할 뿐, 재부착으로 크기 상대를 바꾸지 않는다.
+원기둥 등은 shape provider의 측정 배율을 적용한다. 기존 복합 수식은 자동 변환하지 않는다.
+자체 입력은 figureSizeEditOf를 통해 편집해 부착/크기 편집의 기존 위치 계약을 보존한다.
+기존 전체 크기 맞춤 버튼, 별도 축별 되돌리기, 고급 크기 설정은 제거했다.
+미리보기의 크기 설정 이동도 배치 탭으로 연결했다.
+
+## 반복 배치
+
+- 명칭: 줄로 배열 → 반복 배치. 부품의 이전 반응형 탭은 배치로 변경.
+- 적용 전: 접힌 상태에서도 미적용 표시. 펼치면 방향, 간격 유지/개수 유지, 해당 입력과 적용 버튼.
+- 적용 후: 적용됨 표시, 상대 부품, 방향, 현재 개수, 중심 간격. 방향/방식/유효한 입력을 직접 수정 가능.
+- 간격 유지: 중심 간격을 입력하고 개수는 자동 계산.
+- 개수 유지: 개수를 입력하고 중심 간격은 자동 계산하여 읽기 전용 표시.
+- 중심 간격은 표면 사이 빈틈이 아니라 중심과 다음 중심의 거리이다.
+- 해제는 숨은 메뉴 대신 직접 버튼으로 제공. 원본 부품 하나가 남는다는 설명 포함.
+- 기존 고정 개수 UI가 layout.args[4](부품 extent)를 피치로 표시하던 문제 수정: figureRowOf의 실제 pitch 사용.
+- 기존 반복 배치를 수정할 때 set-joint로 repeat만 변경해 연결·관절의 나머지 기록을 보존한다.
+- 적용 후와 부품 전환 시 이전 미리보기 후보가 남지 않도록 정리.
+- 부착으로 위치가 정해진 부품에는 별도의 계산 위치 고정/비례 버튼을 중복 표시하지 않는다.
+
+## 검증
+
+figure-model 0.10.0, things-scene 10.1.99에 맞춰 타입 검사 및 브라우저 빌드.
+기존 things-factory node_modules의 figure-model 0.9.6은 사용하지 않고 명시적 경로를 지정했다.
+의존성 설치나 lockfile 변경 없음.
+
+관련 Node 테스트 66개 통과: size-response, multipart-response, attachment-size-contract, links, resize-with-placement.
+실제 브라우저에서 확인:
+
+1. brace의 상대 tabletop이 처음부터 정확히 표시됨.
+2. 1300 → 1250 크기 입력, 비례/차이 전환 시 1250 유지.
+3. legLeft를 X 방향 200 mm 간격으로 배치하면 8개 표시.
+4. 적용 후 개수 유지로 바꾸고 5개 입력 → 중심 간격 355 mm.
+5. 방향 Z로 변경 → 중심 간격 130 mm. 되돌리기 → X, 355 mm 복원.
+6. 해제하면 미적용 상태와 단일 부품으로 복귀.
+
+증거: evidence/2026-10-24/integrated-size.png, repeat-layout.png.
+로컬 확인 URL: http://127.0.0.1:4393/ (in-memory fixture, 실제 편집기 컴포넌트).
+
+## 범위
+
+figure-model 명세와 저장 형식은 변경하지 않았다. 복합 수식의 범용 편집 UI를 추가한 것은 아니다.
+원점 부착·곡면 부착 등 커널이 지원하지 않는 반복 배치는 기존 제한과 이유를 유지한다.
+
+## 공통 스타일 정합성 보완
+
+크기 편집기는 별도 입력 스타일 대신 figure-viewer의 SidePanelStyles를 직접 사용한다.
+기존 패널과 동일한 26px 높이, 밑줄 입력, 글꼴·색상 토큰, 포커스 표시를 적용했다.
+축마다 추가했던 구분선과 박스형 입력, 반복 배치의 둥근 상태 배지와 박스형 해제 버튼을 제거했다.
+상태 문구와 라디오 선택 행은 공통 스타일에 이름 있는 규칙(section-state, choice-row)으로 정의했다.
+해제는 기존 quiet 버튼 규칙을 사용한다. 적용 전후 라디오 정렬·간격도 일치시켰다.
+타입 검사와 실제 화면 확인 완료. 최신 스타일 확인 URL은 http://127.0.0.1:4394/ 이다.
+증거: evidence/2026-10-24/size-shared-style.png, repeat-shared-style.png.
+
+## 크기 설정 위치 변경
+
+사용자 요청으로 통합 크기 설정을 배치 탭 맨 위로 이동했다. 속성의 중복 크기 구역과 빈 구역은 제거했다. 형상 고유 치수는 필요한 부품에서만 속성에 유지한다. 크기를 편집할 때 유지되는 위치 설명도 배치의 크기 구역으로 이동했다. 타입 검사 및 실제 브라우저에서 속성의 중복 제거와 배치의 설정 표시를 확인했다. 증거: evidence/2026-10-24/size-in-layout.png.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-ui",
-  "version": "10.1.208",
+  "version": "10.1.210",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -27,8 +27,8 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.10.0",
-    "@hatiolab/things-scene": "^10.1.99",
+    "@hatiolab/figure-model": "^0.11.0",
+    "@hatiolab/things-scene": "^10.1.100",
     "@material/web": "^2.0.0",
     "@operato/data-grist": "^10.29.43",
     "@operato/graphql": "^10.29.43",
@@ -42,11 +42,11 @@
     "@operato/slot-layout-editor": "^10.29.43",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.29.43",
-    "@things-factory/ai-assistant": "^10.1.208",
-    "@things-factory/figure-service": "^10.1.208",
-    "@things-factory/figure-viewer": "^10.1.208",
+    "@things-factory/ai-assistant": "^10.1.210",
+    "@things-factory/figure-service": "^10.1.210",
+    "@things-factory/figure-viewer": "^10.1.210",
     "@things-factory/setting-base": "^10.1.208",
     "three": "^0.185.1"
   },
-  "gitHead": "ffc1ceaa9471b9f4a9b86f46c3021f2fed72d17d"
+  "gitHead": "89fbda12d43d8532ba4e95ba6d6d7e05e2da2502"
 }

package/test/attachment-size-contract.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { addFigureBox, applyFigureAuthoring, applyFigureProposal, compileFigureAsset, figureFollowOf, parseFigureAsset, serializeFigureAsset } from '@hatiolab/figure-model'
+import { multipartResponseFixture } from './multipart-response-fixture.js'
+import { createFigureProductSession } from '../client/modeller/product-session.js'
+
+const rules = (parent: string, replace = true) => [
+  { kind: 'link-dimension' as const, part: 'brace', axis: 'x' as const, source: { of: 'part' as const, part: parent, axis: 'x' as const }, plus: -300, replace },
+  { kind: 'attach' as const, part: 'brace', to: { part: parent, face: 'bottom' as const }, align: { x: { mm: -50 }, z: 'min' as const }, replace }
+]
+const brace = (a: ReturnType<typeof multipartResponseFixture>) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'brace')!
+
+test('asymmetric face margins survive serialization using existing dimension and attachment commands', () => {
+  const a = parseFigureAsset(serializeFigureAsset(applyFigureProposal(multipartResponseFixture(), rules('tabletop'))))
+  for (const width of [1500, 2000, 3000]) {
+    const g = brace({ ...a, designInputs: { ...a.designInputs, 'size.x': width } })
+    const size = g.shape.dimensions['size.x']!
+    assert.equal(size, width - 300)
+    assert.equal(g.pose.t[0] - size / 2 + width / 2, 100)
+    assert.equal(width / 2 - (g.pose.t[0] + size / 2), 200)
+  }
+})
+
+test('reattachment alone leaves dimension reference unchanged; combined recipe retargets both with one undo', async () => {
+  const original = addFigureBox(multipartResponseFixture(), { id: 'otherTop', size: { x: 2000, y: 80, z: 600 }, position: { x: 0, y: 1000, z: 0 } })
+  const onlyAttached = applyFigureAuthoring(original, { kind: 'attach', part: 'brace', to: { part: 'otherTop', face: 'bottom' }, replace: true })
+  assert.equal((figureFollowOf(onlyAttached, 'brace', 'x') as { part: string }).part, 'tabletop')
+  const source = serializeFigureAsset(original)
+  const session = createFigureProductSession({ load: async () => ({ id: 'audit', source }), save: async q => ({ id: 'audit', source: q.source }) })
+  await session.open('audit')
+  const before = session.source()
+  session.applyRecipe(rules('otherTop'))
+  const after = session.source()
+  const result = parseFigureAsset(after)
+  assert.equal((figureFollowOf(result, 'brace', 'x') as { part: string }).part, 'otherTop')
+  assert.equal(brace(result).shape.dimensions['size.x'], 1700)
+  assert.equal(result.joints!.find(j => j.body1.part === 'brace')!.body0.part, 'otherTop')
+  session.undo(); assert.equal(session.source(), before)
+  session.redo(); assert.equal(session.source(), after)
+  assert.throws(() => session.applyRecipe(rules('missing')))
+  assert.equal(session.source(), after, 'failed recipe changes nothing')
+})
+
+test('detach preserves dimension references: editor must explicitly choose how its managed size rules end', () => {
+  const a = applyFigureAuthoring(multipartResponseFixture(), { kind: 'detach', part: 'brace' })
+  assert.equal((figureFollowOf(a, 'brace', 'x') as { part: string }).part, 'tabletop')
+})

package/test/browser/acceptance-page.js

@@ -112,7 +112,7 @@ export const MODELS = {
       a = addFigureBox(a, { id, size: { x: 900, y: 1800, z: 40 }, position: { x, y: 1000, z: 0 } })
       a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'frame', face: 'top' } })
       const j = a.joints.find(k => k.body1.part === id)
-      a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: `${id}-open` } } })
+      a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', state: { id: `${id}-open` } }] } })
       a = editFigurePart(a, { kind: 'set-driver', state: `${id}-open`, clip: `${id}-swing`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })
     }
     return serializeFigureAsset(a)

package/test/browser/detail-page.js

@@ -11,7 +11,7 @@ async function start() {
   asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range: { x: { min: 50, max: 400 }, y: { min: 50, max: 400 }, z: { min: 50, max: 400 } }, at: { x: 100, y: 100, z: 100 } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size', part: 'block', axes: ['x', 'y', 'z'] })
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: {
-    id: 'block', type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: 'block' }, axis: 'X', lowerLimit: 0, upperLimit: 200, state: { id: 'shift', start: 0 }
+    id: 'block', body0: { plane: 'mounting-plane' }, body1: { part: 'block' }, motion: [{ type: 'prismatic', axis: 'X', lowerLimit: 0, upperLimit: 200, state: { id: 'shift', start: 0 } }]
   } })
   asset = editFigurePart(asset, { kind: 'set-driver', state: 'shift', clip: 'cycle', duration: 4, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 200 }, { seconds: 4, value: 0 }] })
   const source = serializeFigureAsset(asset)

package/test/browser/detail-tabs-page.js

@@ -13,7 +13,7 @@ for (let i = 0; i < PARTS; i++) {
   const id = `slide-${i}`
   asset = addFigureBox(asset, { id, size: { x: 40, y: 40, z: 40 }, position: { x: i * 60, y: 20, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: {
-    id, type: 'prismatic', body0: { plane: 'mounting-plane' }, body1: { part: id }, axis: 'Z', lowerLimit: 0, upperLimit: 100, state: { id: `${id}-z`, start: 0 }
+    id, body0: { plane: 'mounting-plane' }, body1: { part: id }, motion: [{ type: 'prismatic', axis: 'Z', lowerLimit: 0, upperLimit: 100, state: { id: `${id}-z`, start: 0 } }]
   } })
   asset = editFigurePart(asset, { kind: 'set-driver', state: `${id}-z`, clip: `cycle-${i}`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 1, value: 100 }, { seconds: 2, value: 0 }] })
 }

package/test/browser/editing-page.js

@@ -52,7 +52,7 @@ window.figures = {
       a = addFigureBox(a, { id, size: { x: 900, y: 1800, z: 40 }, position: { x, y: 1000, z: 0 } })
       a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'frame', face: 'top' } })
       const j = a.joints.find(k => k.body1.part === id)
-      a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', state: { id: `${id}-open` } } })
+      a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', state: { id: `${id}-open` } }] } })
       a = editFigurePart(a, { kind: 'set-driver', state: `${id}-open`, clip: `${id}-swing`, duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 80 }] })
     }
     return serializeFigureAsset(a)

package/test/browser/editing.check.mjs

@@ -313,28 +313,42 @@ describe('the material: colours by purpose, one step each, a glow drawn while dr
     assert.ok(offered.folded && !offered.folded.open && offered.folded.count > 0, JSON.stringify(offered.folded))
   })
 
-  test('a single field typed is drawn while it is typed; written when it is left', async () => {
+  /*
+    A round body's measures are the 「배치」 tab's size editor (2026-10-24): its across said as a diameter, written as the
+    radius it halves to. The editor writes on change; it draws nothing while a number is typed.
+  */
+  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-arrangement')))
     const start = await revision()
-    await type('drum.dimension.radius', '300')
-    assert.equal((await look('drum')).size[0], 600, 'drawn 600 across while typed')
+    await type('drum X · 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)
     assert.equal(await revision(), start + 1)
     assert.equal(await read(() => probe.value('drum.dimension.radius')), 300)
+    assert.equal((await look('drum')).size[0], 600, 'drawn 600 across')
+    await click(await read(() => probe.tab('figure.label.tab-short-properties')))
   })
 })
 
+/*
+  A box's size is the 「배치」 tab's size editor now (2026-10-24); the numbers in hand on the properties tab are its place,
+  in the position row.
+*/
 describe('values in hand on the properties tab: drawn at once, written on change (user 2026-09-24)', () => {
+  /* Where the canvas is told to draw the box across: its pose as given to it. */
+  const across = async () => Math.round((await read(() => probe.drawnPose('box'))).t[0])
+  let was
   before(async () => {
     await mount('box')
     await pick('box')
   })
 
-  test('a size typed is drawn while it is typed, and written once on Enter', async () => {
+  test('a place typed is drawn while it is typed, and written once on Enter', async () => {
+    was = await across()
     const start = await revision()
-    await type('box.size.x', '700')
-    assert.equal((await look('box')).size[0], 700, 'drawn 700 wide while typed')
+    await type('box.position.x', '300')
+    assert.equal(await across(), was + 300, 'drawn 300 over while typed')
     assert.equal(await revision(), start, 'nothing written yet')
     await page().keyboard.press('Enter')
     await sleep(400)
@@ -343,20 +357,20 @@ describe('values in hand on the properties tab: drawn at once, written on change
 
   test('once written, the value in hand is let go: undone, the canvas draws the figure as it stands', async () => {
     await press(...UNDO)
-    assert.equal(await read(() => probe.value('box.size.x')), 400, 'undone')
-    assert.equal((await look('box')).size[0], 400, 'drawn as it stands, not as last typed')
+    assert.equal(await read(() => probe.value('box.position.x')), 0, 'undone')
+    assert.equal(await across(), was, 'drawn as it stands, not as last typed')
   })
 
   test('a label dragged sideways scrubs the value: drawn while held, one step on release', async () => {
     const start = await revision()
-    const label = await read(() => editing.fieldLabel('box.size.x'))
-    assert.ok(label, 'the X of the size row')
-    const held = await drag(label, 60, async () => ({ drawn: (await look('box')).size[0], shown: await read(() => editing.fieldValue('box.size.x')), revision: await revision() }))
-    assert.equal(held.drawn, 460, 'one millimetre a pixel at 400 mm')
-    assert.equal(held.shown, '460', 'the field follows')
+    const label = await read(() => editing.fieldLabel('box.position.x'))
+    assert.ok(label, 'the X of the position row')
+    const held = await drag(label, 60, async () => ({ drawn: await across(), shown: await read(() => editing.fieldValue('box.position.x')), revision: await revision() }))
+    assert.equal(held.drawn, was + 60, 'one millimetre a pixel near 0 mm')
+    assert.equal(held.shown, '60', 'the field follows')
     assert.equal(held.revision, start, 'nothing written while held')
     assert.equal(await revision(), start + 1, 'the release is one step')
-    assert.equal(await read(() => probe.value('box.size.x')), 460)
+    assert.equal(await read(() => probe.value('box.position.x')), 60)
   })
 })
 

package/test/browser/links.check.mjs

@@ -88,7 +88,9 @@ async function pick(part) {
   await click(await read(id => probe.row(id), part), `the row of ${part}`)
   await until(id => probe.state().selected === id, [part], `${part} selected`)
 }
-const tab = name => read(l => probe.tab(l), `figure.label.tab-short-${name}`).then(point => click(point, `the ${name} tab`))
+/* A side tab by its short name; with a part chosen, 「반응형」 is named 「배치」 (figure.label.tab-arrangement). */
+const tab = name =>
+  read(n => probe.tab(`figure.label.tab-short-${n}`) ?? (n === 'response' ? probe.tab('figure.label.tab-arrangement') : null), name).then(point => click(point, `the ${name} tab`))
 /** A fastening the part has is said in one line; 「바꾸기」 opens the fastening window on it. */
 async function changeFastening() {
   await until(() => look.all('button[change-fastening]').length === 1, [], 'the fastening said in one line')
@@ -100,7 +102,15 @@ const targets = () => read(() => probe.fastenTargets())
 const windowOpen = () => read(() => !!probe.fastenTargets())
 /** A row of the window's list pressed, as a hand does, and waited for as the one chosen. */
 async function aimAt(part) {
-  await click(await read(p => probe.fastenTarget(p), part), `the row of ${part} in the window`)
+  /* The window is placed after it opens: its chip is pressed where it stands still, not where it was a frame ago. */
+  let point = await read(p => probe.fastenTarget(p), part)
+  for (let i = 0; i < 20; i++) {
+    await page().evaluate(() => new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r))))
+    const now = await read(p => probe.fastenTarget(p), part)
+    if (now && point && now.x === point.x && now.y === point.y) break
+    point = now
+  }
+  await click(point, `the row of ${part} in the window`)
   await until(p => probe.fastenTargets()?.some(t => t.target === p && t.selected), [part], `${part} chosen in the window`)
 }
 /** An element handle found through every shadow root. */
@@ -189,13 +199,15 @@ describe('a size rule that would follow itself, and a fastening that would hang
     await mount('linked', fasten(a, 'b', 'a'))
   })
 
+  /* b stands on a's top: made to follow, its width takes a's width (ADR-0159 3), which follows b's. */
   test('b made to follow a\'s width: refused, said as a loop, nothing written', async () => {
     await pick('b')
-    await click(await at('details[resize-choice] > summary'), 'the advanced size choice')
+    await tab('response')
     const start = await state()
-    await choose('X', 'part:a:x', 'details[resize-choice] select')
+    await press('input[aria-label="b X figure.label.size-follows"]', undefined, 'b\'s width made to follow')
     await until(() => probe.state().error === 'figure.text.follow-would-loop', [], 'the loop said')
     assert.equal((await state()).revision, start.revision, 'nothing written')
+    await tab('properties')
   })
 
   test('a fastened to b, which hangs from it: refused, said as a loop, nothing written', async () => {
@@ -213,30 +225,36 @@ describe('a part made to follow the figure size, and let go of it', () => {
     a = applyFigureAuthoring(a, { kind: 'declare-instance-size', range: SIZE, at: { x: 400, y: 400, z: 400 } })
     await mount('sized', applyFigureAuthoring(a, { kind: 'link-dimension', part: 'box', axis: 'x', source: { of: 'instance', axis: 'x' } }))
     await pick('box')
-    /* How a part answers a size is the 「반응형」 tab's (user 2026-10-17). */
+    /* How a part answers a size is the 「반응형」 tab's (user 2026-10-17), its size editor one row a side (ADR-0159 3). */
     await tab('response')
   })
+  /* What each side's row says it follows: the source said in one line, or nothing. */
+  const sources = () => all('div.dimension[data-axis] div.source span')
+  const follows = axis => `input[aria-label="box ${axis} figure.label.size-follows"]`
 
-  test('on a figure with a size, follow-size is one step, says nothing of a size declared, and is not offered again', async () => {
+  /*
+    The one-step follow-size button is gone (2026-10-24): each side is made to follow by its own 'follows', and a box on
+    nothing follows the figure's own side.
+  */
+  test('on a figure with a size, each side made to follow is one step, follows the figure\'s own side, and says nothing of a size declared', async () => {
     await read(() => look.hear('notify'))
-    const start = await state()
-    await click(await at('button[follow-size]'), 'follow-size')
-    await oneStep(start)
-    await until(() => !look.at('button[follow-size]'), [], 'the button gone once every side follows')
-    /* Each side's row says it follows; no sentence under them says it again (user 2026-10-16). */
-    assert.equal((await all('p[hint]', 'figure.text.resize-all-following')).length, 0, 'no sentence repeats the rows')
-    assert.equal((await all('div[resize-now] span', 'figure.label.resize-following')).length, 3, 'every side said to follow, once')
+    for (const axis of ['Y', 'Z']) {
+      const start = await state()
+      await press(follows(axis), undefined, `${axis} made to follow`)
+      await oneStep(start)
+    }
+    assert.deepEqual((await sources()).map(s => s.text), ['X', 'Y', 'Z'].map(axis => `figure.label.size-figure ${axis}`), 'every side said to follow the figure, once')
     const told = (await heard('notify')).filter(n => n?.level === 'info' && String(n.message).includes('figure.text.size-declared-to-follow'))
     assert.deepEqual(told, [], 'the figure had its size: no line says it was declared')
   })
 
   test('a side let go is one step and keeps the size it had', async () => {
     const start = await state()
-    await click(await at('button[resize-unfollow="x"]'), 'let go of X')
+    await press(follows('X'), undefined, 'let go of X')
     await oneStep(start)
     assert.equal(await read(() => probe.value('box.size.x')), 400, 'its own width is the 400 it was')
     assert.equal(Math.round((await read(() => probe.body('box'))).dimensions['size.x']), 400)
-    assert.ok(await at('button[follow-size]'), 'follow-size is offered again')
+    assert.deepEqual((await sources()).map(s => s.text), ['Y', 'Z'].map(axis => `figure.label.size-figure ${axis}`), 'X follows nothing')
   })
 })
 
@@ -251,7 +269,7 @@ function sizedPair(turning) {
   if (!turning) return a
   a = fasten(fasten(a, 'base', 'plane'), 'flange', 'base')
   const j = a.joints.find(o => o.body1.part === 'flange')
-  return applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'flange-turn' } } })
+  return applyFigureAuthoring(a, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'flange-turn' } }] } })
 }
 
 describe('the sizes a figure may be placed at, and how it grows', () => {
@@ -309,7 +327,7 @@ describe('a row\'s pitch', () => {
     await pick('roller')
     /* The row is the 「반응형」 tab's. */
     await tab('response')
-    assert.deepEqual((await all('input[aria-label="roller.repeat.pitch"]')).map(i => i.value), ['200'], 'a tenth of 2000')
+    assert.deepEqual((await all('input[aria-label="figure.label.repeat-gap"]')).map(i => i.value), ['200'], 'a tenth of 2000')
     assert.ok((await all('ul[row-reading] li')).length > 0, 'the row said as it stands')
   })
 
@@ -323,7 +341,7 @@ describe('a row\'s pitch', () => {
     await pick('roller')
     await tab('response')
     const start = await state()
-    await type(await handle('input[aria-label="roller.repeat.pitch"]'), '300')
+    await type(await handle('input[aria-label="figure.label.repeat-gap"]'), '300')
     await oneStep(start)
     const now = await source()
     assert.equal(now.designInputs.pitch, 300, 'the input is 300')
@@ -508,7 +526,7 @@ describe('past the edge of the face a part is fastened to', () => {
     a = fasten(box(a, 'out', [100, 100, 100]), 'out', 'frame', { align: { x: { mm: 480 } } })
     const mesh = { asset: 'a'.repeat(64), format: 'glb', unit: 'mm', bounds: { min: { x: -50, y: -50, z: -50 }, max: { x: 50, y: 50, z: 50 } }, triangles: 12, primitives: 1 }
     a = addFigurePrimitive(a, { id: 'tilted', kind: 'mesh', dimensions: { size: 100 }, mesh, position: { x: 0, y: 0, z: 0 } })
-    a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'tilted', type: 'fixed', body0: { part: 'frame', face: 'top' }, body1: { part: 'tilted' }, origin: { align: { x: { mm: 460 } }, childRotate: { y: 30 } } } })
+    a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'tilted', body0: { part: 'frame', face: 'top' }, body1: { part: 'tilted' }, origin: { align: { x: { mm: 460 } }, childRotate: { y: 30 } } } })
     a = fasten(addFigurePrimitive(a, { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 200 }, position: { x: 0, y: 0, z: 0 } }), 'drum', 'frame')
     a = fasten(box(a, 'cap', [50, 50, 50]), 'cap', 'drum', { align: { x: { mm: 70 }, z: { mm: 70 } } })
     await mount('overhangs', fasten(box(a, 'plate', [1600, 20, 200]), 'plate', 'frame', { align: { x: { mm: 200 } } }))
@@ -593,11 +611,12 @@ describe('a bench: what each part is fastened to, what detaching would do, a row
     assert.deepEqual(await all('[detach-words]'), [])
   })
 
-  test('a part fastened to nothing: the row is folded under its head and says why', async () => {
+  /* A row that cannot be made says why open, under a head that says it is not made (2026-10-24). */
+  test('a part fastened to nothing: the row stands open under its head and says why', async () => {
     await pick('loose')
     await tab('response')
-    assert.deepEqual((await all('details[row-fold] > summary h3')).map(h => h.text), ['figure.label.repeat'])
-    assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [false], 'folded')
+    assert.deepEqual((await all('details[row-fold] > summary h3')).map(h => h.text), ['figure.label.repeat figure.label.repeat-inactive'])
+    assert.deepEqual((await all('details[row-fold]')).map(d => d.open), [true], 'open')
     assert.deepEqual((await all('p[row-blocked]')).map(p => p.text), ['figure.text.row-blocked-unfastened'])
   })
 

package/test/browser/modeller-page.js

@@ -83,7 +83,7 @@ function sourceOf(kind, text) {
     /* On the roller's side at 0° round its own Y -- its own +X (ADR-0140 3.9). */
     asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'mark', to: { part: 'roller', surface: { around: 0, along: 'centre' } } })
     const j = asset.joints.find(o => o.body1.part === 'roller')
-    asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Z', lowerLimit: -360, upperLimit: 360, state: { id: 'spin' } } })
+    asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -360, upperLimit: 360, state: { id: 'spin' } }] } })
     return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 200 }))
   }
   throw Error(`no figure for ${kind}`)