@things-factory/figure-service 10.1.16 → 10.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.16",
+  "version": "10.1.18",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,15 +23,15 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.17",
+    "@hatiolab/figure-model": "^0.1.19",
     "@operato/typeorm-history": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.8",
-    "@things-factory/auth-base": "^10.1.16",
+    "@things-factory/auth-base": "^10.1.18",
     "@things-factory/env": "^10.1.3",
     "@things-factory/shell": "^10.1.16",
     "graphql-scalars": "^1.22.4",
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "aff86bc162b42c1d933711f7bc85a073f1ddcd29"
+  "gitHead": "608fe1a70f430ae9c3aa20497173cecc8121373e"
 }

package/server/service/figure/figure-e2e-smoke.test.ts

@@ -0,0 +1,72 @@
+/**
+ * AI 로 figure 를 완성하는 길에 막히는 데가 있나 — 끝까지 걸어 본다.
+ *
+ * 개별 단계는 각자 시험이 있다. 없던 것은 **이어 붙였을 때**다. 만드는 데까지 되는데
+ * 발행에서 막히면 저작자는 AI 로 시작해서 손으로 끝내야 하고, 그것은 이 기능이 있으나 마나다.
+ */
+import { createAIClient, setDefaultAIClient } from '@things-factory/ai-client-base'
+import '@things-factory/ai-client-base'
+
+import { proposeFigure } from './figure-propose'
+import { inspectSource } from './figure-gate'
+import { parseSource } from './figure-source'
+
+const PALETTE = ['palette.primary', 'palette.accent', 'palette.neutral']
+const on = process.env.RUN_FIGURE_LLM_SMOKE === '1'
+const describeIf = on ? describe : describe.skip
+
+describeIf('AI 로 만든 figure 가 발행까지 가나', () => {
+  beforeAll(() => {
+    setDefaultAIClient(createAIClient({ provider: 'gemini', apiKey: process.env.GEMINI_API_KEY!, model: 'gemini-3.5-flash' } as any))
+  })
+  afterAll(() => setDefaultAIClient(undefined))
+
+  const walk = async (label: string, prompt: string, type: string) => {
+    const made = await proposeFigure({ prompt, type, palette: PALETTE, refine: true })
+
+    /* 1. 저장 문을 지나는가 — 형식 오류면 여기서 던진다. */
+    const saved = parseSource(JSON.stringify(made.source))
+
+    /* 2. 발행 게이트를 지나는가 — 여기서 막히면 AI 로 시작해 손으로 끝내야 한다. */
+    const gate = inspectSource(saved.source)
+    const blocking = gate.findings.filter(f => f.blocking)
+
+    // eslint-disable-next-line no-console
+    console.log(
+      `[${label}] 부품 ${made.source.parts.length} · 삼각형 ${made.cost.triangles} · 등급 ${made.score.grade}` +
+        ` · 위반 ${made.violations.length} · 발행 ${gate.blocked ? '막힘: ' + blocking.map(f => f.code + '(' + (f.at ?? '') + ')').join(', ') : '통과'}`
+    )
+    return { made, gate, blocking }
+  }
+
+  test('늘려도 안 부서지는 것을 만든다 — 앵커를 가르친 뒤', async () => {
+    const { gate, blocking } = await walk(
+      '신호탑',
+      'a signal tower: a tall slim pole standing on a foot, with three stacked lamps at the very top. the lamps must stay on top of the pole when the tower is made taller.',
+      'SIGNAL_TOWER_E2E'
+    )
+    expect(gate.blocked).toBe(false)
+    expect(blocking).toEqual([])
+  }, 120_000)
+
+  test('반복하는 것을 만든다 — 컨베이어', async () => {
+    const { made, gate } = await walk(
+      '컨베이어',
+      'a roller conveyor: a frame with rollers repeating along its length. when the conveyor is made longer the number of rollers must grow, not their size.',
+      'CONVEYOR_E2E'
+    )
+    expect(gate.blocked).toBe(false)
+    expect(made.source.parts.some((p: any) => p.sizing === 'repeat')).toBe(true)
+  }, 120_000)
+
+  test('움직이는 것을 만든다 — 문', async () => {
+    const { made, gate } = await walk(
+      '자동문',
+      'a двух-panel automatic door in a frame. add an animation clip that opens both panels together by sliding them apart.',
+      'AUTO_DOOR_E2E'
+    )
+    expect(gate.blocked).toBe(false)
+    expect(made.source.animations?.length).toBeGreaterThan(0)
+    expect(made.source.animations![0]!.channels.length).toBeGreaterThan(0)
+  }, 120_000)
+})

