@things-factory/figure-ui 10.1.245 → 10.1.247

package/test/browser/screen.check.mjs

@@ -651,6 +651,49 @@ describe('the preview: registered as a board registers it, posed and played, the
     assert.ok(given.every(v => v === now.value), `each given the speed shown: ${given}`)
   })
 
+  test('an angle slides by a degree, and a value typed is given as typed (robot dog, 2026-11-03)', async () => {
+    const step = await read(() => screenCheck.previewControl('j2-shoulder').querySelector('input[type=range]').step)
+    assert.equal(step, '1', 'a degree, not a hundredth of the range')
+    const typed = await element('the shoulder typed', () => screenCheck.previewControl('j2-shoulder').querySelector('input[typed]'))
+    await typed.click({ clickCount: 3 })
+    await page().keyboard.type('37')
+    await page().keyboard.press('Enter')
+    await until('given', () => screenCheck.deep('figure-preview')[0].scene.root.components.every(c => c.state.parameters?.['j2-shoulder'] === 37))
+  })
+
+  test('a clip played lets go of the value tried on the control it drives; the default pose lets go of every one', async () => {
+    const given = () => read(() => screenCheck.deep('figure-preview')[0].scene.root.components.map(c => ({ ...(c.state.parameters ?? {}) })))
+    const base = await element('the base', () => screenCheck.previewControl('j1-base').querySelector('input[type=range]'))
+    await base.focus()
+    for (let i = 0; i < 5; i++) await page().keyboard.press('ArrowRight')
+    await until('tried', () => screenCheck.deep('figure-preview')[0].scene.root.components.every(c => c.state.parameters?.['j1-base'] !== undefined))
+    /* The cycle drives j1-base; it is played (its speed above 0 since the test before). */
+    const speed = await element('the clip\'s speed', () => screenCheck.previewControl('cycle').querySelector('input[type=range]'))
+    await speed.focus()
+    await page().keyboard.press('ArrowRight')
+    await until('let go', () => screenCheck.deep('figure-preview')[0].scene.root.components.every(c => c.state.parameters?.['j1-base'] === undefined))
+    assert.ok((await given()).every(p => p['j2-shoulder'] === 37), 'a control the clip does not drive keeps its value')
+    await press('back to the default pose', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[clear-tried]'))
+    await until('all let go', () => screenCheck.deep('figure-preview')[0].scene.root.components.every(c => Object.keys(c.state.parameters ?? {}).length === 0))
+    assert.equal(await read(() => !!screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[clear-tried]')), false, 'nothing left to clear')
+  })
+
+  test('the preview looks from the front, the side or above, and its controls fold out of the way (robot dog, 2026-11-03)', async () => {
+    /* What the preview's camera is, read in the page. */
+    const square = () => !!screenCheck.deep('figure-preview')[0].scene.root.activeCamera3d?.isOrthographicCamera
+    assert.equal(await read(square), false, 'it starts in perspective')
+    await press('the front view', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[view=front]'))
+    await until('square on', square)
+    assert.equal(await read(() => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[view=front]').getAttribute('aria-pressed')), 'true')
+    await press('the perspective', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[view=perspective]'))
+    await until('perspective again', () => !screenCheck.deep('figure-preview')[0].scene.root.activeCamera3d?.isOrthographicCamera)
+    await press('fold the controls', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[fold-controls]'))
+    await until('folded', () => !screenCheck.previewControl('j1-base'))
+    assert.ok(await read(() => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('div[clips] button[fold-controls]')), 'the one button stays')
+    await press('unfold the controls', () => screenCheck.deep('figure-preview')[0].shadowRoot.querySelector('button[fold-controls]'))
+    await until('back', () => !!screenCheck.previewControl('j1-base'))
+  })
+
   test('narrow (1024 wide and less, both sides open), the size help and the controls share the bottom row without covering each other', async () => {
     const viewport = page().viewport()
     await page().setViewport({ width: 1024, height: 768 })
@@ -885,7 +928,17 @@ describe('the side panel is found as it was left, per part', () => {
     await pressRow('forearm')
     await until('forearm chosen, at its top', () => screenCheck.editor().selected === 'forearm' && screenCheck.shownPanel().scrollTop === 0)
     await pressRow('upper-arm')
-    await until('upper-arm as it was left', top => screenCheck.editor().selected === 'upper-arm' && Math.abs(screenCheck.shownPanel().scrollTop - top) <= 2, top)
+    /* Said with the numbers when it does not come back: where the panel stands, where it was left, how tall it is. */
+    const back = top => {
+      const panel = screenCheck.shownPanel()
+      return { selected: screenCheck.editor().selected, scrollTop: Math.round(panel.scrollTop), top, scrollHeight: panel.scrollHeight, clientHeight: panel.clientHeight }
+    }
+    let seen
+    for (const end = Date.now() + 8000; Date.now() < end; await new Promise(done => setTimeout(done, 50))) {
+      seen = await read(back, top)
+      if (seen.selected === 'upper-arm' && Math.abs(seen.scrollTop - top) <= 2) break
+    }
+    assert.ok(seen.selected === 'upper-arm' && Math.abs(seen.scrollTop - top) <= 2, `upper-arm as it was left: ${JSON.stringify(seen)}`)
     assert.deepEqual(await folds(), opened, 'its folds as they were')
   }
 })

package/test/browser/section-page.js

@@ -31,6 +31,8 @@ const FIGURES = {
   },
   pyramid: () => applyFigureAuthoring(polygon(figure('Pyramid'), 'wedge', TRIANGLE), { kind: 'set-section', part: 'wedge', apex: { x: 0, z: 0 } }),
   /* A box standing on the floor: a length change keeps its bottom. */
+  /* An elbow pipe (ADR-0100 §16.2): up, a quarter bend toward +X, along. */
+  pipe: () => addFigurePrimitive(figure('Pipe'), { id: 'pipe', kind: 'pipe', dimensions: { radius: 50, wall: 5 }, path: [{ line: 400 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 300 }], position: { x: 0, y: 0, z: 0 } }),
   'floor-box': () => applyFigureAuthoring(addFigureBox(figure('Floor'), { id: 'box', size: { x: 400, y: 200, z: 300 }, position: { x: 0, y: 100, z: 0 } }), { kind: 'set-placement', placement: 'floor' }),
   /* A box whose sizes follow the figure's: none of them is its own to set. */
   follows: () => applyFigureAuthoring(addFigureBox(figure('Follows'), { id: 'box', size: { x: 400, y: 400, z: 400 }, position: { x: 0, y: 200, z: 0 } }), { kind: 'follow-size', part: 'box' }),
@@ -89,7 +91,9 @@ const shapeWords = shape => {
     section: drawn ? JSON.parse(JSON.stringify(drawn.section)) : null,
     apex: shape.loft?.apex ?? null,
     length: drawn ? Math.round(drawn.end - drawn.start) : null,
-    cavity: shape.cavity ? JSON.parse(JSON.stringify({ wall: shape.cavity.wall, start: shape.cavity.start, end: shape.cavity.end })) : null
+    cavity: shape.cavity ? JSON.parse(JSON.stringify({ wall: shape.cavity.wall, start: shape.cavity.start, end: shape.cavity.end })) : null,
+    top: shape.loft?.to ? JSON.parse(JSON.stringify(shape.loft.to)) : null,
+    pipe: shape.sweep ? JSON.parse(JSON.stringify({ section: shape.sweep.section, to: shape.sweep.to ?? null, wall: shape.sweep.wall ?? null, path: shape.sweep.path })) : null
   }
 }
 const box = element => {
@@ -116,6 +120,7 @@ Object.assign(window.probe, {
     const shown = e => !!e && getComputedStyle(e).display !== 'none'
     const length = root.querySelector('div[sizes] label[mm]')
     const apex = root.querySelector('label[apex]')
+    const top = root.querySelector('label[top]')
     return {
       caption: words(caption),
       lastValid: !!caption?.hasAttribute('last-valid'),
@@ -126,6 +131,7 @@ Object.assign(window.probe, {
       note: words(root.querySelector('small[role=status]')),
       length: length ? { label: words(length.querySelector('span')), disabled: length.querySelector('input').disabled, note: words(length.querySelector('small')) } : null,
       apex: apex ? { checked: apex.querySelector('input').checked, disabled: apex.querySelector('input').disabled, words: words(apex.querySelector('small')) } : null,
+      top: top ? { checked: top.querySelector('input').checked, disabled: top.querySelector('input').disabled, words: words(top.querySelector('small')) } : null,
       narrow: host.hasAttribute('narrow'),
       show: host.getAttribute('show'),
       tabs: shown(root.querySelector('nav[tabs]')),

package/test/browser/section.check.mjs

@@ -418,6 +418,87 @@ describe('a drawn section\'s end drawn to one point', () => {
   })
 })
 
+describe('a box\'s top another size: a tapered box (ADR-0100 §16.1, robot dog 2026-11-03)', () => {
+  test('turned on, its top\'s width typed and applied is one step; turned off, a box again', async () => {
+    await mount('floor-box')
+    await pick('box')
+    await openEditor()
+    assert.deepEqual((await editorNow()).top, { checked: false, disabled: false, words: '' })
+    await press('label[top] input', { within: 'figure-section-editor' })
+    await until(() => probe.sectionEditor().top.checked, 'the top on')
+    /* The length, the two widths across, then the top's two widths and its corner. */
+    await type('div[sizes] label[mm] input', { within: 'figure-section-editor', index: 3 }, '200', 'Tab')
+    const start = await state()
+    await press('footer button', { within: 'figure-section-editor', text: 'figure.button.section-editor-apply' })
+    await until(r => probe.state().revision === r + 1, 'one step', start.revision)
+    const now = await held('box')
+    assert.equal(now.top.size.x, 200)
+    assert.equal(now.section.size.x, 400, 'the bottom as it was')
+    await until(() => probe.drawnShape('box')?.top?.size?.x === 200, 'drawn tapered')
+    await openEditor()
+    await until(() => probe.sectionEditor()?.top?.checked, 'opened again with its top on')
+    await press('label[top] input', { within: 'figure-section-editor' })
+    await press('footer button', { within: 'figure-section-editor', text: 'figure.button.section-editor-apply' })
+    await until(r => probe.state().revision === r + 2, 'one step back', start.revision)
+    assert.equal((await held('box')).top, null)
+  })
+})
+
+describe('a pipe\'s panel: its wall, its pieces, each change one step (ADR-0100 §16.2)', () => {
+  before(async () => {
+    await mount('pipe')
+    await pick('pipe')
+    await until(() => !!findDeep('figure-pipe-panel'), 'the pipe panel')
+  })
+  const pipeNow = async () => (await held('pipe')).pipe
+  const step = async (what, act) => {
+    const start = await state()
+    await act()
+    await until(r => probe.state().revision === r + 1, what, start.revision)
+  }
+
+  test('a wall of 0 is a solid bar', async () => {
+    await step('the wall', () => type('input[aria-label="figure.label.pipe-wall"]', { within: 'figure-pipe-panel' }, '0'))
+    assert.equal((await pipeNow()).wall, null)
+  })
+
+  test('a bend added is the path\'s last piece; its direction chosen, then taken away again', async () => {
+    await step('a bend added', () => press('button[add-bend]', { within: 'figure-pipe-panel' }))
+    const added = await pipeNow()
+    assert.equal(added.path.length, 4)
+    assert.deepEqual(added.path[3], { kind: 'bend', radius: 100, angle: 90, toward: 0 })
+    /* The second piece's bend turns toward +X; its quarters are said as the figure's axes it turns to there. */
+    const words = await read(() => [...findDeep('figure-pipe-panel').shadowRoot.querySelectorAll('ol[pieces] li')[1].querySelectorAll('select option')].map(o => o.textContent.trim()))
+    assert.deepEqual(words, ['+Z', '+X', '−Z', '−X'])
+    await step('its direction', () =>
+      read(() => {
+        const select = findDeep('figure-pipe-panel').shadowRoot.querySelectorAll('ol[pieces] li')[1].querySelector('select')
+        select.value = '270'
+        select.dispatchEvent(new Event('change'))
+      })
+    )
+    assert.equal((await pipeNow()).path[1].toward, 270)
+    await step('the last piece taken away', () => read(() => [...findDeep('figure-pipe-panel').shadowRoot.querySelectorAll('ol[pieces] li button[act]')].at(-1).click()))
+    assert.equal((await pipeNow()).path.length, 3)
+  })
+
+  /* ADR-0100 §16.2.9: thick below and thin above, one pipe. */
+  test('an end diameter typed narrows it toward its end; 「one size all along」 makes it one size again', async () => {
+    await step('the end diameter', () => type('input[aria-label="figure.label.pipe-end-diameter"]', { within: 'figure-pipe-panel' }, '40'))
+    assert.deepEqual((await pipeNow()).to, { kind: 'ellipse', radius: { x: 20, z: 20 } })
+    await step('one size again', () => press('button[end-same]', { within: 'figure-pipe-panel' }))
+    assert.equal((await pipeNow()).to, null)
+  })
+
+  test('a bend tighter than the pipe is refused, said with the radius it takes', async () => {
+    const start = await state()
+    await type('input[aria-label="figure.label.pipe-bend-radius"]', { within: 'figure-pipe-panel' }, '30')
+    await until(() => probe.state().error !== '', 'the refusal said')
+    assert.equal((await state()).revision, start.revision, 'nothing written')
+    assert.equal((await state()).error, 'figure.text.pipe-bend-tight')
+  })
+})
+
 describe('the inside in the section editor: drawn on the widths being typed, sent with them in one step', () => {
   before(async () => {
     await mount('tray')

package/test/browser/side-panel-sweep.check.mjs

@@ -179,4 +179,17 @@ describe('the preview', () => {
     assert.equal(looks[0].radius, '5px')
     assert.notEqual(looks[0].background, 'rgb(239, 239, 239)')
   })
+  /* Robot dog 2026-11-03: with the data tab's sample on, a field it gives changed nothing and said nothing. */
+  test('a value the sample gives is shown as the sample\'s, not offered as a field; the sample off, the field is back', async () => {
+    const rows = () => read(DEEP => {
+      const root = eval(DEEP)('figure-preview')[0].shadowRoot
+      return { fields: root.querySelectorAll('div[clips] input, div[clips] select').length, sampled: [...root.querySelectorAll('div[clips] label[sampled] output')].map(o => o.textContent.trim()) }
+    }, DEEP)
+    await read(DEEP => (eval(DEEP)('figure-preview')[0].sample = { A: 4 }), DEEP)
+    await until(DEEP => eval(DEEP)('figure-preview')[0].shadowRoot.querySelector('div[clips] label[sampled]'), [DEEP], 'the sampled row')
+    assert.deepEqual(await rows(), { fields: 1, sampled: ['4'] }, 'A from the sample, CARRIERSTATUS still a field')
+    await read(DEEP => (eval(DEEP)('figure-preview')[0].sample = null), DEEP)
+    await until(DEEP => !eval(DEEP)('figure-preview')[0].shadowRoot.querySelector('div[clips] label[sampled]'), [DEEP], 'the field back')
+    assert.deepEqual(await rows(), { fields: 2, sampled: [] })
+  })
 })

package/test/clips.test.ts

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url'
 import { addFigureBox, applyFigureAuthoring, createFigureAsset, editFigurePart } from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 
-import { clipsOf, poseAt, trackEdit, undrivenOf, withKey, withoutKey } from '../client/modeller/clips.ts'
+import { clipsOf, poseAt, trackEdit, undrivenOf, withKey, withKeyChanged, withoutKey } from '../client/modeller/clips.ts'
 import { moving } from './joints.ts'
 
 const read = (path: string) => readFileSync(fileURLToPath(new URL(path, import.meta.url)), 'utf8')
@@ -62,3 +62,32 @@ test('움직임 탭에 서고, 막대는 입력 한 묶음 · 나머지는 부
     for (const key of keys) assert.ok(table[key], `${lang}: ${key}`)
   }
 })
+
+test('키는 그 자리에서 시각과 값을 고친다 — 첫 키는 0초, 클립 밖·다른 키와 같은 시각은 거절 (제안 18, 2026-11-03)', () => {
+  const keys = [{ seconds: 0, value: 0 }, { seconds: 1, value: 30 }, { seconds: 2, value: 60 }]
+  assert.deepEqual(withKeyChanged(keys, 1, { value: 45 }, 2), [{ seconds: 0, value: 0 }, { seconds: 1, value: 45 }, { seconds: 2, value: 60 }])
+  assert.deepEqual(withKeyChanged(keys, 1, { seconds: 1.37 }, 2)!.map(k => k.seconds), [0, 1.37, 2], '1% 눈금에 매이지 않는다')
+  assert.deepEqual(withKeyChanged(keys, 2, { seconds: 0.5 }, 2)!.map(k => k.value), [0, 60, 30], '시각 순서로 다시 선다')
+  assert.equal(withKeyChanged(keys, 0, { seconds: 0.2 }, 2), null, '첫 키는 0초')
+  assert.equal(withKeyChanged(keys, 1, { seconds: 2 }, 2), null, '다른 키의 시각')
+  assert.equal(withKeyChanged(keys, 1, { seconds: 3 }, 2), null, '클립 밖')
+  assert.equal(withKeyChanged(keys, 1, { value: NaN }, 2), null)
+  assert.deepEqual(withKeyChanged(keys, 0, { value: 10 }, 2)![0], { seconds: 0, value: 10 }, '첫 키의 값은 고친다')
+})
+
+/* Robot dog 2026-11-03: a curve given to another control on its own beat, a clip copied to be timed apart. */
+test('a track copied onto another control a while later; a clip copy takes a free name', async () => {
+  const { copiedTrackEdit, copyTargetsOf, freeClipNameOf, shiftable } = await import('../client/modeller/clips.ts')
+  let asset = editFigurePart(machine(), { kind: 'set-driver', state: 'spin', clip: 'turn', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 1, value: 90 }, { seconds: 2, value: 0 }] })
+  const clip = clipsOf(asset)[0]!
+  const track = clip.tracks[0]!
+  assert.deepEqual(copyTargetsOf(asset, 'turn'), ['spin', 'shift'], 'its own control, then those it may take')
+  assert.ok(shiftable(track))
+  const onto = copiedTrackEdit(asset, clip, track, 'shift', 0.5)
+  assert.equal(onto.state, 'shift')
+  assert.deepEqual(onto.keys[0], { seconds: 0, value: 45 }, 'half a second later it starts half way up')
+  asset = editFigurePart(asset, onto)
+  assert.deepEqual(clipsOf(asset)[0]!.tracks.map(t => t.state).sort(), ['shift', 'spin'])
+  assert.equal(freeClipNameOf(asset, 'turn'), 'turn-copy')
+  assert.equal(freeClipNameOf(editFigurePart(asset, { kind: 'set-clip', clip: 'turn', name: 'turn-copy' }), 'turn-copy'), 'turn-copy-copy')
+})

package/test/data-motion.test.ts

@@ -308,7 +308,9 @@ test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () =>
   assert.match(clips, /kind: 'remove-driver', state: track\.state, clip: clip\.name/)
   /* A key's value is shown to three decimals: a slider's 14.399999999999999 is not what a person typed. */
   assert.match(clips, /value: current === undefined \? '' : shown\(current\)/)
-  assert.match(clips, /\$\{key\.seconds\}s → \$\{shown\(key\.value\)\}/)
+  /* Typed in its chip since 2026-11-03: the field holds the value to a thousandth, with no grouping. */
+  assert.match(clips, /const typed = \(value: number\) => String\(Math\.round\(value \* 1000\) \/ 1000\)/)
+  assert.match(clips, /\.value=\$\{typed\(key\.value\)\}/)
   const keys = [read('../client/modeller/figure-data-panel.ts'), clips, read('../client/modeller/refusals.ts')].flatMap(src =>
     [...src.matchAll(/'(figure\.[a-z.-]*[a-z])'/g)].map(m => m[1]!)
   )
@@ -340,3 +342,14 @@ test('데이터 탭 · 클립 패널 · 미리보기의 배선과 문구', () =>
     for (const key of made) assert.ok(table[key], `${lang}: ${key}`)
   }
 })
+
+/* Robot dog 2026-11-03: what the sample gives a row is what the figure shows; the preview says so. */
+test('the value data gives a row is read down its accessor; left out or null, there is none', async () => {
+  const { dataValueAt } = await import('../client/modeller/data-interface.ts')
+  const data = { status: 'ALARM', arm: { joints: [{ angle: 30 }] }, off: null }
+  assert.equal(dataValueAt(data, 'status'), 'ALARM')
+  assert.equal(dataValueAt(data, 'arm.joints[0].angle'), 30)
+  assert.equal(dataValueAt(data, 'off'), undefined)
+  assert.equal(dataValueAt(data, 'missing.deep'), undefined)
+  assert.equal(dataValueAt(null, 'status'), undefined)
+})

package/test/fasten-geometry.test.ts

@@ -8,10 +8,10 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { addFigureBox, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
 import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
 
-import { alignmentAt, faceViewOf, offsetOf, overhangOf, screenOf } from '../client/modeller/fasten-geometry.ts'
+import { alignmentAt, 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 => {
@@ -86,3 +86,14 @@ test('the drawing\'s two names do not lie over each other (user 2026-10-16: 「r
   /* A face that fills the drawing: its name inside its top edge. */
   assert.deepEqual(fastenLabelsOf({ x: 4, y: 4, w: 300, h: 170 }, { x: 100, y: 60, w: 100, h: 40 }, 'lid', 180).face, { x: 8, y: 18 })
 })
+
+test('붙일 면 그림은 그려진 자세대로 — 눕힌 원기둥의 위·아래 면은 옆에 서고, 화면의 위는 면이 아니다 (로봇개, 2026-11-03)', () => {
+  const upright = revisionOf(scene())
+  assert.deepEqual(facesAsDrawnOf(upright, 'bin'), { left: 'left', right: 'right', bottom: 'bottom', top: 'top', back: 'back', front: 'front' }, '돌지 않았으면 제 이름 그대로')
+  const laid = revisionOf(addFigurePrimitive(createFigureAsset('Laid'), { id: 'drum', kind: 'cylinder', dimensions: { radius: 100, length: 400 }, position: { x: 0, y: 500, z: 0 }, rotation: { x: 0, y: 0, z: 90 } } as never))
+  const drawn = facesAsDrawnOf(laid, 'drum')
+  /* Turned 90° about Z: its own top points along -X, its own bottom along +X. */
+  assert.deepEqual([drawn.left, drawn.right], ['top', 'bottom'])
+  assert.ok(!['top', 'bottom'].includes(drawn.top) && !['top', 'bottom'].includes(drawn.bottom), `화면의 위·아래는 원기둥의 면이 아니다: ${drawn.top}, ${drawn.bottom}`)
+  assert.deepEqual([drawn.front, drawn.back], ['front', 'back'])
+})

package/test/joint-frames.test.ts

@@ -13,6 +13,7 @@ import { jointAxisUnit, jointAxisWord } from '../client/modeller/joint-axis.ts'
 import { alignOf, endPlaceKeyOf, fasteningOf, fixedJointOf, motionFormOf, motionFormRefusalOf, motionJoint, motionOf, rowAxesOf, rowBlockOf } from '../client/modeller/links.ts'
 import { jointDragOf } from '../client/modeller/joint-drag.ts'
 import { jointFanOf } from '../client/modeller/joint-fan.ts'
+import { defaultsMovedOf } from '../client/modeller/refusals.ts'
 import { revisionOf } from './revision-of.ts'
 
 type Dynamic = any
@@ -147,9 +148,18 @@ test('a range need not hold 0; it needs its most above its least', () => {
   const fixed = jointOf(still, 'link')
   const lifted = set(still, motionJoint(fixed, { ...motionFormOf(fixed), kind: 'turn', min: 10, max: 90 }, 'link'))
   assert.equal(lifted.stateDefaults[jointOf(lifted, 'link').motion[0].state.id], 10)
-  /* An existing control keeps its name and its stored value: a range that leaves that value out is the kernel's refusal (R1). */
+  /*
+    An existing control keeps its name; a range that leaves its stored value out brings the value to the nearest end, as
+    set-state-input does -- one rule for a default out of its range (2026-11-03, replacing the 10-04 refusal). The screen
+    says it moved (\`defaultsMovedOf\`).
+  */
   const j = jointOf(plain(), 'link')
-  assert.throws(() => set(plain(), motionJoint(j, { ...motionFormOf(j), min: 10, max: 90 }, 'link')), /INPUT_RANGE/)
+  const id = motionFormOf(j).id
+  const narrowed = set(plain(), motionJoint(j, { ...motionFormOf(j), min: 10, max: 90 }, 'link'))
+  assert.equal(motionFormOf(jointOf(narrowed, 'link')).id, id, 'the same control')
+  assert.equal(narrowed.stateDefaults[id], 10)
+  const say = (key: string, p: Record<string, string>) => `${key} ${JSON.stringify(p)}`
+  assert.equal(defaultsMovedOf(plain(), narrowed, say), `figure.text.default-moved-to-end ${JSON.stringify({ control: id, from: '0', to: '10' })}`)
 })
 
 test('old shapes: every form path writes the joint back as it was, saved and reopened', () => {

package/test/links.test.ts

@@ -757,3 +757,27 @@ test('상태에 따라 크기 — 지름으로 적은 두 끝이 반지름 명
   assert.deepEqual(stateSizeFixedOf(asset, 'wound', 'x'), { kind: 'unlink-dimension', part: 'wound', axis: 'x', mm: 450 }, '쉬는 값(100 %)의 반지름으로 고정')
   assert.equal(stateSizeFixedOf(asset, 'wound', 'y'), undefined)
 })
+
+test('축이 지나는 점 — 폼에서 정하고, 부품은 두고 축만 옮기며, 길이를 따르는 거리는 그대로 다시 쓴다 (ADR-0159, 로봇개 2026-11-03)', async () => {
+  const { motionFormOf, motionJoint } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Hip')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 400, y: 100, z: 200 }, position: { x: 0, y: 300, z: 0 } })
+  asset = addFigureBox(asset, { id: 'leg', size: { x: 40, y: 200, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leg', to: { part: 'body', face: 'bottom' } })
+  const joint = () => asset.joints!.find(j => j.body1.part === 'leg')!
+  const form = { kind: 'turn' as const, axis: 'z' as const, id: 'hip', min: -90, max: 90, follow: '', multiplier: 1, offset: 0, through: { x: 100 } }
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(joint(), form, 'leg') })
+  assert.deepEqual(joint().motion![0]!.through, { x: 100 })
+  assert.deepEqual(motionFormOf(joint()).through, { x: 100 }, '폼이 다시 읽는다')
+  const plain = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(joint(), { ...form, through: {} }, 'leg') })
+  const at = (a: FigureAsset, hip: number) => compileFigureAsset(a).evaluate({ hip }).geometry.find(g => g.id === 'leg')!.pose.t.map(v => Math.round(v))
+  assert.deepEqual(at(asset, 0), at(plain, 0), '0 에서는 축이 어디를 지나든 제자리 — 부품은 옮기지 않는다')
+  /* Turned a quarter about a point 100 mm along x, the leg swings around that point, not about the joint. */
+  assert.notDeepEqual(at(asset, 90), at(plain, 90))
+  /* A distance that follows a length is said and written back unchanged; one cleared to 0 goes. */
+  const follows = { y: { from: { of: 'part' as const, part: 'body', axis: 'y' as const }, times: 0.5 } }
+  const kept = motionJoint({ ...joint(), motion: [{ ...joint().motion![0]!, through: { x: 100, ...follows } }] }, { ...motionFormOf({ ...joint(), motion: [{ ...joint().motion![0]!, through: { x: 100, ...follows } }] }), through: { x: 0 } }, 'leg')
+  assert.deepEqual(kept.motion![0]!.through, follows)
+})

package/test/material.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict'
 
 import { addFigureBox, addFigurePrimitive, compileFigureAsset, createFigureAsset, editFigurePart, figureCostOf } from '@hatiolab/figure-model'
 
-import { glowOf, materialEditOf, offeredPaletteOf } from '../client/modeller/material-edit.ts'
+import { glowOf, materialEditOf, offeredPaletteOf, ownColourOf } from '../client/modeller/material-edit.ts'
 
 const probe = () => {
   let asset = createFigureAsset('Probe')
@@ -68,3 +68,17 @@ test('자산에 없는 색 역할은 그 색을 함께 보낸다 — 새 피규
   const own = materialEditOf('body', { token: 'palette.accent' }, { token: 'palette.primary' }, asset.palette, offered)
   assert.equal('palette' in own, false, '자산에 있는 색이면 보낼 것이 없다')
 })
+
+test('직접 정한 색은 그 값으로 이름 붙어 자산 팔레트에 함께 들어가고, 테마 역할이 아니다 (로봇개 노랑, 2026-11-03)', () => {
+  const asset = probe()
+  const { token, colour } = ownColourOf('#FFD400')
+  assert.deepEqual([token, colour], ['colour.ffd400', '#ffd400'])
+  const edit = materialEditOf('body', { token: 'palette.primary' }, { token }, asset.palette, { ...offeredPaletteOf({}, asset.palette), [token]: colour }) as { palette?: Record<string, string> }
+  assert.deepEqual(edit.palette, { 'colour.ffd400': '#ffd400' })
+  const after = editFigurePart(asset, edit as never)
+  assert.equal(drawn(after, 'body').material.token, 'colour.ffd400')
+  assert.equal(after.palette['colour.ffd400'], '#ffd400')
+  /* The same colour again is the same entry: nothing more to add. */
+  const again = materialEditOf('drum', { token: 'palette.primary' }, { token }, after.palette, { ...offeredPaletteOf({}, after.palette), [token]: colour })
+  assert.equal('palette' in again, false)
+})

package/test/maturity.test.ts

@@ -150,7 +150,7 @@ test('여섯 축 — 정해진 순서, 잴 수 없는 둘은 비율 없이 까
   )
   const byKey = Object.fromEntries(axes.map(axis => [axis.key, axis]))
   assert.equal(byKey.detail!.ratio, undefined)
-  assert.equal(byKey.detail!.blocked, 'figure.text.maturity-blocked-no-detail-level', '디테일 등급은 이 모델에 없다(ADR-0087)')
+  assert.equal(byKey.detail!.blocked, 'figure.text.maturity-blocked-no-detail-level', '등급을 정하지 않은 피규어')
   assert.equal(byKey.reactive!.ratio, undefined)
   assert.equal(byKey.reactive!.blocked, 'figure.text.maturity-blocked-no-binding')
 
@@ -161,6 +161,24 @@ test('여섯 축 — 정해진 순서, 잴 수 없는 둘은 비율 없이 까
   assert.equal(byKey.readable!.reading, '2')
 })
 
+test('등급 충실도 — 디테일 등급을 정하면 그 등급이 허용하는 부품 수 중 쓴 비율로 잰다 (ADR-0087 등급 복귀, 로봇개 2026-11-03)', () => {
+  let asset = withPalette('palette.accent')
+  asset = addFigureBox(asset, cube('a', 50))
+  asset = addFigureBox(asset, cube('b', 150, 'palette.accent'))
+  asset = { ...asset, detailLevel: 'M' }
+  const detail = figureReportOf(asset)!.axes.find(axis => axis.key === 'detail')!
+  assert.equal(detail.blocked, undefined, 'XL·M 을 골라도 「등급이 없다」고 하지 않는다')
+  assert.equal(detail.ratio, 2 / 8)
+  assert.equal(detail.reading, '2/8')
+})
+
+test('무제한 등급은 부품 수를 재지 않는다고 말한다 — 등급이 없다고 하지 않는다 (사용자 2026-11-03)', () => {
+  let asset = withPalette('palette.accent')
+  asset = addFigureBox(asset, cube('a', 50))
+  const detail = figureReportOf({ ...asset, detailLevel: 'UNLIMITED' })!.axes.find(axis => axis.key === 'detail')!
+  assert.deepEqual([detail.ratio, detail.blocked], [undefined, 'figure.text.maturity-blocked-unlimited'])
+})
+
 test('재질이 한도를 넘으면 일관성이 한 칸 내려간다 — 셋 중 하나', () => {
   let asset = withPalette('t1', 't2', 't3')
   asset = addFigureBox(asset, cube('a', 0))

package/test/palette-icons.test.ts

@@ -13,8 +13,9 @@ import { fileURLToPath } from 'node:url'
 /**
  * Measured in the app's icon font on :3300, 2026-09-24: each draws one cell wide. `wall` drew 52px -- its letters.
  * 2026-09-30: `details` (the pyramid) 24px at 24px; `pyramid` is not in the font (168px).
+ * 2026-11-03: `conversion_path` (the pipe) 24px in the app's font file, material-symbols 0.28.2 outlined, at 24px.
  */
-const RENDERS = new Set(['deployed_code', 'database', 'crop_square', 'circle', 'change_history', 'hexagon', 'details', 'check_box_outline_blank', 'crop_portrait', 'door_front'])
+const RENDERS = new Set(['deployed_code', 'database', 'crop_square', 'circle', 'change_history', 'hexagon', 'details', 'check_box_outline_blank', 'crop_portrait', 'door_front', 'conversion_path'])
 
 test('every shape in the palette has an icon the font draws', () => {
   const parts = readFileSync(fileURLToPath(new URL('../client/modeller/figure-parts.ts', import.meta.url)), 'utf8')

package/test/pipe-panel.test.ts

@@ -0,0 +1,33 @@
+/*
+ * **관 패널** (ADR-0100 §16.2, 로봇개 11-03 · 사용자 「파이프같은 경우가 많이 활용될 것 같으니까」).
+ *
+ * 굽는 방향은 커널의 「단면 첫 축에서 잰 각도」로 저장되지만, 화면은 그 자리에서 실제로 꺾이는 축(+X 쪽)으로 말한다.
+ * 굽힘마다 그 굽힘이 시작하는 자리의 단면 축을 커널이 놓은 스테이션에서 읽는다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { addFigurePrimitive, applyFigureAuthoring, compileFigureAsset, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureEvaluatedShape } from '@hatiolab/figure-model'
+
+import { bendWordOf, piecesOf } from '../client/modeller/pipe-path.ts'
+
+const PATH = [{ line: 200 }, { bend: { radius: 100, angle: 90, toward: 90 } }, { line: 200 }, { bend: { radius: 100, angle: 90, toward: 0 } }]
+const pipe = (path = PATH): FigureAsset =>
+  addFigurePrimitive(createFigureAsset('P'), { id: 'pipe', kind: 'pipe', dimensions: { radius: 25, wall: 3 }, path, position: { x: 0, y: 0, z: 0 } })
+const sweepOf = (a: FigureAsset) => (compileFigureAsset(a).evaluate().geometry.find(g => (g as { id: string }).id === 'pipe') as unknown as { shape: FigureEvaluatedShape }).shape.sweep!
+
+test('a bend says the axis it turns to there: the first, up Y, toward +X; the second, heading +X, as its section lies then', () => {
+  const sweep = sweepOf(pipe())
+  assert.equal(bendWordOf(sweep, 0, 90), '', 'a run has none')
+  assert.deepEqual([0, 90, 180, 270].map(t => bendWordOf(sweep, 1, t)), ['+Z', '+X', '−Z', '−X'])
+  /* Heading +X after the first bend, its section's axes are turned with it: toward 0 is still +Z, 90 is now −Y. */
+  assert.deepEqual([0, 90, 180, 270].map(t => bendWordOf(sweep, 3, t)), ['+Z', '−Y', '−Z', '+Y'])
+  assert.equal(bendWordOf(sweep, 1, 45), '', 'between the axes: no word')
+})
+
+test('the path as set-pipe takes it, read back from the shape: the same pieces', () => {
+  assert.deepEqual(piecesOf(sweepOf(pipe())), PATH)
+  const longer = applyFigureAuthoring(pipe(), { kind: 'set-pipe', part: 'pipe', path: [...PATH, { line: 50 }] })
+  assert.deepEqual(piecesOf(sweepOf(longer)), [...PATH, { line: 50 }])
+})

package/test/refusals.test.ts

@@ -14,6 +14,7 @@ import * as fm from '@hatiolab/figure-model'
 import type { FigureAsset } from '@hatiolab/figure-model'
 import {
   clipLossOf,
+  defaultsMovedOf,
   editRefusalOf,
   inputRangeRefusalOf,
   partNameRefusalOf,
@@ -216,6 +217,22 @@ test('기즈모로 옮길 수 없는 부품 — 관절이 자리를 정하는지
   assert.equal(placedRefusalOf(refusalOf(() => act(conveyor(), { kind: 'set-repeat', part: 'frame', pitch: 10 })), '프레임', keyed), null, '다른 EDIT_TARGET 은 이 말이 아니다')
 })
 
+test('코드로만 보이던 거절 — 관절·붙임이 자리를 정함은 어느 명령에서든, 대칭 복사, 없는 값 (로봇개 견본 2026-11-03)', () => {
+  /* The same refusal as the gizmo's, reached from another command: named by the part the kernel gave, not "(EDIT_TARGET)". */
+  assert.match(editRefusalOf(refusalOf(() => act(conveyor(), { kind: 'nudge-part', part: 'roller', by: { x: 10 } })), keyed), /gizmo-joint-places .*"part":"roller"/)
+  const mirror = (asset: FigureAsset, target: string) => refusalOf(() => fm.editFigurePart(asset, { kind: 'mirror-part', target, axis: 'x' } as never))
+  assert.match(editRefusalOf(mirror(box(), 'box'), keyed), /mirror-would-overlap .*"part":"box"/)
+  let off = fm.addFigureBox(box(), { id: 'side', size: { x: 100, y: 100, z: 100 }, position: { x: 500, y: 50, z: 0 } })
+  off = fm.addFigureBox(off, { id: 'lamp', size: { x: 20, y: 20, z: 20 }, position: { x: 0, y: 0, z: 0 } })
+  off = act(off, { kind: 'attach', part: 'lamp', to: { part: 'side', face: 'top' } })
+  assert.match(editRefusalOf(mirror(off, 'lamp'), keyed), /mirror-not-symmetric .*"part":"lamp"/)
+  /* A value the figure does not have, as a fastened part's own position is not (the mirror that wrote it, before). */
+  const w = fm.createFigureEditorWorkspace(), context = w.open(fm.serializeFigureAsset(box())).context!
+  const unknown = refusalOf(() => w.apply({ context, origin: 'ui', expectedRevision: 0, changes: [{ kind: 'set-design', input: 'lamp.position.x', unit: 'mm', value: 1 }] }))
+  const said = editRefusalOf(unknown, say)
+  assert.ok(said.includes('lamp.position.x') && !said.includes('UNKNOWN_INPUT'), said)
+})
+
 test('옮겨 적은 거절 — 기록은 커널의 거절과 같은 모양이라 같은 말로 읽힌다 (ADR-0127)', () => {
   const a = act(fm.addFigureBox(fm.createFigureAsset('Post'), { id: 'post', size: { x: 100, y: 1000, z: 100 }, position: { x: 0, y: 0, z: 0 } }), {
     kind: 'attach',
@@ -326,3 +343,15 @@ test('화면은 커널의 거절 문장에 정규식을 대지 않는다 (ADR-01
   const refusals = readFileSync(join(root, 'modeller/refusals.ts'), 'utf8')
   assert.doesNotMatch(refusals, /\.message\b/, 'refusals.ts 는 문장을 읽지 않는다')
 })
+
+test('기본 자세가 새 범위 밖이라 옮겨지면 한 줄로 말한다 — 조작값, 어디서 어디로; 범위 안에서 정한 값은 말하지 않는다 (제안 6, 2026-11-03)', () => {
+  const knee = (min: number, max: number, start: number) => {
+    const a = fm.addFigureBox(fm.createFigureAsset('Knee'), { id: 'shin', size: { x: 40, y: 200, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+    a.document.model.inputs.push({ id: 'fl-knee', unit: 'deg', role: 'state', min, max } as never)
+    a.stateDefaults['fl-knee'] = start
+    return a
+  }
+  assert.equal(defaultsMovedOf(knee(-140, 0, -60), knee(0, 140, 0), say), '기본 자세 fl-knee -60 → 0(새 범위 끝)으로 옮겼습니다.')
+  assert.equal(defaultsMovedOf(knee(0, 140, 20), knee(0, 140, 60), say), '', '범위 안에서 작성자가 바꾼 값')
+  assert.equal(defaultsMovedOf(knee(0, 140, 20), knee(0, 140, 20), say), '')
+})

package/test/revision.test.ts

@@ -89,7 +89,7 @@ function selectionQuestions(shown: FigureRevision, part: string) {
   jointFanOf(shown, part)
   partSummaryOf(asset, part, key => key, 'ko')
   for (const axis of ['x', 'y', 'z'] as const) measureNow(shown, part, axis)
-  for (const axis of ['x', 'z'] as const) canMirror(shown, part, axis, reach)
+  for (const axis of ['x', 'z'] as const) canMirror(shown, part, axis)
   figurePlaneAlignChanges(asset, part)
   figureFaceOverhangOf(asset, part, shown.inputs)
   figurePartFaceOf(asset, part, 'top', shown.inputs)

package/test/section-editor.test.ts

@@ -163,7 +163,7 @@ test('사각형·원도 같은 창에서 — 폭·지름·길이를 한 명령
   const box = applyFigureAuthoring(addFigureBox(createFigureAsset('B'), { id: 'b', size: { x: 400, y: 200, z: 300 }, position: { x: 0, y: 100, z: 0 } }), { kind: 'set-placement', placement: 'floor' })
   const shape = (compileFigureAsset(box).evaluate().geometry.find(g => (g as { id: string }).id === 'b') as unknown as { shape: FigureEvaluatedShape }).shape
   const w = workingOf(shape)
-  assert.deepEqual(w, { points: [], across: { x: 400, z: 300 }, length: 200, apex: null, cavity: null })
+  assert.deepEqual(w, { points: [], across: { x: 400, z: 300 }, length: 200, apex: null, top: null, cavity: null })
   assert.deepEqual(sectionOf(shape, { ...w, across: { x: 500, z: 300 } }), { kind: 'rectangle', size: { x: 500, z: 300 } })
   assert.deepEqual(figureSectionMeasuresOf(box, 'b')!.measures, { y: 'editable', x: 'editable', z: 'editable' })
   /* The editor sends only what changed: a measure left alone may follow another value and must not be written. */
@@ -182,6 +182,22 @@ test('사각형·원도 같은 창에서 — 폭·지름·길이를 한 명령
   assert.equal(workingIssuesOf(r, { ...workingOf(r), length: 0 }).words[0]!.key, 'figure.text.section-issue-length')
 })
 
+/* ADR-0100 §16.1 (robot dog 2026-11-03): a box's top another size -- a tapered box -- is one command from the same window. */
+test('윗면 크기 바꾸기: 켜면 윗면의 크기와 모서리를 한 명령으로, 끄면 다시 상자로 — 윗면이 맞지 않으면 보내기 전에 말한다', async () => {
+  const { addFigureBox } = await import('@hatiolab/figure-model')
+  const { workingOf, workingIssuesOf } = await import('../client/modeller/section-drawing.ts')
+  const box = addFigureBox(createFigureAsset('B'), { id: 'b', size: { x: 400, y: 200, z: 300 }, position: { x: 0, y: 100, z: 0 } })
+  const shapeOf = (a: FigureAsset) => (compileFigureAsset(a).evaluate().geometry.find(g => (g as { id: string }).id === 'b') as unknown as { shape: FigureEvaluatedShape }).shape
+  const w = workingOf(shapeOf(box))
+  const top = { across: { x: 200, z: 150 }, corner: 20 }
+  const action = sectionActionOf('b', 'rectangle', w, { ...w, top })
+  assert.deepEqual(action, { kind: 'set-section', part: 'b', top })
+  const tapered = applyFigureAuthoring(box, action)
+  assert.deepEqual(workingOf(shapeOf(tapered)).top, top, 'opened again, the top as it was set')
+  assert.deepEqual(sectionActionOf('b', 'rectangle', workingOf(shapeOf(tapered)), { ...workingOf(shapeOf(tapered)), top: null }), { kind: 'set-section', part: 'b', top: null })
+  assert.equal(workingIssuesOf(shapeOf(box), { ...w, top: { across: { x: 30, z: 150 }, corner: 20 } }).words[0]!.key, 'figure.text.section-issue-top')
+})
+
 test('속 공간이 있으면 폭·길이가 그 벽과 막힌 끝을 남기는지도 커널로 묻는다', async () => {
   const { addFigureBox } = await import('@hatiolab/figure-model')
   const { workingOf, workingIssuesOf } = await import('../client/modeller/section-drawing.ts')