@things-factory/figure-service 10.1.245 → 10.1.247

package/dist-server/service/figure/figure-ai-scenarios.js

@@ -0,0 +1,814 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIGURE_AI_SCENARIOS = void 0;
+exports.scenarioPartsOf = scenarioPartsOf;
+exports.mixerDraft = mixerDraft;
+exports.portRevisionMisses = portRevisionMisses;
+/**
+ * AI 모델링 시나리오 — what a person asks the figure AI for, and what the figure must then be (2026-11-03, 사용자 「여러가지
+ * 모델링 시나리오를 구성해서 AI를 통한 모델링이 잘 구현되는지 지속적으로 점검할 수 있도록 하라」).
+ *
+ * Each scenario is a request in a person's words, the draft it is asked on (none for a new figure), and a check that
+ * says what the figure that came back misses -- read from the figure by the kernel (its parts' shapes, fastenings,
+ * motion, clips, data), never from the steps the model wrote, so any way of making it that the kernel takes passes.
+ * Each also holds a reference answer the check must pass and a wrong one it must fail: the checks are themselves held to
+ * known verdicts without a provider (figure-ai-scenarios.test.ts). The live run (figure-ai-scenarios.live.test.ts) asks a
+ * real model for each and writes a report to compare runs by.
+ *
+ * The scenarios are spread over what the kernel can say (ADR-0100 shapes and §16's taper and pipe, ADR-0093 fastenings,
+ * ADR-0159 joints, repeats, clips, the figure's size, data bindings, mirrored chains), new figures and revisions both.
+ */
+const figure_model_1 = require("@hatiolab/figure-model");
+/** Every part of a figure, as the kernel evaluates it. */
+function scenarioPartsOf(asset) {
+    const geometry = (0, figure_model_1.compileFigureAsset)(asset).evaluate().geometry;
+    const boxes = (0, figure_model_1.figureOccupiedBoxesOf)(geometry, (0, figure_model_1.figureWritersOf)(asset));
+    const nodes = asset.document.model.nodes;
+    const joints = (asset.joints ?? []);
+    return asset.appearance.map((look) => {
+        const id = look.target;
+        const node = nodes.find(n => n.id === `${id}.shape`);
+        const joint = joints.find(j => j.body1?.part === id);
+        const box = boxes.find(b => b.part === id);
+        const body = geometry.find(g => g.id === id);
+        const motion = (joint?.motion ?? []);
+        return {
+            id,
+            kind: (0, figure_model_1.figureShapeDescriptionOf)(node, asset.document.model)?.kind ?? String(node?.op ?? ''),
+            centre: { x: box?.centre.x ?? 0, y: box?.centre.y ?? 0, z: box?.centre.z ?? 0 },
+            extent: { x: box?.extent.x ?? 0, y: box?.extent.y ?? 0, z: box?.extent.z ?? 0 },
+            colour: String(asset.palette?.[look.material?.token] ?? look.material?.token ?? '').toLowerCase(),
+            ...(joint ? { on: joint.body0?.part ?? 'mounting-plane' } : {}),
+            motion: motion.map(m => m.type),
+            controls: motion.map((m, i) => m.state?.id ?? m.id ?? (i ? `${joint.id}.${i}` : joint.id)),
+            limits: motion.map(m => ({ lower: m.lowerLimit, upper: m.upperLimit })),
+            /* The kernel's own reading of which part a body was placed by: a row's copies are named `["<part>.repeat", i, …]`. */
+            copies: boxes.filter(b => b.part === id).length || 1,
+            shape: body?.shape,
+            node
+        };
+    });
+}
+const near = (a, b, tol = 0.5) => Math.abs(a - b) <= tol;
+const bottom = (p) => p.centre.y - p.extent.y / 2;
+const top = (p) => p.centre.y + p.extent.y / 2;
+/** Every part fastened to something: the plane, or another part (each part fastened once, as the grammar teaches). */
+function loose(parts) {
+    return parts.filter(p => !p.on).map(p => `${p.id} is fastened to nothing`);
+}
+/** A clip that plays one of `controls`. */
+const clipsPlaying = (asset, controls) => (asset.drivers ?? []).filter((d) => controls.includes(d.state));
+const steps = (list) => list;
+/* ── The drafts revisions are asked on ────────────────────────────────────────────────── */
+/** A mixer: a body standing on the floor, a port fastened to its front. */
+function mixerDraft() {
+    return (0, figure_model_1.applyFigureProposal)((0, figure_model_1.createFigureAsset)('Mixer'), [
+        { kind: 'add-part', part: { id: 'body', kind: 'cylinder', dimensions: { radius: 140, length: 320 } } },
+        { kind: 'add-part', part: { id: 'port', kind: 'box', dimensions: { width: 80, height: 60, depth: 30 } } },
+        { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } },
+        /* The body's front is its curved side: a point on it, by the outward normal there (ADR-0140 3.9; push Y, +Z is 270°). */
+        { kind: 'attach', part: 'port', to: { part: 'body', surface: { around: 270, along: 'centre' } } },
+        { kind: 'set-placement', placement: 'floor' }
+    ]);
+}
+/**
+ * What "make the port twice as wide and give it an accent colour" asks of the mixer, said as what is missing: the port
+ * twice as wide (X), its height and depth kept, a colour it did not have, and the body left as it was.
+ */
+function portRevisionMisses(before, after) {
+    const was = Object.fromEntries(scenarioPartsOf(before).map(p => [p.id, p]));
+    const now = Object.fromEntries(scenarioPartsOf(after).map(p => [p.id, p]));
+    const misses = [];
+    if (!now.port)
+        return ['the port is gone'];
+    const size = (p) => (0, figure_model_1.figureShapeBoundsOf)(p.shape);
+    const extentOf = (p, axis) => size(p)[axis].max - size(p)[axis].min;
+    if (!near(extentOf(now.port, 'x'), extentOf(was.port, 'x') * 2))
+        misses.push(`port width ${extentOf(now.port, 'x')}, asked ${extentOf(was.port, 'x') * 2}`);
+    for (const axis of ['y', 'z'])
+        if (!near(extentOf(now.port, axis), extentOf(was.port, axis)))
+            misses.push(`port ${axis} changed to ${extentOf(now.port, axis)}`);
+    if (now.port.colour === was.port.colour)
+        misses.push(`port colour still ${was.port.colour}`);
+    if (!now.body)
+        misses.push('the body is gone');
+    else
+        for (const axis of ['x', 'y', 'z'])
+            if (!near(extentOf(now.body, axis), extentOf(was.body, axis)))
+                misses.push(`body ${axis} changed to ${extentOf(now.body, axis)}`);
+    if (now.body && now.body.colour !== was.body.colour)
+        misses.push(`body colour changed to ${now.body.colour}`);
+    return misses;
+}
+/** An elbow: up from the floor, a quarter bend toward +X, along. */
+function elbowDraft() {
+    return (0, figure_model_1.applyFigureProposal)((0, figure_model_1.createFigureAsset)('Elbow'), [
+        { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+        { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } }
+    ]);
+}
+/** A plain box standing on the floor. */
+function boxDraft() {
+    return (0, figure_model_1.applyFigureProposal)((0, figure_model_1.createFigureAsset)('Bin'), [
+        { kind: 'add-part', part: { id: 'bin', kind: 'box', dimensions: { width: 600, height: 300, depth: 400 } } },
+        { kind: 'attach', part: 'bin', to: { plane: 'mounting-plane' } }
+    ]);
+}
+/** A table: a top on four legs. */
+function tableDraft() {
+    return (0, figure_model_1.applyFigureProposal)((0, figure_model_1.createFigureAsset)('Table'), [
+        { kind: 'add-part', part: { id: 'top', kind: 'box', dimensions: { width: 1200, height: 40, depth: 700 } } },
+        { kind: 'add-part', part: { id: 'leg', kind: 'box', dimensions: { width: 50, height: 700, depth: 50 } } },
+        { kind: 'attach', part: 'leg', to: { plane: 'mounting-plane' } },
+        { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } }
+    ]);
+}
+/** A cabinet with a lamp on its top. */
+function lampDraft() {
+    return (0, figure_model_1.applyFigureProposal)((0, figure_model_1.createFigureAsset)('Cabinet'), [
+        { kind: 'add-part', part: { id: 'cabinet', kind: 'box', dimensions: { width: 600, height: 1200, depth: 500 } } },
+        { kind: 'add-part', part: { id: 'lamp', kind: 'cylinder', dimensions: { radius: 40, length: 80 } } },
+        { kind: 'attach', part: 'cabinet', to: { plane: 'mounting-plane' } },
+        { kind: 'attach', part: 'lamp', to: { part: 'cabinet', face: 'top' } }
+    ]);
+}
+/* ── The scenarios ────────────────────────────────────────────────────────────────────── */
+const accent = (target, colour, token = 'palette.accent') => ({ kind: 'set-material', target, material: { token }, palette: { [token]: colour } });
+exports.FIGURE_AI_SCENARIOS = [
+    {
+        id: 'roll-press',
+        title: '새 피규어: 프레임 안 두 롤러, 서로 다른 색',
+        covers: ['add-part cylinder', 'attach', 'set-material'],
+        prompt: 'two cylindrical rollers inside a simple rectangular press frame; make the rollers visually distinct',
+        name: 'Roll press',
+        /*
+          Two rollers -- two parts, or one repeated in a row -- that stand out: a colour the frame does not have. Read so after
+          a model's row of two was failed for being one part (2026-11-03, the first runs).
+        */
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const rollers = parts.filter(p => p.kind === 'ellipse');
+            const frame = parts.filter(p => p.kind !== 'ellipse');
+            const misses = [...loose(parts)];
+            const drawn = rollers.reduce((sum, r) => sum + r.copies, 0);
+            if (drawn < 2)
+                misses.push(`${drawn} round bodies drawn, two rollers asked`);
+            if (!frame.length)
+                misses.push('no frame');
+            else if (rollers.length && rollers.every(r => frame.some(f => f.colour === r.colour)))
+                misses.push(`the rollers are the frame's colour, ${rollers[0].colour}`);
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1000, height: 80, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'roller-a', kind: 'cylinder', dimensions: { radius: 80, length: 400 } } },
+            { kind: 'add-part', part: { id: 'roller-b', kind: 'cylinder', dimensions: { radius: 80, length: 400 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'roller-a', to: { part: 'base', face: 'top' }, align: { x: { mm: -200 } } },
+            { kind: 'attach', part: 'roller-b', to: { part: 'base', face: 'top' }, align: { x: { mm: 200 } } },
+            accent('roller-b', '#d08a2c')
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1000, height: 80, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'roller-a', kind: 'cylinder', dimensions: { radius: 80, length: 400 } } },
+            { kind: 'add-part', part: { id: 'roller-b', kind: 'cylinder', dimensions: { radius: 80, length: 400 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'roller-a', to: { part: 'base', face: 'top' }, align: { x: { mm: -200 } } },
+            { kind: 'attach', part: 'roller-b', to: { part: 'base', face: 'top' }, align: { x: { mm: 200 } } },
+            /* Rollers drawn in the frame's own colour: nothing stands out. */
+            accent('roller-a', '#477b9e', 'palette.primary'),
+            accent('roller-b', '#477b9e', 'palette.primary'),
+            accent('base', '#477b9e', 'palette.primary')
+        ])
+    },
+    {
+        id: 'lift-table',
+        title: '새 피규어: 받침 · 기둥 · 상판을 쌓기',
+        covers: ['attach part face', 'stacking'],
+        prompt: '리프트 테이블: 바닥에 넓은 받침, 그 위에 원기둥 기둥, 기둥 위에 받침만 한 상판',
+        name: 'Lift table',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            if (parts.length < 3)
+                return [...misses, `${parts.length} parts, three asked`];
+            const sorted = [...parts].sort((a, b) => top(b) - top(a));
+            const [highest] = sorted;
+            const column = parts.find(p => p.kind === 'ellipse');
+            if (!column)
+                misses.push('no round column');
+            else {
+                if (!(highest.extent.x * highest.extent.z > column.extent.x * column.extent.z))
+                    misses.push('the top is not wider than the column');
+                if (!parts.some(p => p !== column && near(bottom(column), top(p), 1)))
+                    misses.push('the column does not stand on another part');
+                if (!near(bottom(highest), top(column), 1))
+                    misses.push('the top does not sit on the column');
+            }
+            if (!parts.some(p => near(bottom(p), 0, 1)))
+                misses.push('nothing stands on the floor');
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1200, height: 80, depth: 800 } } },
+            { kind: 'add-part', part: { id: 'column', kind: 'cylinder', dimensions: { radius: 90, length: 600 } } },
+            { kind: 'add-part', part: { id: 'top', kind: 'box', dimensions: { width: 1200, height: 60, depth: 800 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'column', to: { part: 'base', face: 'top' } },
+            { kind: 'attach', part: 'top', to: { part: 'column', face: 'top' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'box', dimensions: { width: 1200, height: 80, depth: 800 } } },
+            { kind: 'add-part', part: { id: 'column', kind: 'cylinder', dimensions: { radius: 90, length: 600 } } },
+            { kind: 'add-part', part: { id: 'top', kind: 'box', dimensions: { width: 1200, height: 60, depth: 800 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'column', to: { part: 'base', face: 'top' } },
+            { kind: 'attach', part: 'top', to: { part: 'base', face: 'top' } }
+        ])
+    },
+    {
+        id: 'elbow-flange',
+        title: '새 피규어: 엘보 배관과 끝의 플랜지 (ADR-0100 §16.2)',
+        covers: ['add-part pipe', 'bend', 'attach to a pipe end'],
+        prompt: '바닥에서 위로 올라가다 90도 꺾여 옆으로 가는 지름 80 배관, 배관 끝에 원판 플랜지',
+        name: 'Elbow',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const pipe = parts.find(p => p.kind === 'sweep');
+            if (!pipe)
+                return [...misses, 'no part along a path (a pipe)'];
+            if (!pipe.shape?.sweep?.path?.some((s) => s.kind === 'bend'))
+                misses.push('the pipe has no bend');
+            if (!parts.some(p => p.on === pipe.id))
+                misses.push('nothing is fastened to the pipe');
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+            { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 70, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { part: 'pipe', face: 'right' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'pipe', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }] } },
+            { kind: 'attach', part: 'pipe', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 70, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { plane: 'mounting-plane' } }
+        ])
+    },
+    {
+        id: 'conveyor',
+        title: '새 피규어: 프레임 위 롤러를 반복으로',
+        covers: ['make-repeat'],
+        prompt: 'a roller conveyor: a 2 m long frame with rollers repeated along its length every 150 mm',
+        name: 'Conveyor',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const rows = (after.joints ?? []).filter((j) => j.repeat);
+            if (!rows.length)
+                misses.push('no part repeated in a row');
+            const geometry = (0, figure_model_1.compileFigureAsset)(after).evaluate().geometry;
+            if (geometry.length < 8)
+                misses.push(`${geometry.length} bodies drawn, a row of rollers asked`);
+            const longest = Math.max(...parts.map(p => Math.max(p.extent.x, p.extent.z)));
+            if (longest < 1500)
+                misses.push(`the longest part is ${Math.round(longest)} mm, a 2 m frame asked`);
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'frame', kind: 'box', dimensions: { width: 2000, height: 100, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 480 } } },
+            { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } },
+            { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 150 }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'frame', kind: 'box', dimensions: { width: 2000, height: 100, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 480 } } },
+            { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } },
+            { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } }
+        ])
+    },
+    {
+        id: 'two-joint-arm',
+        title: '새 피규어: 두 관절로 도는 팔',
+        covers: ['set-joint revolute', 'a joint on a moving part'],
+        prompt: '바닥 받침 위에 아래팔과 위팔이 있고, 받침-아래팔, 아래팔-위팔이 각각 회전 관절인 로봇 팔',
+        name: 'Arm',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const turning = parts.filter(p => p.motion.includes('revolute'));
+            if (turning.length < 2)
+                misses.push(`${turning.length} turning joints, two asked`);
+            else if (!turning.some(p => turning.some(q => q.id === p.on)))
+                misses.push('no turning part hangs from another turning part');
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'cylinder', dimensions: { radius: 150, length: 100 } } },
+            { kind: 'add-part', part: { id: 'lower-arm', kind: 'box', dimensions: { width: 80, height: 500, depth: 80 } } },
+            { kind: 'add-part', part: { id: 'upper-arm', kind: 'box', dimensions: { width: 60, height: 400, depth: 60 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'set-joint', joint: { id: 'shoulder', body0: { part: 'base', face: 'top' }, body1: { part: 'lower-arm' }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 }] } },
+            { kind: 'set-joint', joint: { id: 'elbow', body0: { part: 'lower-arm', face: 'top' }, body1: { part: 'upper-arm' }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -120, upperLimit: 120 }] } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'base', kind: 'cylinder', dimensions: { radius: 150, length: 100 } } },
+            { kind: 'add-part', part: { id: 'lower-arm', kind: 'box', dimensions: { width: 80, height: 500, depth: 80 } } },
+            { kind: 'add-part', part: { id: 'upper-arm', kind: 'box', dimensions: { width: 60, height: 400, depth: 60 } } },
+            { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
+            { kind: 'set-joint', joint: { id: 'shoulder', body0: { part: 'base', face: 'top' }, body1: { part: 'lower-arm' }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -90, upperLimit: 90 }] } },
+            { kind: 'attach', part: 'upper-arm', to: { part: 'lower-arm', face: 'top' } }
+        ])
+    },
+    {
+        id: 'cabinet-door',
+        title: '새 피규어: 경첩 문 0~90°와 여는 클립',
+        covers: ['set-joint limits', 'set-driver clip'],
+        prompt: 'a cabinet with one door on a hinge that opens from 0 to 90 degrees, and a clip that opens it in 2 seconds',
+        name: 'Cabinet',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const door = parts.find(p => p.motion.includes('revolute'));
+            if (!door)
+                return [...misses, 'no hinged part'];
+            const span = door.limits.map(l => (l.upper ?? Infinity) - (l.lower ?? -Infinity))[0];
+            if (!(span >= 80 && span <= 100))
+                misses.push(`the hinge turns ${span}°, 0 to 90 asked`);
+            if (!clipsPlaying(after, door.controls).length)
+                misses.push("no clip plays the door's hinge");
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'cabinet', kind: 'box', dimensions: { width: 600, height: 1200, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'door', kind: 'box', dimensions: { width: 600, height: 1200, depth: 20 } } },
+            { kind: 'attach', part: 'cabinet', to: { plane: 'mounting-plane' } },
+            { kind: 'set-joint', joint: { id: 'hinge', body0: { part: 'cabinet', face: 'front' }, body1: { part: 'door' }, origin: { align: { x: 'min' } }, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'door-open' } }] } },
+            { kind: 'set-driver', state: 'door-open', clip: 'open', duration: 2, keys: [{ seconds: 0, value: 0 }, { seconds: 2, value: 90 }], loop: 'hold' }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'cabinet', kind: 'box', dimensions: { width: 600, height: 1200, depth: 500 } } },
+            { kind: 'add-part', part: { id: 'door', kind: 'box', dimensions: { width: 600, height: 1200, depth: 20 } } },
+            { kind: 'attach', part: 'cabinet', to: { plane: 'mounting-plane' } },
+            { kind: 'set-joint', joint: { id: 'hinge', body0: { part: 'cabinet', face: 'front' }, body1: { part: 'door' }, origin: { align: { x: 'min' } }, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: 0, upperLimit: 90, state: { id: 'door-open' } }] } }
+        ])
+    },
+    {
+        id: 'hopper',
+        title: '새 피규어: 윗면이 넓은 사각 호퍼 (ADR-0100 §16.1)',
+        covers: ['add-part tapered-box'],
+        prompt: '아래가 좁고 위가 넓은 사각 호퍼: 아랫면 300×300, 윗면 800×800, 높이 600, 모서리는 둥글게',
+        name: 'Hopper',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const hopper = parts.find(p => p.kind === 'tapered');
+            if (!hopper)
+                return [...misses, 'no part whose top is another size than its bottom'];
+            const l = hopper.shape.loft;
+            const [from, to] = [l.section.size, l.to.size];
+            if (!(to.x > from.x && to.z > from.z))
+                misses.push(`its top ${to.x}×${to.z} is not wider than its bottom ${from.x}×${from.z}`);
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'hopper', kind: 'tapered-box', dimensions: { width: 300, depth: 300, height: 600, topWidth: 800, topDepth: 800, round: 30, topRound: 60 } } },
+            { kind: 'attach', part: 'hopper', to: { plane: 'mounting-plane' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'hopper', kind: 'tapered-box', dimensions: { width: 800, depth: 800, height: 600, topWidth: 300, topDepth: 300, round: 60, topRound: 30 } } },
+            { kind: 'attach', part: 'hopper', to: { plane: 'mounting-plane' } }
+        ])
+    },
+    {
+        id: 'quadruped-legs',
+        title: '새 피규어: 몸통과 좌우 대칭인 다리 넷, 다리마다 무릎',
+        covers: ['mirror-part chain', 'joints'],
+        prompt: 'a four-legged robot body: a box body and four legs, each leg a thigh and a shin with a hip and a knee joint; the legs symmetric left and right',
+        name: 'Quadruped',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const moving = parts.filter(p => p.motion.length);
+            if (moving.length < 8)
+                misses.push(`${moving.length} moving parts, four legs of two joints asked`);
+            /* Left and right: every moving part has its reflection across the body's middle along Z or X. */
+            const mirrored = (p, axis) => moving.some(q => q !== p && near(q.centre[axis], -p.centre[axis], 1) && ['x', 'y', 'z'].filter(x => x !== axis).every(x => near(q.centre[x], p.centre[x], 1)));
+            const lonely = moving.filter(p => !mirrored(p, 'z') && !mirrored(p, 'x'));
+            if (lonely.length)
+                misses.push(`no mirror of ${lonely.map(p => p.id).join(', ')}`);
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'body', kind: 'box', dimensions: { width: 800, height: 200, depth: 300 } } },
+            { kind: 'set-placement', placement: 'floor' },
+            { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' }, gap: 500 },
+            { kind: 'add-part', part: { id: 'fl-thigh', kind: 'box', dimensions: { width: 60, height: 250, depth: 60 } } },
+            { kind: 'add-part', part: { id: 'fl-shin', kind: 'box', dimensions: { width: 40, height: 250, depth: 40 } } },
+            { kind: 'set-joint', joint: { id: 'fl-hip', body0: { part: 'body', face: 'bottom' }, body1: { part: 'fl-thigh' }, origin: { align: { x: 'max', z: 'max' } }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -45, upperLimit: 45 }] } },
+            { kind: 'set-joint', joint: { id: 'fl-knee', body0: { part: 'fl-thigh', face: 'bottom' }, body1: { part: 'fl-shin' }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: 0, upperLimit: 120 }] } },
+            { kind: 'mirror-part', target: 'fl-thigh', axis: 'z', chain: true, prefix: { from: 'fl', to: 'fr' } },
+            { kind: 'mirror-part', target: 'fl-thigh', axis: 'x', chain: true, prefix: { from: 'fl', to: 'bl' }, keepMotion: true },
+            { kind: 'mirror-part', target: 'fr-thigh', axis: 'x', chain: true, prefix: { from: 'fr', to: 'br' }, keepMotion: true }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'body', kind: 'box', dimensions: { width: 800, height: 200, depth: 300 } } },
+            { kind: 'set-placement', placement: 'floor' },
+            { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' }, gap: 500 },
+            { kind: 'add-part', part: { id: 'fl-thigh', kind: 'box', dimensions: { width: 60, height: 250, depth: 60 } } },
+            { kind: 'add-part', part: { id: 'fl-shin', kind: 'box', dimensions: { width: 40, height: 250, depth: 40 } } },
+            { kind: 'set-joint', joint: { id: 'fl-hip', body0: { part: 'body', face: 'bottom' }, body1: { part: 'fl-thigh' }, origin: { align: { x: 'max', z: 'max' } }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: -45, upperLimit: 45 }] } },
+            { kind: 'set-joint', joint: { id: 'fl-knee', body0: { part: 'fl-thigh', face: 'bottom' }, body1: { part: 'fl-shin' }, motion: [{ type: 'revolute', axis: 'Z', lowerLimit: 0, upperLimit: 120 }] } }
+        ])
+    },
+    {
+        id: 'pipeline-run',
+        title: '새 피규어: 굽힘 셋 이상인 곡선 배관과 끝 플랜지 (ADR-0100 §16.2)',
+        covers: ['add-part pipe', 'several bends', 'attach to a pipe end'],
+        prompt: '펌프에서 탱크로 가는 지름 100 배관: 바닥에서 1m 올라가 옆으로 꺾고, 다시 앞으로 꺾고, 마지막에 다시 옆으로 꺾여 탱크 옆면으로 들어가게. 배관 끝에는 플랜지',
+        name: 'Pipeline',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const pipes = parts.filter(p => p.kind === 'sweep');
+            const bends = pipes.reduce((n, p) => n + (p.shape?.sweep?.path ?? []).filter((s) => s.kind === 'bend').length, 0);
+            if (!pipes.length)
+                return [...misses, 'no part along a path (a pipe)'];
+            if (bends < 3)
+                misses.push(`${bends} bends, three asked`);
+            /* A flange on the pipe's far end, up in the air: not on its start, on the floor. */
+            if (!parts.some(p => pipes.some(q => q.id === p.on) && p.kind !== 'sweep' && bottom(p) > 100))
+                misses.push('no flange on the end of a pipe');
+            return misses;
+        },
+        /* Up Y; toward 90 is +X; heading +X, toward 0 is +Z; heading +Z, toward 180 is +X again -- its end the right face. */
+        reference: steps([
+            { kind: 'add-part', part: { id: 'line', kind: 'pipe', dimensions: { radius: 50, wall: 5 }, path: [{ line: 1000 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 800 }, { bend: { radius: 150, angle: 90, toward: 0 } }, { line: 600 }, { bend: { radius: 150, angle: 90, toward: 180 } }, { line: 400 }] } },
+            { kind: 'attach', part: 'line', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 90, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { part: 'line', face: 'right' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'line', kind: 'pipe', dimensions: { radius: 50, wall: 5 }, path: [{ line: 1000 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 800 }] } },
+            { kind: 'attach', part: 'line', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 90, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { part: 'line', face: 'right' } }
+        ])
+    },
+    {
+        id: 'pipe-rack',
+        title: '새 피규어: 나란히 가는 곡선 배관 두 줄',
+        covers: ['several pipes', 'attach align'],
+        prompt: 'two parallel pipes side by side, 300 mm apart, each rising 800 mm and bending 90 degrees to run 1 m sideways',
+        name: 'Pipe rack',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const bent = parts.filter(p => p.kind === 'sweep' && (p.shape?.sweep?.path ?? []).some((s) => s.kind === 'bend'));
+            if (bent.length < 2)
+                return [...misses, `${bent.length} bent pipes, two asked`];
+            const [a, b] = bent;
+            const apart = Math.hypot(a.centre.x - b.centre.x, a.centre.z - b.centre.z);
+            if (!(apart > 200 && apart < 400))
+                misses.push(`the pipes are ${Math.round(apart)} mm apart, 300 asked`);
+            if (!near(a.extent.y, b.extent.y, 1))
+                misses.push('the pipes rise to different heights');
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'pipe-a', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 800 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 1000 }] } },
+            { kind: 'add-part', part: { id: 'pipe-b', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 800 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 1000 }] } },
+            { kind: 'attach', part: 'pipe-a', to: { plane: 'mounting-plane' }, align: { z: { mm: -150 } } },
+            { kind: 'attach', part: 'pipe-b', to: { plane: 'mounting-plane' }, align: { z: { mm: 150 } } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'pipe-a', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 800 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 1000 }] } },
+            { kind: 'add-part', part: { id: 'pipe-b', kind: 'pipe', dimensions: { radius: 40, wall: 4 }, path: [{ line: 800 }] } },
+            { kind: 'attach', part: 'pipe-a', to: { plane: 'mounting-plane' }, align: { z: { mm: -150 } } },
+            { kind: 'attach', part: 'pipe-b', to: { plane: 'mounting-plane' }, align: { z: { mm: 150 } } }
+        ])
+    },
+    {
+        id: 'tapering-bent-bar',
+        title: '새 피규어: 아래는 굵고 위로 갈수록 가는 휜 막대 (ADR-0100 §16.2.9)',
+        /*
+          One pipe narrowing along its length (endRadius), or pieces of different sizes fastened end to end: any such making
+          passes. The check reads only what stands: something bends, and it is thicker at its lowest than at its highest.
+        */
+        covers: ['pipe endRadius', 'pipe wall 0', 'pieces of different sizes fastened end to end'],
+        prompt: '바닥에서 올라가며 한 번 휘어지는 막대. 아래쪽은 지름 80으로 굵고, 위로 갈수록 가늘어져 끝은 지름 40',
+        name: 'Bent bar',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            if (!parts.some(p => p.kind === 'sweep' && (p.shape?.sweep?.path ?? []).some((s) => s.kind === 'bend')))
+                misses.push('nothing bends');
+            /* How thick each part is at each height: a pipe at its stations, its section there; anything else at its bottom and top. */
+            const across = (section) => 2 * Math.max(...Object.values(section.radius ?? {}).map(Number), ...Object.values(section.size ?? {}).map(v => Number(v) / 2));
+            const samples = parts.flatMap(p => {
+                const w = p.shape?.sweep;
+                if (!w)
+                    return [{ y: bottom(p), thick: Math.min(p.extent.x, p.extent.z) }, { y: top(p), thick: Math.min(p.extent.x, p.extent.z) }];
+                const pose = (0, figure_model_1.compileFigureAsset)(after).evaluate().geometry.find(g => g.id === p.id)?.pose;
+                const y = (q) => (pose ? pose.r[1][0] * q[0] + pose.r[1][1] * q[1] + pose.r[1][2] * q[2] + pose.t[1] : q[1]);
+                return w.stations.map((st) => ({ y: y(st.p), thick: across((0, figure_model_1.figureSweepSectionAt)(w, st.t)) }));
+            });
+            const low = samples.reduce((a, b) => (b.y < a.y ? b : a));
+            const high = samples.reduce((a, b) => (b.y > a.y ? b : a));
+            if (!(low.thick > high.thick + 1))
+                misses.push(`${Math.round(low.thick)} thick at its lowest, ${Math.round(high.thick)} at its highest: thicker below asked`);
+            if (parts.some(p => p.shape?.sweep?.wall !== undefined))
+                misses.push('a bar is hollow');
+            return misses;
+        },
+        reference: steps([
+            { kind: 'add-part', part: { id: 'bar', kind: 'pipe', dimensions: { radius: 40, wall: 0, endRadius: 20 }, path: [{ line: 600 }, { bend: { radius: 200, angle: 60, toward: 90 } }, { line: 300 }] } },
+            { kind: 'attach', part: 'bar', to: { plane: 'mounting-plane' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'bar', kind: 'pipe', dimensions: { radius: 20, wall: 0, endRadius: 40 }, path: [{ line: 600 }, { bend: { radius: 200, angle: 60, toward: 90 } }, { line: 300 }] } },
+            { kind: 'attach', part: 'bar', to: { plane: 'mounting-plane' } }
+        ])
+    },
+    {
+        id: 'pipe-down-into-tank',
+        title: '새 피규어: 아래로 꺾여 내려가는 배관 끝에 플랜지 (ADR-0100 §16.2.7)',
+        covers: ['pipe end heading down', 'attach to a pipe end'],
+        prompt: '바닥에서 1m 올라가 옆으로 800mm 가다가 아래로 꺾여 500mm 내려가는 배관. 내려간 끝에 플랜지를 달아 줘',
+        name: 'Drop pipe',
+        check: after => {
+            const parts = scenarioPartsOf(after);
+            const misses = [...loose(parts)];
+            const pipe = parts.find(p => p.kind === 'sweep' && p.shape.sweep.stations.at(-1).n[1] < -0.999);
+            if (!pipe)
+                return [...misses, 'no pipe ends heading down'];
+            const joints = (after.joints ?? []);
+            const onEnd = joints.find(j => j.body0?.part === pipe.id && pipe.shape.faces[j.body0.face]?.station === 'last');
+            if (!onEnd)
+                misses.push("nothing is fastened to the pipe's lower end");
+            return misses;
+        },
+        /* Up; toward 90 is +X; heading +X, toward 90 turns it down. Its end, heading down, is its bottom face. */
+        reference: steps([
+            { kind: 'add-part', part: { id: 'drop', kind: 'pipe', dimensions: { radius: 50, wall: 5 }, path: [{ line: 1000 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 800 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 500 }] } },
+            { kind: 'attach', part: 'drop', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 90, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { part: 'drop', face: 'bottom' } }
+        ]),
+        wrong: steps([
+            { kind: 'add-part', part: { id: 'drop', kind: 'pipe', dimensions: { radius: 50, wall: 5 }, path: [{ line: 1000 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 800 }, { bend: { radius: 150, angle: 90, toward: 90 } }, { line: 500 }] } },
+            { kind: 'attach', part: 'drop', to: { plane: 'mounting-plane' } },
+            { kind: 'add-part', part: { id: 'flange', kind: 'cylinder', dimensions: { radius: 90, length: 20 } } },
+            { kind: 'attach', part: 'flange', to: { plane: 'mounting-plane' } }
+        ])
+    },
+    {
+        id: 'mixer-port',
+        title: '고치기: 포트 폭 두 배와 새 색, 몸통은 그대로',
+        covers: ['set-section across', 'set-material', 'a revision changes only what is asked'],
+        prompt: 'make the port twice as wide and give it an accent colour',
+        base: mixerDraft,
+        check: (after, before) => portRevisionMisses(before, after),
+        reference: steps([{ kind: 'set-section', part: 'port', across: { x: 160 } }, accent('port', '#d08a2c')]),
+        wrong: steps([accent('port', '#d08a2c')])
+    },
+    {
+        id: 'open-tote',
+        title: '고치기: 상자를 위가 열린 통으로, 벽 10mm',
+        covers: ['set-cavity'],
+        prompt: '이 상자를 위가 열린 통으로 만들어 줘. 벽 두께 10mm, 바닥 두께 15mm',
+        base: boxDraft,
+        check: after => {
+            const bin = scenarioPartsOf(after).find(p => p.id === 'bin');
+            if (!bin)
+                return ['the box is gone'];
+            const c = bin.shape?.cavity;
+            if (!c)
+                return ['no inside'];
+            const misses = [];
+            if (c.end !== 'open')
+                misses.push('its top is not open');
+            if (c.start === 'open')
+                misses.push('its bottom is open too');
+            if (!Object.values(c.wall).every(w => near(w, 10)))
+                misses.push(`walls ${Object.values(c.wall).join(', ')}, 10 asked`);
+            return misses;
+        },
+        reference: steps([{ kind: 'set-cavity', part: 'bin', cavity: { wall: 10, start: { closed: 15 }, end: 'open' } }]),
+        wrong: steps([{ kind: 'set-cavity', part: 'bin', cavity: { wall: 10, start: 'open', end: 'open' } }])
+    },
+    {
+        id: 'pipe-extend',
+        title: '고치기: 관 끝에 아래로 꺾이는 굽힘과 직선 더하기 (ADR-0100 §16.2)',
+        covers: ['set-pipe path', 'bend direction'],
+        prompt: '이 관의 끝에서 아래쪽으로 90도 한 번 더 꺾고 300mm 더 뻗게 해 줘. 앞부분은 그대로',
+        base: elbowDraft,
+        check: (after, before) => {
+            const was = scenarioPartsOf(before).find(p => p.id === 'pipe');
+            const now = scenarioPartsOf(after).find(p => p.id === 'pipe');
+            if (!now?.shape?.sweep)
+                return ['the pipe is gone'];
+            const misses = [];
+            const [p0, p1] = [was.shape.sweep.path, now.shape.sweep.path];
+            if (JSON.stringify(p1.slice(0, p0.length)) !== JSON.stringify(p0))
+                misses.push('the pipe as it was is changed');
+            if (p1.length !== p0.length + 2)
+                misses.push(`${p1.length - p0.length} pieces added, a bend and a run asked`);
+            else {
+                const [bend, run] = p1.slice(p0.length);
+                if (!(bend.kind === 'bend' && near(bend.angle, 90)))
+                    misses.push(`it adds ${JSON.stringify(bend)}, a 90° bend asked`);
+                if (!(run.kind === 'line' && near(run.length, 300)))
+                    misses.push(`it adds ${JSON.stringify(run)}, a 300 mm run asked`);
+            }
+            const heading = now.shape.sweep.stations.at(-1).n;
+            if (!(heading[1] < -0.999))
+                misses.push(`it ends heading ${heading.map(v => Math.round(v * 100) / 100).join(', ')}, down asked`);
+            return misses;
+        },
+        /* Heading +X after the first bend, its section's first axis is still +Z and its second is now -Y: 90 turns it down. */
+        reference: steps([{ kind: 'set-pipe', part: 'pipe', path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 300 }] }]),
+        wrong: steps([{ kind: 'set-pipe', part: 'pipe', path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 400 }, { bend: { radius: 120, angle: 90, toward: 270 } }, { line: 300 }] }])
+    },
+    {
+        id: 'pipe-to-duct',
+        title: '고치기: 원형 관을 사각 덕트로, 경로는 그대로',
+        covers: ['set-pipe section'],
+        prompt: '이 관을 가로 120, 세로 80 의 사각 덕트로 바꿔 줘. 경로는 그대로',
+        base: elbowDraft,
+        check: (after, before) => {
+            const was = scenarioPartsOf(before).find(p => p.id === 'pipe');
+            const now = scenarioPartsOf(after).find(p => p.id === 'pipe');
+            if (!now?.shape?.sweep)
+                return ['the pipe is gone'];
+            const misses = [];
+            const s = now.shape.sweep.section;
+            if (s.kind !== 'rectangle')
+                return [`its section is a ${s.kind}, a rectangle asked`];
+            const sizes = [s.size.x, s.size.z].sort((a, b) => a - b);
+            if (!(near(sizes[0], 80) && near(sizes[1], 120)))
+                misses.push(`its section is ${s.size.x}×${s.size.z}, 120×80 asked`);
+            if (JSON.stringify(now.shape.sweep.path) !== JSON.stringify(was.shape.sweep.path))
+                misses.push('its path changed');
+            return misses;
+        },
+        reference: steps([{ kind: 'set-pipe', part: 'pipe', width: 120, depth: 80, round: 0 }]),
+        wrong: steps([{ kind: 'set-pipe', part: 'pipe', width: 120, depth: 80, round: 0, path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 90 } }, { line: 300 }] }])
+    },
+    {
+        id: 'pipe-to-solid-bar',
+        title: '고치기: 관을 굵은 속찬 막대로, 경로는 그대로',
+        covers: ['set-pipe radius', 'wall 0'],
+        prompt: '이 관을 지름 60 의 속이 찬 막대로 바꿔 줘',
+        base: elbowDraft,
+        check: (after, before) => {
+            const was = scenarioPartsOf(before).find(p => p.id === 'pipe');
+            const now = scenarioPartsOf(after).find(p => p.id === 'pipe');
+            if (!now?.shape?.sweep)
+                return ['the pipe is gone'];
+            const misses = [];
+            const s = now.shape.sweep.section;
+            if (s.kind !== 'ellipse' || !near(s.radius.x, 30))
+                misses.push(`its section is ${JSON.stringify(s)}, a 60 mm circle asked`);
+            if (now.shape.sweep.wall !== undefined)
+                misses.push('it is still hollow');
+            if (JSON.stringify(now.shape.sweep.path) !== JSON.stringify(was.shape.sweep.path))
+                misses.push('its path changed');
+            return misses;
+        },
+        reference: steps([{ kind: 'set-pipe', part: 'pipe', radius: 30, wall: 0 }]),
+        wrong: steps([{ kind: 'set-pipe', part: 'pipe', radius: 30 }])
+    },
+    {
+        id: 'pipe-narrow',
+        title: '고치기: 관이 끝으로 갈수록 가늘어지게 (ADR-0100 §16.2.9)',
+        covers: ['set-pipe endRadius'],
+        prompt: '이 관이 끝으로 갈수록 가늘어져서 끝에서는 지름 40 이 되게 해 줘. 시작 굵기와 경로는 그대로',
+        base: elbowDraft,
+        check: (after, before) => {
+            const was = scenarioPartsOf(before).find(p => p.id === 'pipe');
+            const now = scenarioPartsOf(after).find(p => p.id === 'pipe');
+            if (!now?.shape?.sweep)
+                return ['the pipe is gone'];
+            const w = now.shape.sweep;
+            const misses = [];
+            if (!w.to)
+                misses.push(`it does not narrow: one section, ${JSON.stringify(w.section)}, end to end`);
+            else if (!(w.to.kind === 'ellipse' && near(w.to.radius.x, 20)))
+                misses.push(`its end is ${JSON.stringify(w.to)}, a 40 mm circle asked`);
+            if (!near(w.section.radius?.x ?? 0, was.shape.sweep.section.radius.x))
+                misses.push('its start changed');
+            if (JSON.stringify(w.path) !== JSON.stringify(was.shape.sweep.path))
+                misses.push('its path changed');
+            return misses;
+        },
+        reference: steps([{ kind: 'set-pipe', part: 'pipe', endRadius: 20 }]),
+        wrong: steps([{ kind: 'set-pipe', part: 'pipe', radius: 20 }])
+    },
+    {
+        id: 'pipe-turn-other-way',
+        title: '고치기: 관이 반대쪽(-X)으로 꺾이게',
+        covers: ['set-pipe bend toward'],
+        prompt: '이 관이 오른쪽이 아니라 반대쪽(-X 방향)으로 꺾이게 해 줘. 길이와 굵기는 그대로',
+        base: elbowDraft,
+        check: after => {
+            const now = scenarioPartsOf(after).find(p => p.id === 'pipe');
+            if (!now?.shape?.sweep)
+                return ['the pipe is gone'];
+            const misses = [];
+            const end = now.shape.sweep.stations.at(-1);
+            if (!(end.n[0] < -0.999))
+                misses.push(`it ends heading ${end.n.map((v) => Math.round(v * 100) / 100).join(', ')}, -X asked`);
+            const lengths = now.shape.sweep.path.map((p) => p.length ?? p.radius);
+            if (JSON.stringify(lengths) !== JSON.stringify([500, 120, 400]))
+                misses.push(`its runs and radius are ${lengths.join(', ')}, kept asked`);
+            return misses;
+        },
+        reference: steps([{ kind: 'set-pipe', part: 'pipe', path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 270 } }, { line: 400 }] }]),
+        wrong: steps([{ kind: 'set-pipe', part: 'pipe', path: [{ line: 500 }, { bend: { radius: 120, angle: 90, toward: 0 } }, { line: 400 }] }])
+    },
+    {
+        id: 'box-tapered-top',
+        title: '고치기: 상자 윗면을 절반 크기로 (ADR-0100 §16.1)',
+        covers: ['set-section top'],
+        prompt: '이 상자의 윗면을 가로세로 절반 크기로 줄여서 위로 갈수록 좁아지게 해 줘. 아랫면은 그대로',
+        base: boxDraft,
+        check: (after, before) => {
+            const was = scenarioPartsOf(before).find(p => p.id === 'bin');
+            const now = scenarioPartsOf(after).find(p => p.id === 'bin');
+            if (!now)
+                return ['the box is gone'];
+            if (now.kind !== 'tapered')
+                return [`it is a ${now.kind}, a tapered box asked`];
+            const misses = [];
+            const [from, to] = [now.shape.loft.section.size, now.shape.loft.to.size];
+            if (!(near(from.x, was.extent.x) && near(from.z, was.extent.z)))
+                misses.push(`its bottom is ${from.x}×${from.z}, kept asked`);
+            if (!(near(to.x, from.x / 2) && near(to.z, from.z / 2)))
+                misses.push(`its top is ${to.x}×${to.z}, half asked`);
+            return misses;
+        },
+        reference: steps([{ kind: 'set-section', part: 'bin', top: { across: { x: 300, z: 200 } } }]),
+        wrong: steps([{ kind: 'set-section', part: 'bin', across: { x: 300, z: 200 } }])
+    },
+    {
+        id: 'table-follows-width',
+        title: '고치기: 보드에서 폭을 바꾸면 상판이 따라가게',
+        covers: ['declare-instance-size', 'follow-size'],
+        prompt: '보드에서 이 테이블의 폭을 바꾸면 상판 폭이 따라 늘어나게 해 줘. 다리는 그대로',
+        base: tableDraft,
+        check: after => {
+            const inputs = after.document.model.inputs;
+            const width = inputs.find(i => i.id === 'size.x');
+            if (!width)
+                return ["the figure's size is not declared"];
+            const at = (x) => scenarioPartsOf({ ...after, designInputs: { ...after.designInputs, 'size.x': x } });
+            const was = Object.fromEntries(at(after.designInputs['size.x']).map(p => [p.id, p]));
+            const wider = Object.fromEntries(at(after.designInputs['size.x'] * 1.5).map(p => [p.id, p]));
+            const misses = [];
+            if (!(wider.top.extent.x > was.top.extent.x + 1))
+                misses.push('the top does not grow with the width');
+            if (!near(wider.leg.extent.x, was.leg.extent.x))
+                misses.push('the leg grows with the width');
+            return misses;
+        },
+        reference: steps([{ kind: 'declare-instance-size' }, { kind: 'follow-size', part: 'top', axes: ['x'] }]),
+        wrong: steps([{ kind: 'declare-instance-size' }])
+    },
+    {
+        id: 'status-lamp',
+        title: '고치기: 상태 값으로 램프 색 (데이터 바인딩)',
+        covers: ['set-data-schema', 'set-data-binding table'],
+        prompt: 'status 값이 ALARM 이면 램프를 빨간색으로 깜빡이고, NORMAL 이면 초록색으로 켜지게 해 줘',
+        base: lampDraft,
+        check: after => {
+            const bindings = (after.dataInterface?.bindings ?? []);
+            const table = bindings.find(b => b.rule === 'table' && (b.targets?.parts ?? []).includes('lamp'));
+            if (!table)
+                return ['no table binding on the lamp'];
+            const misses = [];
+            const red = (c) => !!c && /^#([ef][0-9a-f]|d[89a-f])[0-4][0-9a-f][0-4][0-9a-f]$/i.test(c);
+            const green = (c) => !!c && /^#[0-4][0-9a-f]([89a-f][0-9a-f])[0-6][0-9a-f]$/i.test(c);
+            if (!red(table.table?.ALARM?.color))
+                misses.push(`ALARM is ${table.table?.ALARM?.color ?? 'not there'}, red asked`);
+            if (table.table?.ALARM?.effect?.kind !== 'blink')
+                misses.push('ALARM does not blink');
+            if (!green(table.table?.NORMAL?.color))
+                misses.push(`NORMAL is ${table.table?.NORMAL?.color ?? 'not there'}, green asked`);
+            return misses;
+        },
+        reference: steps([
+            { kind: 'set-data-schema', schema: [{ name: 'status', kind: 'text', values: ['NORMAL', 'ALARM'] }] },
+            { kind: 'set-data-binding', binding: { id: 'lamp-status', accessor: 'status', rule: 'table', lookup: 'code', targets: { parts: ['lamp'] }, table: { ALARM: { color: '#ef4444', effect: { kind: 'blink' } }, NORMAL: { color: '#22c55e' } } } }
+        ]),
+        wrong: steps([
+            { kind: 'set-data-schema', schema: [{ name: 'status', kind: 'text', values: ['NORMAL', 'ALARM'] }] },
+            { kind: 'set-data-binding', binding: { id: 'lamp-status', accessor: 'status', rule: 'table', lookup: 'code', targets: { parts: ['lamp'] }, table: { ALARM: { color: '#ef4444' }, NORMAL: { color: '#22c55e' } } } }
+        ])
+    }
+];
+//# sourceMappingURL=figure-ai-scenarios.js.map