package/server/service/figure/figure-gate.test.ts

@@ -30,3 +30,71 @@ describe('release-gate repair candidates', () => {
     expect(split?.fixes?.every(fix => fix.resolved > 0)).toBe(true)
   })
 })
+
+/*
+ * The base box is a promise to whoever places this figure.
+ *
+ * `base` is the number an instance is scaled by (`instanceScale = width/base.x`) and the placement
+ * height comes out of `base.y`. A figure whose box disagrees with its parts renders at the wrong
+ * size and the wrong height the moment it is placed, so publishing it breaks that promise
+ * even though the source itself is well formed.
+ *
+ * Saving is still allowed — these are violations, not errors — so a figure already standing on a
+ * drawing keeps standing. It just cannot be published again until it is fixed.
+ */
+describe('release gate — the base box', () => {
+  /** A figure that sits correctly in its box: 200 tall, foot on the floor at -100. */
+  const sound = {
+    type: 'POST',
+    base: { x: 100, y: 200, z: 100 },
+    detailLevel: 'M',
+    parts: [
+      {
+        name: 'post', primitive: 'cube',
+        transform: { position: { x: 0, y: -50, z: 0 }, size: { x: 100, y: 100, z: 100 } },
+        material: { token: 'palette.primary' }
+      }
+    ]
+  }
+
+  const inspect = (source: unknown) => inspectSource(JSON.stringify(source))
+
+  it('lets a sound figure through', () => {
+    const inspection = inspect(sound)
+    expect(inspection.blocked).toBe(false)
+  })
+
+  it('refuses a part that overflows the box', () => {
+    const over = { ...sound, parts: [{ ...sound.parts[0], transform: { position: { x: 0, y: -120, z: 0 }, size: { x: 100, y: 100, z: 100 } } }] }
+    const inspection = inspect(over)
+    const finding = inspection.findings.find(f => f.code === 'part-outside-base')
+
+    expect(finding?.blocking).toBe(true)
+    expect(inspection.blocked).toBe(true)
+  })
+
+  it('refuses a figure that does not reach the face its placement names', () => {
+    const floating = { ...sound, parts: [{ ...sound.parts[0], transform: { position: { x: 0, y: 0, z: 0 }, size: { x: 100, y: 100, z: 100 } } }] }
+    const inspection = inspect(floating)
+    const finding = inspection.findings.find(f => f.code === 'parts-off-placement-face')
+
+    expect(finding?.blocking).toBe(true)
+    expect(inspection.blocked).toBe(true)
+  })
+
+  it('still only reports the violations that are about taste', () => {
+    /*
+      Slack in the box is a declaration, not a defect — clearance in front of a conveyor, the pitch
+      of a rack bay. A roomy box with an odd segment count is told about and published.
+    */
+    const roomy = {
+      ...sound,
+      base: { x: 3000, y: 200, z: 3000 },
+      parts: [{ ...sound.parts[0], primitive: 'cylinder', segments: 9 }]
+    }
+    const inspection = inspect(roomy)
+
+    expect(inspection.findings.some(f => f.code === 'segments-off-preset')).toBe(true)
+    expect(inspection.blocked).toBe(false)
+  })
+})

package/server/service/figure/figure-gate.ts

@@ -1,4 +1,4 @@
-import { compile, sizingReport, validate } from '@hatiolab/figure-model'
+import { blocksRelease, compile, sizingReport, validate } from '@hatiolab/figure-model'
 import type { Axis, FigureSource } from '@hatiolab/figure-model'
 
 /** Service transport shape. It deliberately contains only an explicit, reversible FigureSource edit. */
