@things-factory/figure-ui 10.1.63 → 10.1.65

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

@@ -1,563 +0,0 @@
-/*
- * AI 후보가 저작 화면의 정본에 닿는 마지막 경계다.
- *
- * 모델의 응답은 신뢰하지 않는다. `proposal.ts`는 사람이 고른 변경만 옮기고, 저장 식별자인
- * Figure type과 이름으로 연결된 부품의 의미를 보존해야 한다. 이 순수 로직을 Lit 화면 밖에서
- * 시험해 두면 DOM 배선이 바뀌어도 후보 수락 규칙이 조용히 약해지지 않는다.
- */
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { createRequire } from 'node:module'
-import { test } from 'node:test'
-
-import { applyProposal, diffProposal, takeProposal } from '../dist-client/modeller/proposal.js'
-import { feedbackFromSession, openAiProposal, openSizingFix, toggleProposalChange } from '../dist-client/modeller/proposal-session.js'
-
-const current = () => ({
-  type: 'MIXER',
-  base: { x: 100, y: 100, z: 100 },
-  detailLevel: 'M',
-  parts: [
-    {
-      name: 'body',
-      primitive: 'cube',
-      transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } },
-      material: { token: 'palette.primary' }
-    },
-    {
-      name: 'motor',
-      primitive: 'cube',
-      transform: { position: { x: 0, y: 60, z: 0 }, size: { x: 20, y: 20, z: 20 } },
-      material: { token: 'palette.neutral' }
-    }
-  ]
-})
-
-const proposal = () => ({
-  type: 'FORKLIFT', // 모델이 이 값을 지어내도 이미 저장된 Figure의 type은 바꾸지 않는다.
-  base: { x: 200, y: 100, z: 100 },
-  detailLevel: 'L',
-  parts: [
-    {
-      name: 'body',
-      primitive: 'cube',
-      transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 200, y: 100, z: 100 } },
-      material: { token: 'palette.accent' }
-    },
-    {
-      name: 'guard',
-      primitive: 'cube',
-      transform: { position: { x: 0, y: 50, z: 0 }, size: { x: 100, y: 10, z: 10 } },
-      material: { token: 'palette.primary' }
-    }
-  ]
-})
-
-test('AI 후보는 모든 변경을 이름 단위로 드러낸다 — 사람에게 숨은 변경이 없다', () => {
-  const changes = diffProposal(current() as any, proposal() as any)
-
-  assert.deepEqual(
-    changes.map(change => `${change.kind}:${change.key}`).sort(),
-    ['added:guard', 'base:base', 'changed:body', 'detail:detailLevel', 'removed:motor']
-  )
-})
-
-test('선택하지 않은 후보 변경은 정본에 들어가지 않는다', () => {
-  const result = applyProposal(current() as any, proposal() as any, new Set(['body', 'base']))
-
-  assert.deepEqual(result.base, { x: 200, y: 100, z: 100 })
-  assert.equal(result.detailLevel, 'M')
-  assert.deepEqual(result.parts.map(part => part.name), ['body', 'motor'])
-  assert.equal(result.parts[0].material.token, 'palette.accent')
-})
-
-test('후보가 다른 type을 내도 이미 존재하는 Figure의 저장 식별자는 보존한다', () => {
-  const result = takeProposal(current() as any, proposal() as any)
-
-  assert.equal(result.type, 'MIXER')
-})
-
-test('새 Figure의 후보는 사람의 수락 전까지 입력 source를 바꾸지 않는다', () => {
-  const candidate = proposal()
-  const result = takeProposal(undefined, candidate as any)
-
-  assert.notEqual(result, candidate)
-  assert.equal(candidate.type, 'FORKLIFT')
-  assert.equal(result.type, 'FORKLIFT')
-})
-
-test('AI 후보의 검토 상태는 하나의 세션으로 열리고, 선택은 불변으로 바뀐다', () => {
-  const candidate = openAiProposal(current() as any, {
-    source: JSON.stringify(proposal()),
-    grade: 'L',
-    triangles: 42,
-    groups: 2,
-    attempts: 1,
-    quality: { status: 'ready', summary: 'ready', findings: [], visualRegions: 1, visualCoverage: 1, visualReadability: 1 }
-  } as any)
-
-  const toggled = toggleProposalChange(candidate, 'body')
-  assert.notEqual(toggled, candidate)
-  assert.equal(candidate.picked.has('body'), true)
-  assert.equal(toggled.picked.has('body'), false)
-  assert.equal(toggled.note, '')
-})
-
-test('발행 게이트 수정과 AI 후보는 같은 검토 세션 경계를 쓴다', () => {
-  const session = openSizingFix(current() as any, { part: 'body', axis: 'x', from: 'auto', to: 'max' } as any)
-  assert.equal(session?.metrics, undefined)
-  assert.equal(session?.source.parts[0].anchor?.x, 'max')
-  assert.equal(openSizingFix(current() as any, { part: 'missing', axis: 'x', to: 'max' } as any), undefined)
-})
-
-test('피드백은 후보 세션의 선택과 측정값만 전송한다', () => {
-  const session = openAiProposal(current() as any, {
-    source: JSON.stringify(proposal()),
-    grade: 'L',
-    triangles: 42,
-    groups: 2,
-    attempts: 1,
-    quality: { status: 'review', summary: 'check', findings: [{ dimension: 'shape', code: 'S1', message: 'check' }], visualRegions: 1, visualCoverage: 1, visualReadability: 1 }
-  } as any)
-  const feedback = feedbackFromSession(current() as any, { ...session, note: ' keep body ' }, 'accepted')
-  assert.deepEqual(feedback, {
-    outcome: 'accepted', selectedChanges: session.picked.size, totalChanges: session.picked.size,
-    note: 'keep body', grade: 'L', quality: { status: 'review', findingCodes: ['S1'] }
-  })
-})
-
-/*
- * The modeller opens no AI door of its own. The application header already has one and it opens the
- * same dock, and two doors to one room on one screen make a reader look for the difference between
- * them (2026-09-18, on the author's reading of the screen). `figure-ask` — a second, inline form
- * that called `proposeFigure` directly — went on 2026-09-16.
- *
- * What the page owes is unchanged and checked here: when the dock asks, it answers with the source
- * 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 요청은 JSON이 아니라 GraphQL multipart Upload 링크를 탄다', () => {
-  const path = fileURLToPath(new URL('../client/graphql/index.ts', import.meta.url))
-  const source = readFileSync(path, 'utf8')
-  const propose = source.slice(source.indexOf('export async function proposeFigure'), source.indexOf('/**\n * 발행한다'))
-
-  assert.match(propose, /context: \{ hasUpload: !!request\.image \}/)
-})
-
-/*
- * ── The whole round trip, not just one hop ───────────────────────────────────
- *
- * Everything above checks a single step. What broke on 2026-09-15 was the sequence: a candidate
- * that only added animations produced an EMPTY change list, so the take button — disabled while
- * nothing is picked — could never be pressed. The author could neither accept the candidate nor
- * get rid of it. Asking again did not help, because the second candidate had the same shape.
- *
- * `FIGURE_FIELDS` in proposal.ts decides which figure-level fields are visible at all, and it had
- * fallen behind the format: `animations`, `capabilities` and `placement` were missing, while
- * `anchor` — removed from the format on 2026-09-10 — was still listed. The tests below walk the
- * sequence an author actually performs, so a gap in that list shows up as a stuck session rather
- * than as a silently dropped field.
- */
-
-/** A candidate whose only change is movement — the shape that could not be finished. */
-const animationOnly = () => ({
-  ...current(),
-  animations: [
-    {
-      name: 'door',
-      channels: [
-        {
-          target: 'motor',
-          path: 'rotation',
-          keys: [
-            { at: 0, value: { x: 0, y: 0, z: 0 } },
-            { at: 2, value: { x: 0, y: 90, z: 0 } }
-          ]
-        }
-      ]
-    }
-  ]
-})
-
-/**
- * A candidate whose only change is a value-driven pose.
- *
- * The same shape as the movement-only case above, and it went wrong the same way: a field the
- * change list does not know about diffs to nothing, so the take button stays disabled and the
- * author can neither accept the candidate nor clear it. `parameters` arrived on 2026-09-16 and
- * would have landed in that hole.
- */
-const parameterOnly = () => ({
-  ...current(),
-  parameters: [
-    {
-      name: 'hoist',
-      range: { unit: 'mm', min: 0, max: 1800 },
-      clip: {
-        channels: [
-          {
-            target: 'motor',
-            path: 'translation',
-            keys: [
-              { at: 0, value: { x: 0, y: 0, z: 0 } },
-              { at: 2.5, value: { x: 0, y: -1800, z: 0 } }
-            ]
-          }
-        ]
-      }
-    }
-  ]
-})
-
-test('a candidate that only adds a value-driven pose is something the author can act on', () => {
-  const changes = diffProposal(current() as any, parameterOnly() as any)
-
-  assert.deepEqual(changes.map(c => `${c.kind}:${c.key}`), ['parameters:parameters'])
-
-  const taken = applyProposal(current() as any, parameterOnly() as any, new Set(['parameters'])) as any
-  assert.equal(taken.parameters?.length, 1, 'the parameter has to survive being taken')
-  assert.equal(taken.parameters[0].range.max, 1800, 'the range travels with it -- without it no value can be given')
-})
-
-test('a candidate that only adds movement is something the author can act on', () => {
-  const changes = diffProposal(current() as any, animationOnly() as any)
-
-  assert.deepEqual(
-    changes.map(c => `${c.kind}:${c.key}`),
-    ['animations:animations'],
-    'movement-only candidates used to diff to nothing, which left the take button disabled forever'
-  )
-
-  const taken = applyProposal(current() as any, animationOnly() as any, new Set(['animations'])) as any
-  assert.equal(taken.animations?.length, 1, 'the clip has to survive being taken')
-  assert.equal(taken.animations[0].channels[0].target, 'motor')
-})
-
-test('figure-level fields the format has are all offered, and ones it dropped are not', () => {
-  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
-  const after = {
-    ...current(),
-    placement: 'ceiling',
-    capabilities: ['Holdable', 'FlowNode'],
-    styleKit: 'factory',
-    detailLevel: 'L',
-    base: { x: 120, y: 100, z: 100 },
-    animations: animationOnly().animations
-  }
-
-  const kinds = diffProposal(before as any, after as any).map(c => c.kind)
-  for (const kind of ['base', 'placement', 'detail', 'styleKit', 'animations', 'capabilities']) {
-    assert.ok(kinds.includes(kind as any), `${kind} changed and the author was never shown it`)
-  }
-  assert.ok(!kinds.includes('anchor' as any), 'figure-level anchor left the format on 2026-09-10')
-})
-
-test('propose, revise, then accept — each round starts from what the author has now', () => {
-  /* Round one: the author keeps the new guard but not the wider base. */
-  const first = openAiProposal(current() as any, { source: JSON.stringify(proposal()) } as any)
-  assert.ok(first.picked.size > 0, 'a fresh session starts with every change picked')
-
-  const withoutBase = toggleProposalChange(first, 'base')
-  assert.ok(!withoutBase.picked.has('base'))
-
-  const afterFirst = applyProposal(current() as any, proposal() as any, withoutBase.picked) as any
-  assert.deepEqual(afterFirst.base, current().base, 'the change left unpicked must not be applied')
-  assert.ok(afterFirst.parts.some((p: any) => p.name === 'guard'), 'the picked addition must be applied')
-
-  /* Round two: asked again, this time about movement. The base the author refused stays refused. */
-  const revised = { ...afterFirst, animations: animationOnly().animations }
-  const second = openAiProposal(afterFirst, { source: JSON.stringify(revised) } as any)
-  assert.deepEqual(
-    [...second.picked],
-    ['animations'],
-    'the second round compares against the accepted draft, not the original — already-taken changes are not offered again'
-  )
-
-  const afterSecond = applyProposal(afterFirst, revised as any, second.picked) as any
-  assert.equal(afterSecond.animations?.length, 1)
-  assert.ok(afterSecond.parts.some((p: any) => p.name === 'guard'), 'round one survives round two')
-  assert.deepEqual(afterSecond.base, current().base, 'and so does the refusal')
-})
-
-test('cancelling leaves the draft exactly as it was', () => {
-  const draft = current()
-  const session = openAiProposal(draft as any, { source: JSON.stringify(proposal()) } as any)
-
-  /* Cancelling is dropping the session. The draft is a separate value and must be untouched. */
-  assert.deepEqual(draft, current(), 'opening a candidate for review must not mutate the draft')
-  assert.ok(session.source !== (draft as any), 'and the session must hold its own copy')
-
-  /* Unpicking everything is the other way to refuse: the take button disables and nothing moves. */
-  let emptied = session
-  for (const key of [...session.picked]) emptied = toggleProposalChange(emptied, key)
-  assert.equal(emptied.picked.size, 0)
-  assert.deepEqual(applyProposal(draft as any, proposal() as any, emptied.picked) as any, {
-    ...draft,
-    parts: draft.parts
-  }, 'with nothing picked the result is the draft itself')
-})
-
-/*
- * ── The cases the four tests above did not reach ─────────────────────────────
- *
- * Those covered the happy sequence. What follows are the ones an author actually hits and that a
- * happy-path test never touches: refusing a deletion, a candidate that takes movement away, the
- * draft moving under an open candidate, and every change kind surviving being applied rather than
- * merely being listed. The animation defect was in exactly that gap — the kind was listed nowhere,
- * so nothing that only listed kinds could have caught it.
- */
-
-const withAnimation = () => ({ ...current(), animations: animationOnly().animations })
-
-test('refusing a deletion keeps the part, and taking it removes it', () => {
-  const dropsMotor = { ...current(), parts: current().parts.filter(p => p.name !== 'motor') }
-
-  const changes = diffProposal(current() as any, dropsMotor as any)
-  assert.deepEqual(changes.map(c => `${c.kind}:${c.key}`), ['removed:motor'])
-
-  const refused = applyProposal(current() as any, dropsMotor as any, new Set()) as any
-  assert.ok(refused.parts.some((p: any) => p.name === 'motor'), 'an unpicked removal must not delete anything')
-
-  const taken = applyProposal(current() as any, dropsMotor as any, new Set(['motor'])) as any
-  assert.ok(!taken.parts.some((p: any) => p.name === 'motor'))
-})
-
-test('a candidate that takes movement away is shown, not applied behind the author', () => {
-  /* The reverse direction of the defect: the draft has clips and the candidate comes back without. */
-  const stripped = { ...withAnimation(), animations: undefined }
-
-  const changes = diffProposal(withAnimation() as any, stripped as any)
-  assert.deepEqual(changes.map(c => c.kind), ['animations'], 'losing the clips has to appear as a change')
-
-  const refused = applyProposal(withAnimation() as any, stripped as any, new Set()) as any
-  assert.equal(refused.animations?.length, 1, 'unpicked, the clips stay')
-
-  const taken = applyProposal(withAnimation() as any, stripped as any, new Set(['animations'])) as any
-  assert.equal(taken.animations, undefined, 'picked, they go — but only because the author said so')
-})
-
-test('every change kind survives being applied, not just being listed', () => {
-  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'], styleKit: 'plain' }
-  const after = {
-    ...current(),
-    placement: 'ceiling',
-    capabilities: ['Holdable', 'FlowNode'],
-    styleKit: 'factory',
-    detailLevel: 'L',
-    base: { x: 120, y: 100, z: 100 },
-    animations: animationOnly().animations
-  }
-
-  const all = new Set(diffProposal(before as any, after as any).map(c => c.key))
-  const taken = applyProposal(before as any, after as any, all) as any
-
-  assert.equal(taken.placement, 'ceiling')
-  assert.deepEqual(taken.capabilities, ['Holdable', 'FlowNode'])
-  assert.equal(taken.styleKit, 'factory')
-  assert.equal(taken.detailLevel, 'L')
-  assert.deepEqual(taken.base, { x: 120, y: 100, z: 100 })
-  assert.equal(taken.animations?.length, 1)
-})
-
-test('each figure-level change can be taken on its own without dragging the others along', () => {
-  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
-  const after = {
-    ...current(),
-    placement: 'ceiling',
-    capabilities: ['Holdable', 'FlowNode'],
-    animations: animationOnly().animations
-  }
-
-  for (const only of ['placement', 'capabilities', 'animations']) {
-    const taken = applyProposal(before as any, after as any, new Set([only])) as any
-    assert.equal(taken.placement, only === 'placement' ? 'ceiling' : 'floor', `${only}: placement leaked`)
-    assert.equal(
-      taken.capabilities.length,
-      only === 'capabilities' ? 2 : 1,
-      `${only}: capabilities leaked`
-    )
-    assert.equal(taken.animations === undefined, only !== 'animations', `${only}: animations leaked`)
-  }
-})
-
-test('taking part of a candidate and then asking again offers only what is still different', () => {
-  const after = {
-    ...current(),
-    placement: 'ceiling',
-    animations: animationOnly().animations,
-    parts: [...current().parts, proposal().parts[1]]
-  }
-
-  /* The author takes the movement only. */
-  const firstRound = applyProposal(current() as any, after as any, new Set(['animations'])) as any
-  assert.equal(firstRound.animations?.length, 1)
-  assert.equal(firstRound.placement, undefined)
-
-  /* Asking again with the same candidate must still offer what was left behind — and not movement. */
-  const second = openAiProposal(firstRound, { source: JSON.stringify(after) } as any)
-  assert.deepEqual([...second.picked].sort(), ['guard', 'placement'])
-})
-
-test('a malformed candidate is refused at the session boundary, not half-opened', () => {
-  for (const bad of ['{"type":"MIXER"}', '{"parts":"not an array"}', 'not json at all']) {
-    assert.throws(
-      () => openAiProposal(current() as any, { source: bad } as any),
-      'a candidate without a usable parts array must not open a review session'
-    )
-  }
-})
-
-test('an identical candidate leaves nothing to decide', () => {
-  const same = openAiProposal(current() as any, { source: JSON.stringify(current()) } as any)
-  assert.equal(same.picked.size, 0, 'no differences means no picks')
-  assert.deepEqual(
-    applyProposal(current() as any, current() as any, same.picked) as any,
-    current(),
-    'and applying it changes nothing'
-  )
-})
-
-test('taking a candidate twice does not compound — the second time there is nothing left', () => {
-  const once = applyProposal(current() as any, proposal() as any) as any
-  const twice = applyProposal(once, proposal() as any) as any
-  assert.deepEqual(twice, once, 'apply has to be idempotent, or a double click duplicates parts')
-  assert.equal(
-    once.parts.filter((p: any) => p.name === 'guard').length,
-    1,
-    'the added part must not appear twice'
-  )
-})
-
-test('part names are matched exactly — a renamed part is an addition plus a removal', () => {
-  const renamed = {
-    ...current(),
-    parts: current().parts.map(p => (p.name === 'motor' ? { ...p, name: 'Motor' } : p))
-  }
-
-  const kinds = diffProposal(current() as any, renamed as any).map(c => `${c.kind}:${c.key}`).sort()
-  assert.deepEqual(kinds, ['added:Motor', 'removed:motor'], 'case differences are different parts — bindings are exact')
-})
-
-/*
- * ── The three properties this path has to keep, stated as properties ─────────
- *
- * Everything above is a case. Cases are written by hand and a hand-written list stops where its
- * author stopped thinking — which is how a whole feature (movement) went unreachable while every
- * test stayed green. These are closed over the format instead: they read what a FigureSource may
- * contain and assert something that must hold for all of it, so the format growing is what makes
- * them fail.
- *
- * They are also the contract another authoring surface would have to meet. Nothing below knows
- * about figures specifically — only that there is a canonical document, a candidate for it, and a
- * person deciding between the two.
- */
-
-/** 형식이 선언한 저작 칸. 손으로 적지 않는다 — 형식이 자라면 이 시험도 같이 자란다. */
-function figureFields(): string[] {
-  /* 패키지가 호이스팅되면 이 패키지 아래에 없다. 해석으로 찾는다 — 경로를 적어 두지 않는다. */
-  const entry = createRequire(import.meta.url).resolve('@hatiolab/figure-model/package.json')
-  const source = readFileSync(entry.replace(/package\.json$/, 'dist/types.d.ts'), 'utf8')
-  const body = source.match(/interface FigureSource \{([\s\S]*?)\n\}/)
-  assert.ok(body, 'FigureSource 를 형식에서 못 찾았다')
-  return [...body![1].matchAll(/^ {4}([a-zA-Z]+)\??:/gm)].map(m => m[1]!)
-}
-
-test('구조 · 저작 가능한 모든 칸은 검토를 지난다 — 조용히 지나가는 칸이 없다', () => {
-  /*
-    `type` 은 저장 식별자라 후보가 바꿔도 받지 않고, `parts` 는 부품 단위로 따로 센다.
-    `version` 은 저장할 때 서버가 찍는다. 나머지는 전부 사람이 보고 고를 수 있어야 한다.
-  */
-  const decidedElsewhere = new Set(['type', 'parts', 'version'])
-  const mustBeReviewable = figureFields().filter(f => !decidedElsewhere.has(f))
-
-  const before: any = { ...current() }
-  const after: any = { ...current() }
-  /* 각 칸을 실제로 다르게 만들어 본다 — 이름만 맞추는 시험은 값이 안 옮겨져도 통과한다. */
-  const sample: Record<string, [unknown, unknown]> = {
-    base: [{ x: 100, y: 100, z: 100 }, { x: 120, y: 100, z: 100 }],
-    placement: ['floor', 'ceiling'],
-    detailLevel: ['M', 'L'],
-    styleKit: ['plain', 'factory'],
-    animations: [undefined, animationOnly().animations],
-    parameters: [undefined, parameterOnly().parameters],
-    capabilities: [['Holdable'], ['Holdable', 'FlowNode']],
-    joints: [
-      undefined,
-      [{ name: 'motor-joint', child: 'motor', type: 'revolute', origin: { x: 0, y: 50, z: 0 }, axis: { x: 0, y: 1, z: 0 }, limits: { min: -90, max: 90 } }]
-    ]
-  }
-
-  const unsampled = mustBeReviewable.filter(f => !(f in sample))
-  assert.deepEqual(unsampled, [], '형식에 칸이 늘었다 — 여기에 다른 값 한 쌍을 더해 검토를 확인하라')
-
-  for (const field of mustBeReviewable) {
-    const [b, a] = sample[field]!
-    before[field] = b
-    after[field] = a
-  }
-
-  const changes = diffProposal(before, after)
-  const shown = new Set(changes.map(c => c.key))
-  const hidden = mustBeReviewable.filter(f => !shown.has(f))
-  assert.deepEqual(hidden, [], '바뀌었는데 사람에게 안 보이는 칸이다 — 받아도 반영되지 않고 아무 말도 안 난다')
-
-  const taken = applyProposal(before, after, new Set(mustBeReviewable)) as any
-  for (const field of mustBeReviewable) {
-    assert.deepEqual(taken[field], sample[field]![1], `${field}: 목록에는 떴는데 받아도 안 옮겨졌다`)
-  }
-})
-
-test('구조 · 고른 것만 옮겨진다 — 어떤 부분집합에도', () => {
-  const before: any = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
-  const after: any = {
-    ...current(),
-    placement: 'ceiling',
-    capabilities: ['Holdable', 'FlowNode'],
-    animations: animationOnly().animations,
-    parts: [...current().parts, proposal().parts[1]]
-  }
-
-  const keys = diffProposal(before, after).map(c => c.key)
-  /* 부분집합 전수. 칸이 늘면 경우도 자동으로 는다. */
-  for (let mask = 0; mask < 1 << keys.length; mask++) {
-    const picked = new Set(keys.filter((_, i) => mask & (1 << i)))
-    const taken = applyProposal(before, after, picked) as any
-    const left = diffProposal(taken, after).map(c => c.key)
-
-    for (const key of keys) {
-      const wasPicked = picked.has(key)
-      assert.equal(
-        left.includes(key),
-        !wasPicked,
-        `고른 것은 남으면 안 되고 안 고른 것은 남아야 한다 (${[...picked].join(',') || '없음'} 에서 ${key})`
-      )
-    }
-  }
-})
-
-test('구조 · 검토는 정본을 건드리지 않는다 — 받기 전까지', () => {
-  const draft = Object.freeze({
-    ...current(),
-    parts: Object.freeze(current().parts.map(p => Object.freeze(p)))
-  }) as any
-  const candidate = { ...current(), animations: animationOnly().animations, placement: 'ceiling' } as any
-
-  /* 얼린 것에 쓰면 던진다. 던지지 않는다는 것이 곧 안 건드렸다는 것이다. */
-  const session = openAiProposal(draft, { source: JSON.stringify(candidate) } as any)
-  diffProposal(draft, candidate)
-  applyProposal(draft, candidate, session.picked)
-  toggleProposalChange(session, 'placement')
-
-  assert.deepEqual(draft.animations, undefined, '검토를 열었다고 정본이 달라지면 안 된다')
-  assert.equal(draft.placement, undefined)
-})
-
-test('구조 · 같은 후보를 두 번 받아도 한 번 받은 것과 같다', () => {
-  const after: any = { ...current(), animations: animationOnly().animations, placement: 'ceiling' }
-  const once = applyProposal(current() as any, after, undefined) as any
-  const twice = applyProposal(once, after, undefined) as any
-
-  assert.deepEqual(twice, once, '두 번 눌러도 달라지면 안 된다')
-  assert.deepEqual(diffProposal(once, after), [], '한 번 받으면 남는 변경이 없다')
-})