@@ -26,20 +26,24 @@ export interface GateFix {
  *
  * 판정은 `figure-model` 의 `gate.ts` 가 이미 문서로 정해 두었다. 여기서 새로 정하지 않는다.
  *
- *   sizing-splits   크기를 바꾸면 조각이 갈라진다   **막는다**
- *   sizing-loose    1배에서 이미 여러 조각이다      알린다
- *   violations      형식이 권하지 않는 것          알린다 (저장 때 이미 보여 준 것들)
+ *   sizing-splits              크기를 바꾸면 조각이 갈라진다      **막는다**
+ *   part-outside-base          부품이 기준 상자를 넘는다          **막는다**
+ *   parts-off-placement-face   기준면에 안 닿는다                 **막는다**
+ *   sizing-loose               1배에서 이미 여러 조각이다         알린다
+ *   그 밖의 violations          형식이 권하지 않는 것              알린다 (저장 때 이미 보여 준 것들)
  *
  * 갈라짐을 막는 이유는 사람 눈에 「부서졌다」로 보이기 때문이다 — 시그널타워를 3배로 세우니 램프가
  * 기둥 위 공중에 떴던 그것이고, 앵커 규칙이 생긴 이유다. 소비처가 형상을 늘려 쓰는 것은 막을 수
  * 없으니(그것이 이 형식의 값이다), 늘려도 견디는지를 발행 전에 본다.
  *
- * ## 재 본 값
+ * ## 몇 개가 걸리나는 여기 안 적는다
  *
- * [확인함] 2026-09-09 · 표본 15개(시드 14 + 저작 1)
- *   형식 오류 0 · 1배 분리 0 · **갈라짐 1**(MIXER, z·y-z 조합) · 조용함 14
+ * 한동안 「표본 15개 중 갈라짐 1 · 조용함 14」를 적어 두고 **게이트가 벽이 아니라는 근거**로
+ * 삼았다. 수는 굳고 카탈로그는 움직인다 — 기준 상자 판정이 붙자 그 비율이 하루 만에 뒤집혔다.
+ * 굳은 수를 근거로 든 문장은 그때부터 사실이 아닌 채로 사람을 안심시킨다.
  *
- * 게이트가 벽이 아니라는 뜻이다. 열넷은 그대로 발행되고, 하나는 고칠 것이 있다.
+ * 무엇이 걸리고 얼마나 넘쳤나는 **저작 도구가 재서 보여 준다.** 그것을 볼 사람은 고치는
+ * 사람이고, 그 사람이 보는 자리는 여기가 아니다.
  */
 
 /** 게이트가 낸 한 가지. `blocking` 이 참이면 발행이 안 된다. */
@@ -161,7 +165,12 @@ export function inspectSource(sourceJson?: string | null): Inspection {
   }
 
   for (const violation of result.violations) {
-    findings.push({ code: violation.code, message: violation.message, blocking: false })
+    findings.push({
+      code: violation.code,
+      message: violation.message,
+      /* 어느 위반이 막나는 형식이 안다 — 여기 목록을 또 들면 둘이 갈린다(ADR-0044 결정 ②). */
+      blocking: blocksRelease(violation.code)
+    })
   }
 
   if (result.errors.length === 0) {

package/server/service/figure/figure-mutation.ts

@@ -278,7 +278,7 @@ export class FigureMutation {
   async deleteFigure(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    // 소프트 삭제다 — 이미 배치된 보드가 이 타입을 참조할 수 있으므로 행을 지우지
+    // 소프트 삭제다 — 이미 배치된 도면이 이 타입을 참조할 수 있으므로 행을 지우지
     // 않는다. 되살릴 길을 남긴다.
     await tx.getRepository(Figure).softDelete({ domain: { id: domain.id }, id })
 

package/server/service/figure/figure-propose.test.ts

@@ -10,12 +10,47 @@
  * 모델은 부르지 않는다. 부르면 시험이 느리고 답이 매번 다르다 — 여기서 볼 것은
  * 모델의 솜씨가 아니라 **우리 거름망**이다.
  */
-import { LIMITS, PART_LIMIT, PRIMITIVE_KINDS, SEGMENT_PRESETS } from '@hatiolab/figure-model'
+import {
+  ANCHOR_RULES,
+  DETAIL_LEVELS,
+  CHANNEL_PATHS,
+  FIGURE_PLACEMENTS,
+  INTERPOLATIONS,
+  LABEL_WHENS,
+  LIMITS,
+  MATERIAL_SLOTS,
+  PART_LIMIT,
+  PART_ROLES,
+  PRIMITIVE_KINDS,
+  REPEAT_LIMIT,
+  SEGMENT_PRESETS,
+  SIZING_RULES
+} from '@hatiolab/figure-model'
 import { setDefaultAIClient } from '@things-factory/ai-client-base'
 import type { AIClient } from '@things-factory/ai-client-base'
 
+import { readFileSync } from 'fs'
+
+import * as model from '@hatiolab/figure-model'
+
 import { ProposeFailure, inspect, proposeFigure, rulesPrompt } from './figure-propose'
 
+
+/**
+ * 형식이 선언한 칸 이름을 **형식 소스에서** 읽는다.
+ *
+ * 손으로 옮겨 적으면 형식이 자라도 이 파일은 그대로 있고, 그러면 이 시험이 지키려는 것을
+ * 스스로 어긴다. 타입은 런타임에 안 남으므로 선언을 읽는다.
+ */
+function declaredFields(name: string): string[] {
+  const path = require.resolve('@hatiolab/figure-model/package.json')
+  const root = path.replace(/package\.json$/, '')
+  const source = readFileSync(`${root}dist/types.d.ts`, 'utf8')
+  const body = source.match(new RegExp(`interface ${name} \\{([\\s\\S]*?)\\n\\}`))
+  if (!body) throw new Error(`형식에서 ${name} 을 못 찾았다 — 이름이 바뀌었으면 시험도 따라가야 한다`)
+  return [...body[1].matchAll(/^\s{4}([a-zA-Z]+)\??:/gm)].map(m => m[1]!)
+}
+
 const PALETTE = ['palette.primary', 'palette.accent', 'palette.neutral']
 
 /** 온전한 후보. 시험할 곳만 덮어쓴다. */
@@ -42,7 +77,7 @@ function candidate(over: Record<string, unknown> = {}) {
  *
  * **받은 말을 적어 둔다.** 프롬프트에 실려 나가는 지시 중에 지켜져야 할 것이 있어서다 —
  * 고치는 요청에서 「부품 이름을 바꾸지 말라」가 빠지면 AI 가 이름을 갈아 버리고, 그러면
- * 이미 배치된 보드의 바인딩이 끊긴다. 답만 보는 모형으로는 그것이 나갔는지 알 수 없다.
+ * 이미 배치된 도면의 바인딩이 끊긴다. 답만 보는 모형으로는 그것이 나갔는지 알 수 없다.
  */
 function stubClient(answers: unknown[]): AIClient & { calls: number; sent: any[][]; system?: string } {
   const client = {
@@ -94,6 +129,153 @@ describe('규칙을 프롬프트로 옮길 때', () => {
   })
 })
 
+/*
+ * ── Every authorable feature has to reach the model ──────────────────────────
+ *
+ * The prompt is the only place the model learns what a figure may contain. Until 2026-09-16 it
+ * taught `{ type, base, placement, detailLevel, parts }` and one stray line naming the animation
+ * paths, so anchors, repeats, capabilities, labels, lamps, hollows and movement were unreachable:
+ * the model was told there is a limit of two animated parts without ever being told where an
+ * animation goes. What came back was coloured boxes.
+ *
+ * These check per feature rather than per word, because a vocabulary list the model cannot place
+ * in the JSON is worse than no mention at all — it produces confident, invalid output.
+ */
+/*
+ * ── The format is the only vocabulary, and the prompt must follow it ─────────
+ *
+ * Checking feature by feature does not hold: a list of features has to be extended by hand every
+ * time the format grows, which is the failure it is supposed to prevent. Until 2026-09-16 the
+ * prompt taught five fields out of thirteen and a single stray line naming the animation paths,
+ * and nothing failed — because nothing compared the prompt against the format.
+ *
+ * So these walk `@hatiolab/figure-model` itself. Every enum it exports is either something an
+ * author writes into a FigureSource, in which case the model has to be taught all of its values,
+ * or it is not, in which case it is named below with the reason. Adding an enum to the format
+ * forces that decision instead of letting it be forgotten.
+ */
+describe('프롬프트는 형식을 따라간다 — 손으로 적은 목록이 아니라', () => {
+  /*
+    저작자가 FigureSource 에 적는 값이 아닌 열거. 여기 없는 새 열거가 형식에 생기면 아래 시험이
+    깨지고, 가르칠지 말지를 그때 정하게 된다.
+  */
+  const NOT_AUTHORED: Record<string, string> = {
+    ERROR_CODES: '검증 결과다 — 저작자가 적는 값이 아니다',
+    VIOLATION_CODES: '같다',
+    RELEASE_BLOCKING_VIOLATIONS: '위반 코드의 부분집합이다 — 어느 것이 발행을 막나는 관문이 알 일이지 저작자가 적는 값이 아니다',
+    AXES: "'x'·'y'·'z' 는 축 이름이고 값이 아니다 — 쓰는 자리에서 anchor.<axis> 로 가르친다",
+    SURFACE_KINDS: 'material.surface 는 things-scene 에 소비처가 0건이다 — 그릴 수 없는 것을 시키지 않는다',
+    CLIP_DRIVES:
+      '없어지는 이름이다 — 값이 만드는 자세가 `parameters` 로 나갔고(ADR-0051 ①) `compile()` 이 옛 원본의 hold 를 옮길 때만 읽는다. 새로 적는 값이 아니다'
+  }
+
+  it('저작에 쓰이는 열거는 값 하나도 빠짐없이 프롬프트에 있다', () => {
+    const prompt = rulesPrompt(PALETTE)
+    const missing: string[] = []
+
+    for (const [name, value] of Object.entries(model as Record<string, unknown>)) {
+      if (!Array.isArray(value) || value.some(v => typeof v !== 'string')) continue
+      if (name in NOT_AUTHORED) continue
+      for (const member of value as string[]) {
+        if (!prompt.includes(member)) missing.push(`${name}.${member}`)
+      }
+    }
+
+    expect(missing).toEqual([])
+  })
+
+  it('저작에 안 쓰이는 열거는 이유가 적혀 있다 — 조용히 빠지지 않는다', () => {
+    const enums = Object.entries(model as Record<string, unknown>)
+      .filter(([, v]) => Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string'))
+      .map(([k]) => k)
+
+    /* 형식에 열거가 늘면 가르치거나 NOT_AUTHORED 에 이유와 함께 적어야 한다. */
+    const prompt = rulesPrompt(PALETTE)
+    const unclassified = enums.filter(
+      name => !(name in NOT_AUTHORED) && !(model as any)[name].every((m: string) => prompt.includes(m))
+    )
+
+    expect(unclassified).toEqual([])
+  })
+
+  it('한도는 형식의 값을 그대로 인용한다 — 프롬프트에 숫자를 적어 두지 않는다', () => {
+    const prompt = rulesPrompt(PALETTE)
+
+    for (const [key, limit] of Object.entries(LIMITS)) {
+      if (typeof limit !== 'number') continue
+      /* 한도를 안 가르치는 것은 괜찮다. 다른 수를 가르치는 것은 안 된다. */
+      const wrong = new RegExp(`${key}[^\\n]*<=\\s*(?!${limit}\\b)\\d+`, 'i')
+      expect(prompt).not.toMatch(wrong)
+    }
+    expect(prompt).toContain(String(REPEAT_LIMIT))
+    for (const level of DETAIL_LEVELS) expect(prompt).toContain(`${level}=${PART_LIMIT[level]}`)
+  })
+
+  /*
+    가르치지 않는 칸. 열거와 같은 규율이다 — 여기 없는 새 칸이 형식에 생기면 아래가 깨지고,
+    그때 가르칠지 말지를 정하게 된다. 「아직 안 가르쳤다」가 조용히 남지 않는다.
+  */
+  const NOT_TAUGHT: Record<string, Record<string, string>> = {
+    FigureSource: {
+      type: '요청에서 온다 — 모델이 지어내면 거절한다',
+      parts: '모양 첫 줄에 이미 있다',
+      version: '저장할 때 서버가 찍는다',
+      styleKit: '읽는 쪽이 0건이다 — 그릴 수 없는 것을 시키면 무동작 설정이 된다'
+    },
+    FigurePart: {
+      name: '모양 첫 줄에 있다',
+      primitive: '같다',
+      transform: '같다',
+      material: '같다'
+    },
+    PartMaterial: {
+      token: '모양 첫 줄에 있다',
+      preset: '같다',
+      surface: 'things-scene 에 소비처가 0건이다 — 그릴 수 없는 것을 시키지 않는다'
+    }
+  }
+
+  for (const iface of ['FigureSource', 'FigurePart', 'PartMaterial']) {
+    it(`${iface} 의 칸은 가르치거나 이유를 적었거나 둘 중 하나다`, () => {
+      const prompt = rulesPrompt(PALETTE)
+      const silent = declaredFields(iface).filter(
+        field => !(field in NOT_TAUGHT[iface]!) && !prompt.includes(field)
+      )
+
+      expect(silent).toEqual([])
+    })
+
+    it(`${iface} 의 제외 목록에 죽은 이름이 없다`, () => {
+      /* 형식에서 없어진 칸을 제외 목록이 계속 들고 있으면, 그 목록이 형식을 안 따라간 것이다. */
+      const declared = new Set(declaredFields(iface))
+      const stale = Object.keys(NOT_TAUGHT[iface]!).filter(field => !declared.has(field))
+
+      expect(stale).toEqual([])
+    })
+  }
+})
+
+describe('고치라는 요청일 때', () => {
+  it('요청이 안 건드린 것을 그대로 실으라고 못 박는다', async () => {
+    /*
+      이 문장이 없으면 애니메이션이 있는 도형을 「색만 바꿔 줘」로 고쳤을 때 모델이 clip 을
+      안 실어 보내고, 그것이 오류 없이 통과해 조용히 사라진다.
+    */
+    const client = stubClient([candidate()])
+    setDefaultAIClient(client as any)
+    await proposeFigure({ prompt: '색을 바꿔 줘', base: candidate() as any, palette: PALETTE })
+
+    const sent = firstAsk(client)
+    expect(sent).toMatch(/Carry over everything the request did not ask you to change/)
+    expect(sent).toMatch(/dropping one is silent/)
+
+    /* 잃기 쉬운 칸은 이름으로 짚어 준다 — 「전부 지켜라」만으로는 모델이 빠뜨린다. */
+    for (const field of ['animations', 'capabilities', 'anchor', 'repeat', 'label', 'materialSlot']) {
+      expect(sent).toContain(field)
+    }
+  })
+})
+
 describe('후보를 받아 볼 때', () => {
   it('온전하면 통과시킨다', () => {
     const looked = inspect(candidate(), PALETTE)
@@ -257,8 +439,8 @@ describe('후보를 만들 때', () => {
 describe('무엇을 시키는지가 프롬프트에 실린다', () => {
   /*
     고치는 요청에서 이 지시가 빠지면 AI 가 부품 이름을 갈아 버린다. 부품 이름은 **저장되는
-    식별자**라서, 이미 배치된 보드의 바인딩·애니메이션이 그 이름을 가리키고 있다. 조용히
-    끊기고, 끊긴 것은 그 보드를 열어 봐야 드러난다.
+    식별자**라서, 이미 배치된 도면의 바인딩·애니메이션이 그 이름을 가리키고 있다. 조용히
+    끊기고, 끊긴 것은 그 도면을 열어 봐야 드러난다.
   */
   it('고치는 요청이면 지금 정본과 「이름을 바꾸지 말라」가 함께 나간다', async () => {
     const client = stubClient([candidate()])
@@ -371,3 +553,73 @@ describe('정책을 넘은 후보는 막지 않고 알린다', () => {
     expect(result.violations.map(one => one.code)).toContain('too-many-parts')
   })
 })
+
+/*
+ * `parameters` — the one field that answers "expose a value an instance can be given".
+ *
+ * A user asked for a hoist that lowers and raises, with the travel exposed as a variable. The
+ * model answered with `sizing`/`anchor` on the figure's own height and invented
+ * `capabilities: ["hoist"]`, which threw at render. It had not declined; it had gone looking and
+ * not found -- because the door was hidden inside animations as `drive: 'hold'`, and the prompt
+ * described that as a playback mode ("hold plays once and stays") when what it actually said was
+ * WHO SUPPLIES THE VALUE.
+ *
+ * ADR-0051 moved it into its own field with a declared physical range, which is what makes the
+ * value nameable: an instance gives 1200mm, not 0.67.
+ *
+ * These guard the wording, because the wording is the defect. A prompt that hides the one door
+ * leaves the model to invent a door.
+ */
+describe('값이 만드는 자세를 parameters 로 가르친다', () => {
+  const prompt = () => rulesPrompt(PALETTE)
+
+  it('재생 방식으로 적지 않는다', () => {
+    expect(prompt()).not.toMatch(/plays once|repeats forever/i)
+    expect(prompt()).toMatch(/Nothing is played back/)
+  })
+
+  it('두 갈래를 갈라서 적는다 — 어느 쪽이 무엇을 받는지까지', () => {
+    const text = prompt()
+    expect(text).toMatch(/TWO kinds and they are different fields/)
+    expect(text).toMatch(/animations\s+TIME RUNS\. The instance supplies a SPEED/)
+    expect(text).toMatch(/parameters\s+A VALUE MAKES THE POSE/)
+  })
+
+  it('인스턴스가 받는 값을 물으면 parameters 라고 못 박는다', () => {
+    /* 이 문장이 없으면 모델이 크기 반응 쪽으로 간다 — 실제로 갔다. */
+    expect(prompt()).toMatch(/USE parameters WHENEVER THE REQUEST ASKS FOR A VALUE THE INSTANCE IS GIVEN/)
+    expect(prompt()).toMatch(/EXPOSE something AS A VARIABLE/)
+  })
+
+  it('세 가지 잘못된 답을 각각 막는다 — 크기 반응 · 애니메이션 · 능력', () => {
+    const text = prompt()
+    expect(text).toMatch(/Do NOT answer that request with sizing or anchor/)
+    expect(text).toMatch(/Do NOT answer it with animations either/)
+    /* `capabilities: ['hoist']` 가 실제로 나왔던 답이다. */
+    expect(text).toMatch(/Do NOT answer it with a capability/)
+  })
+
+  it('범위를 사람이 말하는 단위로 적으라고 한다 — 0~1 이 아니라', () => {
+    /*
+      곡선의 값 축은 0~1 이지만 그것은 런타임의 말이다. 저작자와 인스턴스가 주고받는 것은
+      mm 이고, 그 선언이 없으면 「길이값을 변수로 노출」이 성립하지 않는다.
+    */
+    const text = prompt()
+    expect(text).toMatch(/range: \{ unit, min, max \}/)
+    expect(text).toMatch(/not 0 to 1/)
+  })
+
+  it('파라미터의 at 이 초가 아니라고 말한다', () => {
+    /*
+      값 0~1 이 `[0, 마지막 키]` 로 맵되므로 키의 절대값은 자세를 안 바꾼다 — 간격만 바꾼다.
+      그 마지막 값이 전 구간 이동 시간을 겸한다는 것도 함께 적혀 있어야 한다.
+    */
+    const text = prompt()
+    expect(text).toMatch(/only the SPACING between keys matters/)
+    expect(text).toMatch(/doubles as the seconds a full min-to-max move takes/)
+  })
+
+  it('두 목록이 이름을 나눠 쓴다고 말한다 — 겹치면 형식이 막는다', () => {
+    expect(prompt()).toMatch(/may not be called the same thing/)
+  })
+})