@hatiolab/figure-model 0.1.76 → 0.1.78

package/dist/validate.js

@@ -1,1119 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- *
- * Figure 원본 데이터 검증.
- *
- * 두 갈래로 돌려준다.
- *
- *   errors      형식·정합성이 깨진 것. **컴파일할 수 없다.**
- *   violations  형식은 맞으나 정책을 넘은 것. **컴파일을 막지 않는다.**
- *
- * 둘을 가르는 기준은 「이대로 세울 수 있는가」다. 치수가 없으면 세울 수 없으므로
- * error 다. 재질이 넷이면 세울 수는 있고 다만 draw call 이 는다 — violation 이다.
- *
- * 정책 위반을 막지 않는 것은 뜻이 있다. 막으면 사용자가 우회하고, **숫자로 보여
- * 주면 아낀다.** 랜드마크 설비 하나는 정교해도 되며, 그 대가가 도면 예산에 드러나면
- * 된다.
- *
- * 결측을 기본값으로 갈음하지 않는다. 값이 없는 것과 0 인 것은 다르고, 갈음하면
- * 저작자가 빠뜨린 것을 알 수 없다.
- */
-import { ANCHOR_RULES, AXES, CAPABILITY_NEEDS, FIGURE_CAPABILITIES, CURVED_PRIMITIVES, EXTRUDE_PRIMITIVES, CHANNEL_PATHS, DEFAULT_SIZING, DETAIL_LEVELS, FIGURE_PLACEMENTS, LABEL_WHENS, LIMITS, MATERIAL_PRESETS, MATERIAL_SLOTS, INTERPOLATIONS, PART_LIMIT, PART_ROLES, PRIMITIVE_KINDS, SEGMENTED_PRIMITIVES, SEGMENT_PRESETS, SIZING_RULES, SKIN, SURFACE_KINDS, isPlaceholderType, TYPE_LENGTH, TYPE_PATTERN, FIGURE_SOURCE_VERSION, JOINT_TYPES } from "./types.js";
-import { drawCallsOf, isDrawn, jointFrames, movingNames } from "./grouping.js";
-import { rotatedExtentOf } from "./blueprint.js";
-import { centredSource } from "./origin.js";
-import { groupKeyOf } from "./keys.js";
-function isObject(v) {
-    return typeof v === 'object' && v !== null && !Array.isArray(v);
-}
-function isFiniteNumber(v) {
-    return typeof v === 'number' && Number.isFinite(v);
-}
-function isNonEmptyString(v) {
-    return typeof v === 'string' && v.trim().length > 0;
-}
-class Collector {
-    errors = [];
-    violations = [];
-    error(code, path, message) {
-        this.errors.push({ code, path, message });
-    }
-    violate(code, message, actual, limit, reason) {
-        const v = { code, message };
-        if (actual !== undefined)
-            v.actual = actual;
-        if (limit !== undefined)
-            v.limit = limit;
-        if (reason) {
-            v.why = reason.why;
-            v.how = reason.how;
-        }
-        this.violations.push(v);
-    }
-    /** 유한한 수인지. 아니면 error 를 남기고 false. */
-    finite(v, path, label) {
-        if (isFiniteNumber(v))
-            return true;
-        this.error('not-finite', path, `${label}는 유한한 수여야 한다`);
-        return false;
-    }
-    /** 양수인지. */
-    positive(v, path, label) {
-        if (!this.finite(v, path, label))
-            return false;
-        if (v > 0)
-            return true;
-        this.error('not-positive', path, `${label}는 0 보다 커야 한다`);
-        return false;
-    }
-    /** 열거 값인지. */
-    oneOf(v, allowed, path, label) {
-        if (typeof v === 'string' && allowed.includes(v))
-            return true;
-        this.error('not-allowed', path, `${label}는 ${allowed.join(' · ')} 중 하나여야 한다`);
-        return false;
-    }
-}
-function validateVec3(c, v, path, label) {
-    if (!isObject(v)) {
-        c.error('not-object', path, `${label}는 { x, y, z } 여야 한다`);
-        return;
-    }
-    c.finite(v.x, `${path}.x`, `${label}.x`);
-    c.finite(v.y, `${path}.y`, `${label}.y`);
-    c.finite(v.z, `${path}.z`, `${label}.z`);
-}
-function validateTransform(c, part, path) {
-    const t = part.transform;
-    if (!isObject(t)) {
-        c.error('missing-transform', `${path}.transform`, 'transform 이 없다');
-        return;
-    }
-    if (!isObject(t.position)) {
-        c.error('missing-position', `${path}.transform.position`, 'position 이 없다');
-    }
-    else {
-        validateVec3(c, t.position, `${path}.transform.position`, 'position');
-    }
-    const size = t.size;
-    if (!isObject(size)) {
-        c.error('missing-size', `${path}.transform.size`, 'size 가 없다');
-    }
-    else {
-        // 바닥에 깔린 평면 단면(extrude)은 y 가 0 일 수 있으나 x·z 는 있어야 한다.
-        c.positive(size.x, `${path}.transform.size.x`, 'size.x');
-        c.positive(size.z, `${path}.transform.size.z`, 'size.z');
-        if (size.y !== undefined)
-            c.finite(size.y, `${path}.transform.size.y`, 'size.y');
-        else
-            c.error('missing-size', `${path}.transform.size.y`, 'size.y 가 없다 — 0 으로 갈음하지 않는다');
-    }
-    if (t.rotation !== undefined) {
-        if (!isObject(t.rotation)) {
-            c.error('not-object', `${path}.transform.rotation`, 'rotation 은 객체여야 한다');
-        }
-        else {
-            for (const axis of AXES) {
-                const value = t.rotation[axis];
-                if (value !== undefined)
-                    c.finite(value, `${path}.transform.rotation.${axis}`, `rotation.${axis}`);
-            }
-        }
-    }
-}
-/**
- * 볼록한가 — 모든 코너가 같은 쪽으로 돈다.
- *
- * 외적의 부호가 한 번이라도 뒤집히면 오목한 자리가 있다. 0 은 일직선이라 세지 않는다.
- */
-function isConvex(path) {
-    const points = path.filter(p => isObject(p) && isFiniteNumber(p.x) && isFiniteNumber(p.y));
-    if (points.length < 3)
-        return true;
-    let sign = 0;
-    for (let i = 0; i < points.length; i++) {
-        const a = points[i];
-        const b = points[(i + 1) % points.length];
-        const d = points[(i + 2) % points.length];
-        const cross = (b.x - a.x) * (d.y - b.y) - (b.y - a.y) * (d.x - b.x);
-        if (cross === 0)
-            continue;
-        const now = cross > 0 ? 1 : -1;
-        if (sign === 0)
-            sign = now;
-        else if (sign !== now)
-            return false;
-    }
-    return true;
-}
-function validatePart(c, raw, index, seen) {
-    const path = `parts[${index}]`;
-    if (!isObject(raw)) {
-        c.error('not-object', path, '부품은 객체여야 한다');
-        return;
-    }
-    // 이름 — 저장되는 식별자다
-    if (!isNonEmptyString(raw.name)) {
-        c.error('missing-name', `${path}.name`, '부품 이름이 없다 — 바인딩·애니메이션이 이 이름을 가리킨다');
-    }
-    else if (seen.has(raw.name)) {
-        c.error('duplicate-name', `${path}.name`, `부품 이름이 겹친다: ${raw.name}`);
-    }
-    else {
-        seen.add(raw.name);
-    }
-    const isPrimitive = c.oneOf(raw.primitive, PRIMITIVE_KINDS, `${path}.primitive`, 'primitive');
-    validateTransform(c, raw, path);
-    // 분할 수 — 곡면이 있는 프리미티브만 뜻이 있다
-    if (raw.segments !== undefined) {
-        if (!isFiniteNumber(raw.segments) || !Number.isInteger(raw.segments)) {
-            c.error('not-integer', `${path}.segments`, 'segments 는 정수여야 한다');
-        }
-        else if (raw.segments < LIMITS.minSegments) {
-            c.error('too-few-segments', `${path}.segments`, `segments 는 ${LIMITS.minSegments} 이상이어야 한다`);
-        }
-        else if (!SEGMENT_PRESETS.includes(raw.segments)) {
-            c.violate('segments-off-preset', `${raw.name ?? path}: 분할 수 ${raw.segments} 는 프리셋(${SEGMENT_PRESETS.join(' · ')}) 이 아니다`, raw.segments);
-        }
-        if (isPrimitive && !SEGMENTED_PRIMITIVES.includes(raw.primitive)) {
-            c.violate('segments-ignored', `${raw.name ?? path}: ${raw.primitive} 는 분할 수를 쓰지 않는다`);
-        }
-    }
-    // extrude 계열의 단면
-    if (raw.primitive === 'polygon') {
-        const shape = raw.shape;
-        const pathPoints = isObject(shape) ? shape.path : undefined;
-        if (!Array.isArray(pathPoints) || pathPoints.length < 3) {
-            c.error('missing-shape-path', `${path}.shape.path`, 'polygon 은 3 점 이상의 path 가 필요하다');
-        }
-        else {
-            pathPoints.forEach((p, i) => {
-                if (!isObject(p) || !isFiniteNumber(p.x) || !isFiniteNumber(p.y)) {
-                    c.error('bad-shape-point', `${path}.shape.path[${i}]`, 'path 의 점은 { x, y } 여야 한다');
-                }
-            });
-        }
-    }
-    /*
-      속을 판 단면.
-  
-      두께가 치수의 절반을 넘으면 안쪽이 남지 않는다. 그러면 그냥 덩어리이고, 저작자가
-      통으로 만들려던 것이 아니다.
-  
-      오목한 `polygon` 은 아직 못 판다. 안쪽 테를 만들려면 변을 안으로 밀어 이웃과
-      다시 만나게 해야 하는데, 오목한 자리에서는 그 교점이 도형 밖으로 나가 테가 제
-      몸을 가로지른다. **되는 척하고 엉킨 형상을 내놓지 않는다** — 여기서 잡는다.
-    */
-    const hollow = isObject(raw.shape) ? raw.shape.hollow : undefined;
-    if (isObject(hollow)) {
-        if (!EXTRUDE_PRIMITIVES.includes(raw.primitive)) {
-            c.violate('hollow-ignored', `${raw.name ?? path}: ${raw.primitive} 는 밀어 만드는 것이 아니라 속을 팔 수 없다`);
-        }
-        else if (c.positive(hollow.wall, `${path}.shape.hollow.wall`, 'hollow.wall')) {
-            if (hollow.floor !== undefined)
-                c.finite(hollow.floor, `${path}.shape.hollow.floor`, 'hollow.floor');
-            const size = isObject(raw.transform) && isObject(raw.transform.size) ? raw.transform.size : null;
-            const wall = hollow.wall;
-            const floor = isFiniteNumber(hollow.floor) ? hollow.floor : wall;
-            if (size) {
-                for (const axis of ['x', 'z']) {
-                    if (isFiniteNumber(size[axis]) && wall * 2 >= size[axis]) {
-                        c.error('hollow-too-thick', `${path}.shape.hollow.wall`, `벽 ${wall} 둘이 ${axis} 치수 ${size[axis]} 를 다 먹는다 — 팔 안쪽이 없다`);
-                    }
-                }
-                if (isFiniteNumber(size.y) && floor >= size.y) {
-                    c.error('hollow-too-thick', `${path}.shape.hollow.floor`, `바닥 ${floor} 가 높이 ${size.y} 를 다 먹는다 — 팔 안쪽이 없다`);
-                }
-            }
-            const outline = isObject(raw.shape) ? raw.shape.path : undefined;
-            if (raw.primitive === 'polygon' && Array.isArray(outline) && !isConvex(outline)) {
-                c.error('hollow-not-convex', `${path}.shape.hollow`, '오목한 단면은 아직 못 판다 — 안쪽 테가 제 몸을 가로지른다');
-            }
-        }
-    }
-    /*
-      재질 — 색은 토큰으로 온다.
-  
-      **능력의 닻에는 요구하지 않는다.** 자리(slot)와 문(port)은 그려지지 않으므로 색을 정하라는
-      것이 뜻이 없고, 요구하면 저작자가 아무 색이나 골라 넣게 된다 — 쓰이지 않는 값이 정본에 남는다.
-    */
-    validatePartCapability(c, raw, path);
-    const isAnchor = isObject(raw.capability);
-    if (!isObject(raw.material)) {
-        if (!isAnchor) {
-            c.error('missing-material', `${path}.material`, 'material 이 없다');
-        }
-    }
-    else {
-        const m = raw.material;
-        if (!isNonEmptyString(m.token) && m.preset === undefined) {
-            c.error('material-unresolvable', `${path}.material`, 'token 이나 preset 중 하나는 있어야 한다');
-        }
-        if (m.preset !== undefined)
-            c.oneOf(m.preset, MATERIAL_PRESETS, `${path}.material.preset`, 'preset');
-        if (m.flatShading !== undefined && typeof m.flatShading !== 'boolean') {
-            c.error('not-boolean', `${path}.material.flatShading`, 'flatShading 은 참·거짓이어야 한다');
-        }
-        if (m.transparent !== undefined && typeof m.transparent !== 'boolean') {
-            c.error('not-boolean', `${path}.material.transparent`, 'transparent 는 참·거짓이어야 한다');
-        }
-        /*
-          켜진 모습. 있으면 램프다.
-    
-          세기는 0~1 이다. 위로 열어 두면 저작자가 5 를 넣어 흰 덩어리를 만든다 — 화면에서는
-          형상이 사라지는데 오류는 아니라서 무엇이 잘못됐는지 알 수 없다.
-        */
-        if (m.emissive !== undefined) {
-            if (!isObject(m.emissive)) {
-                c.error('not-object', `${path}.material.emissive`, 'emissive 는 객체여야 한다');
-            }
-            else {
-                const spec = m.emissive;
-                if (spec.token !== undefined && !isNonEmptyString(spec.token)) {
-                    c.error('material-unresolvable', `${path}.material.emissive.token`, 'emissive.token 이 비었다 — 없으면 아예 적지 않는다');
-                }
-                if (c.finite(spec.intensity, `${path}.material.emissive.intensity`, 'emissive.intensity')) {
-                    const strength = spec.intensity;
-                    if (strength < 0 || strength > 1) {
-                        c.error('out-of-range', `${path}.material.emissive.intensity`, 'emissive.intensity 는 0 과 1 사이여야 한다');
-                    }
-                }
-                if (spec.on !== undefined && typeof spec.on !== 'boolean') {
-                    c.error('not-boolean', `${path}.material.emissive.on`, 'emissive.on 은 참·거짓이어야 한다');
-                }
-            }
-        }
-        // 팔레트 밖 표면 — 미감의 예외다. 형태만 여기서 본다.
-        if (m.surface !== undefined) {
-            const u = m.surface;
-            if (!isObject(u)) {
-                c.error('not-object', `${path}.material.surface`, 'surface 는 객체여야 한다');
-            }
-            else {
-                c.oneOf(u.kind, SURFACE_KINDS, `${path}.material.surface.kind`, 'kind');
-                if (!isNonEmptyString(u.ref)) {
-                    c.error('missing-surface-ref', `${path}.material.surface.ref`, 'ref 가 없다 — 무엇을 쓸지 모른다');
-                }
-            }
-        }
-    }
-    if (raw.materialSlot !== undefined) {
-        c.oneOf(raw.materialSlot, MATERIAL_SLOTS, `${path}.materialSlot`, 'materialSlot');
-    }
-    if (raw.sizing !== undefined)
-        c.oneOf(raw.sizing, SIZING_RULES, `${path}.sizing`, 'sizing');
-    // repeat — sizing 이 repeat 면 필수
-    if (raw.sizing === 'repeat') {
-        if (!isObject(raw.repeat)) {
-            c.error('missing-repeat', `${path}.repeat`, "sizing 이 'repeat' 이면 repeat 가 필요하다");
-        }
-        else {
-            c.oneOf(raw.repeat.axis, AXES, `${path}.repeat.axis`, 'repeat.axis');
-            c.positive(raw.repeat.pitch, `${path}.repeat.pitch`, 'repeat.pitch');
-        }
-    }
-    else if (raw.repeat !== undefined) {
-        c.violate('repeat-ignored', `${raw.name ?? path}: sizing 이 'repeat' 가 아니면 repeat 는 쓰이지 않는다`);
-    }
-    /*
-      단면을 원으로 지킬 것인가. 곡면만 뜻이 있다.
-  
-      적어 두고 아무 일도 안 일어나면 저작자는 「꺼 뒀다」고 믿는다. 상자에 적은 것을
-      짚어 준다.
-    */
-    if (raw.keepRound !== undefined) {
-        if (typeof raw.keepRound !== 'boolean') {
-            c.error('not-boolean', `${path}.keepRound`, 'keepRound 는 참·거짓이어야 한다');
-        }
-        else if (!CURVED_PRIMITIVES.includes(raw.primitive)) {
-            c.violate('keep-round-ignored', `${raw.name ?? path}: ${raw.primitive} 는 단면이 원이 아니다`);
-        }
-    }
-    // anchor — 어느 면을 붙잡나
-    if (raw.anchor !== undefined) {
-        if (!isObject(raw.anchor)) {
-            c.error('not-object', `${path}.anchor`, 'anchor 는 축별 객체다 — 예: { y: \'max\', x: \'span\' }');
-        }
-        else {
-            for (const axis of AXES) {
-                if (raw.anchor[axis] !== undefined) {
-                    c.oneOf(raw.anchor[axis], ANCHOR_RULES, `${path}.anchor.${axis}`, `anchor.${axis}`);
-                }
-            }
-            /*
-              `aspect-` 는 다른 축을 가리킨다. 자기 자신이면 뜻이 없고, 또 다른 `aspect-` 를
-              가리키면 서로 미룬다.
-            */
-            for (const axis of AXES) {
-                const rule = raw.anchor[axis];
-                if (typeof rule !== 'string' || !rule.startsWith('aspect-'))
-                    continue;
-                const named = rule.slice('aspect-'.length);
-                if (named === axis) {
-                    c.error('bad-aspect-axis', `${path}.anchor.${axis}`, `${axis} 가 자기 자신을 가리킨다`);
-                }
-                else if (String(raw.anchor[named] ?? '').startsWith('aspect-')) {
-                    c.error('bad-aspect-axis', `${path}.anchor.${axis}`, `${axis} 가 가리킨 ${named} 도 다른 축을 따라간다 — 따라갈 배율이 정해지지 않는다`);
-                }
-            }
-            /*
-              여기 `anchor-ignored` 가 있었다. **틀린 경고였다.**
-      
-              「`sizing` 이 `'scale'` 이면 anchor 는 쓰이지 않는다」고 알렸는데, `anchorOf` 는 적어 둔
-              값을 먼저 돌려준다 — `scale` 부품의 anchor.y 에 `max` 를 적으면 그 축에서는 위 면에서
-              잰 거리를 지킨다. 형식이 자기 동작과 반대되는 말을 저작자 화면에 내보내고 있었고,
-              그 말을 믿은 저작자는 **동작하는 선언을 지웠을 것이다.**
-      
-              `'scale'` 은 「적지 않았을 때의 축별 기본값」이지 anchor 를 막는 값이 아니다. 두 축은
-              상자와 함께 키우고 한 축만 면을 붙잡는 것이 정상적인 저작이다.
-            */
-        }
-    }
-    // Parent. Whether it names a part and whether the chain ends is checked once every name is known.
-    if (raw.parent !== undefined && !isNonEmptyString(raw.parent)) {
-        c.error('unknown-parent', `${path}.parent`, 'parent 는 부품 이름이어야 한다');
-    }
-    // 라벨
-    if (raw.label !== undefined) {
-        if (!isObject(raw.label)) {
-            c.error('not-object', `${path}.label`, 'label 은 객체여야 한다');
-        }
-        else {
-            if (!isNonEmptyString(raw.label.name)) {
-                c.error('missing-label-name', `${path}.label.name`, 'label.name 이 없다');
-            }
-            if (!isNonEmptyString(raw.label.source)) {
-                c.error('missing-label-source', `${path}.label.source`, 'label.source 가 없다 — 무엇을 보일지 모른다');
-            }
-            c.oneOf(raw.label.when, LABEL_WHENS, `${path}.label.when`, 'label.when');
-        }
-    }
-}
-/**
- * 움직임을 본다.
- *
- * ## 왜 시각 순서를 오류로 보나
- *
- * 키가 뒤섞이면 표본추출이 뜻을 잃는다. 런타임이 정렬해 줄 수도 있지만, 그러면 저작자가
- * 적은 순서와 실제로 도는 순서가 달라지고 화면에서는 그저 「이상하게 움직인다」로만
- * 보인다. 여기서 막는 편이 낫다.
- *
- * ## 왜 키 하나는 안 되나
- *
- * 하나짜리는 움직임이 아니라 자세 하나다. 그런 것은 `transform` 이 이미 적는 자리다.
- */
-/**
- * 채널 한 벌의 모양을 본다 — **애니메이션과 파라미터가 같이 쓴다.**
- *
- * 둘의 자세 표현이 같은 모양이라서다(ADR-0051 — 「포즈 데이터는 glTF 꼴 한 벌」). 여기를
- * 포크하면 한쪽에만 검사가 붙고, 어느 쪽이 덜 검사받는지는 아무도 모르게 된다.
- */
-function checkChannels(c, channels, path, parts, joints = NO_JOINTS) {
-    if (!Array.isArray(channels) || channels.length === 0) {
-        c.error('missing-channels', `${path}.channels`, 'channels 가 없다 — 무엇을 움직이는지 모른다');
-        return;
-    }
-    channels.forEach((rawChannel, index) => {
-        const where = `${path}.channels[${index}]`;
-        if (!isObject(rawChannel)) {
-            c.error('not-object', where, 'channel 은 객체여야 한다');
-            return;
-        }
-        const channel = rawChannel;
-        const joint = isNonEmptyString(channel.target) ? joints.get(channel.target) : undefined;
-        if (joint !== undefined) {
-            checkJointChannel(c, channel, where, joint);
-            return;
-        }
-        if (!isNonEmptyString(channel.target)) {
-            c.error('unknown-channel-target', `${where}.target`, 'target 이 없다 — 어느 부품인지 모른다');
-        }
-        else if (!parts.has(channel.target)) {
-            c.error('unknown-channel-target', `${where}.target`, `그런 부품이나 관절이 없다: ${channel.target}`);
-        }
-        const pathOk = c.oneOf(channel.path, CHANNEL_PATHS, `${where}.path`, 'path');
-        if (channel.interpolation !== undefined) {
-            c.oneOf(channel.interpolation, INTERPOLATIONS, `${where}.interpolation`, 'interpolation');
-        }
-        if (channel.pivot !== undefined) {
-            validateVec3(c, channel.pivot, `${where}.pivot`, 'pivot');
-            // 회전 중심은 회전에서만 뜻이 있다. 다른 경로에 적으면 아무 일도 안 일어난다.
-            if (pathOk && channel.path !== 'rotation') {
-                c.violate('pivot-ignored', `${where}: pivot 은 rotation 에서만 쓰인다`);
-            }
-        }
-        if (!Array.isArray(channel.keys) || channel.keys.length < 2) {
-            c.error('too-few-keys', `${where}.keys`, '키가 둘은 있어야 한다 — 하나는 움직임이 아니라 자세다');
-            return;
-        }
-        let previous = -Infinity;
-        channel.keys.forEach((rawKey, k) => {
-            const spot = `${where}.keys[${k}]`;
-            if (!isObject(rawKey)) {
-                c.error('not-object', spot, '키는 { at, value } 여야 한다');
-                return;
-            }
-            if (c.finite(rawKey.at, `${spot}.at`, 'at')) {
-                const now = rawKey.at;
-                if (now < 0)
-                    c.error('not-positive', `${spot}.at`, '키의 시각은 0 이상이어야 한다');
-                else if (now <= previous) {
-                    c.error('keys-out-of-order', `${spot}.at`, '키의 시각은 앞의 것보다 커야 한다');
-                }
-                previous = now;
-            }
-            validateVec3(c, rawKey.value, `${spot}.value`, 'value');
-        });
-    });
-}
-const NO_JOINTS = new Map();
-/**
- * A channel that drives a joint (ADR-0066 decision 2).
- *
- * It names no `path` or `pivot`, because the joint already says what moves and about which point. Each
- * key's value is the joint coordinate: degrees for revolute and continuous, millimetres for prismatic. A
- * value outside the joint's limits is a pose the machine cannot take.
- */
-function checkJointChannel(c, channel, where, joint) {
-    if (channel.path !== undefined) {
-        c.error('not-allowed', `${where}.path`, '관절을 모는 channel 에는 path 를 적지 않는다 — 관절이 이미 무엇이 움직이는지 말한다');
-    }
-    if (channel.pivot !== undefined) {
-        c.error('not-allowed', `${where}.pivot`, '관절을 모는 channel 에는 pivot 을 적지 않는다 — 중심은 관절의 origin 이다');
-    }
-    if (channel.interpolation !== undefined) {
-        c.oneOf(channel.interpolation, INTERPOLATIONS, `${where}.interpolation`, 'interpolation');
-    }
-    if (!Array.isArray(channel.keys) || channel.keys.length < 2) {
-        c.error('too-few-keys', `${where}.keys`, '키가 둘은 있어야 한다 — 하나는 움직임이 아니라 자세다');
-        return;
-    }
-    let previous = -Infinity;
-    channel.keys.forEach((rawKey, k) => {
-        const spot = `${where}.keys[${k}]`;
-        if (!isObject(rawKey)) {
-            c.error('not-object', spot, '키는 { at, value } 여야 한다');
-            return;
-        }
-        if (c.finite(rawKey.at, `${spot}.at`, 'at')) {
-            const now = rawKey.at;
-            if (now < 0)
-                c.error('not-positive', `${spot}.at`, '키의 시각은 0 이상이어야 한다');
-            else if (now <= previous) {
-                c.error('keys-out-of-order', `${spot}.at`, '키의 시각은 앞의 것보다 커야 한다');
-            }
-            previous = now;
-        }
-        if (!c.finite(rawKey.value, `${spot}.value`, '관절 값'))
-            return;
-        const value = rawKey.value;
-        if (joint.limits && (value < joint.limits.min || value > joint.limits.max)) {
-            c.error('out-of-range', `${spot}.value`, `관절 값 ${value} 이 가동 범위 ${joint.limits.min}~${joint.limits.max} 밖이다`);
-        }
-    });
-}
-/**
- * Parents (ADR-0066 decision 1). Every `parent` names a part, and following parents from any part ends at
- * the figure frame. A cycle is reported on each part in it.
- */
-function checkHierarchy(c, source) {
-    const parentOf = new Map();
-    source.parts.forEach((part, index) => {
-        if (!isObject(part) || !isNonEmptyString(part.name) || !isNonEmptyString(part.parent))
-            return;
-        if (!source.parts.some(other => isObject(other) && other.name === part.parent)) {
-            c.error('unknown-parent', `parts[${index}].parent`, `그런 부품이 없다: ${part.parent}`);
-            return;
-        }
-        parentOf.set(part.name, part.parent);
-    });
-    source.parts.forEach((part, index) => {
-        if (!isObject(part) || !parentOf.has(part.name))
-            return;
-        const seen = new Set([part.name]);
-        let at = parentOf.get(part.name);
-        while (at !== undefined) {
-            if (at === part.name) {
-                c.error('parent-cycle', `parts[${index}].parent`, `부모를 따라가면 '${part.name}' 으로 돌아온다 — 틀에 닿지 않는다`);
-                return;
-            }
-            if (seen.has(at))
-                return;
-            seen.add(at);
-            at = parentOf.get(at);
-        }
-    });
-}
-/**
- * Joints (ADR-0066). Returns the joints channels may target, keyed by name.
- *
- * A joint name shares the name space with parts, so a channel target never means two things. A part is
- * the child of at most one joint. `limits` must contain 0, because the rest pose every `transform`
- * describes is joint value 0.
- */
-function checkJoints(c, source) {
-    const said = source.joints;
-    const seen = new Map();
-    if (said === undefined)
-        return seen;
-    if (!Array.isArray(said)) {
-        c.error('not-object', 'joints', 'joints 는 배열이어야 한다');
-        return seen;
-    }
-    const parts = new Set(source.parts.map(part => part?.name).filter(isNonEmptyString));
-    const names = new Set();
-    const children = new Set();
-    said.forEach((raw, at) => {
-        const path = `joints[${at}]`;
-        if (!isObject(raw)) {
-            c.error('not-object', path, '관절은 객체여야 한다');
-            return;
-        }
-        let named = false;
-        if (!isNonEmptyString(raw.name)) {
-            c.error('missing-name', `${path}.name`, '관절 이름이 없다 — channel 이 이 이름으로 관절을 몬다');
-        }
-        else if (names.has(raw.name) || parts.has(raw.name)) {
-            c.error('duplicate-name', `${path}.name`, `이름이 겹친다: ${raw.name} — 관절과 부품은 이름을 나눠 쓴다`);
-        }
-        else {
-            names.add(raw.name);
-            named = true;
-        }
-        if (!isNonEmptyString(raw.child) || !parts.has(raw.child)) {
-            c.error('unknown-joint-child', `${path}.child`, `child 가 부품 이름이 아니다: ${String(raw.child)}`);
-        }
-        else if (children.has(raw.child)) {
-            c.error('joint-child-taken', `${path}.child`, `'${raw.child}' 은 이미 다른 관절의 child 다 — 한 부품에 관절은 하나다`);
-        }
-        else {
-            children.add(raw.child);
-        }
-        const typed = c.oneOf(raw.type, JOINT_TYPES, `${path}.type`, 'type');
-        validateVec3(c, raw.origin, `${path}.origin`, 'origin');
-        if (!isObject(raw.axis)) {
-            validateVec3(c, raw.axis, `${path}.axis`, 'axis');
-        }
-        else {
-            const { x, y, z } = raw.axis;
-            if (c.finite(x, `${path}.axis.x`, 'axis.x') && c.finite(y, `${path}.axis.y`, 'axis.y') && c.finite(z, `${path}.axis.z`, 'axis.z')) {
-                if (Math.hypot(x, y, z) === 0) {
-                    c.error('bad-joint-axis', `${path}.axis`, 'axis 가 0 벡터다 — 어느 쪽으로 움직이는지 없다');
-                }
-            }
-        }
-        let limits;
-        if (raw.limits !== undefined) {
-            if (typed && raw.type === 'continuous') {
-                c.error('not-allowed', `${path}.limits`, 'continuous 관절에는 limits 가 없다 — 끝없이 돈다');
-            }
-            else if (!isObject(raw.limits)) {
-                c.error('not-object', `${path}.limits`, 'limits 는 { min, max } 여야 한다');
-            }
-            else {
-                const lo = c.finite(raw.limits.min, `${path}.limits.min`, 'min');
-                const hi = c.finite(raw.limits.max, `${path}.limits.max`, 'max');
-                if (lo && hi) {
-                    const min = raw.limits.min;
-                    const max = raw.limits.max;
-                    if (max <= min) {
-                        c.error('bad-range', `${path}.limits`, 'max 는 min 보다 커야 한다 — 같으면 움직일 자리가 없다');
-                    }
-                    else if (min > 0 || max < 0) {
-                        c.error('out-of-range', `${path}.limits`, 'limits 가 0 을 품어야 한다 — 그린 자세가 관절 값 0 이다');
-                    }
-                    else {
-                        limits = { min, max };
-                    }
-                }
-            }
-        }
-        if (named && typed) {
-            seen.set(raw.name, limits ? { type: raw.type, limits } : { type: raw.type });
-        }
-    });
-    return seen;
-}
-function checkAnimations(c, source, joints = NO_JOINTS) {
-    const clips = source.animations;
-    if (clips === undefined)
-        return;
-    if (!Array.isArray(clips)) {
-        c.error('not-object', 'animations', 'animations 는 배열이어야 한다');
-        return;
-    }
-    const names = new Set();
-    const parts = new Set(source.parts.map(part => part?.name).filter(isNonEmptyString));
-    clips.forEach((raw, at) => {
-        const path = `animations[${at}]`;
-        if (!isObject(raw)) {
-            c.error('not-object', path, 'clip 은 객체여야 한다');
-            return;
-        }
-        if (!isNonEmptyString(raw.name)) {
-            c.error('missing-name', `${path}.name`, 'clip 이름이 없다 — 인스턴스가 이 이름으로 구동한다');
-        }
-        else if (names.has(raw.name)) {
-            c.error('duplicate-name', `${path}.name`, `clip 이름이 겹친다: ${raw.name}`);
-        }
-        else {
-            names.add(raw.name);
-        }
-        /*
-          `drive` held a value-driven pose as 'hold' before parameters had their own field (ADR-0051).
-          Stored sources were moved when edition 2 arrived (ADR-0065), so the field is refused rather
-          than read by an old rule.
-        */
-        if (raw.drive !== undefined) {
-            c.error('not-allowed', `${path}.drive`, 'drive 칸은 없어졌다. 값으로 움직이는 자세는 parameters 에 적는다');
-        }
-        checkChannels(c, raw.channels, path, parts, joints);
-    });
-}
-/**
- * 능력 선언의 **모양만** 본다.
- *
- * 이름이 실제로 얹히는 능력인지는 씬이 판정한다(`registerFigure`). 여기서 닫힌 목록을 또 적으면
- * 계약이 두 벌이 되고, 씬에 능력이 하나 생길 때마다 형식을 고쳐야 한다.
- */
-/**
- * 부품이 능력의 닻일 때 그 선언의 모양을 본다.
- *
- * 역할 이름은 형식이 정한다(`PART_ROLES`) — 이것은 씬의 낱말이 아니라 **형식이 부품에 붙이는
- * 역할**이고, 씬은 그것을 받아 `SlotDef`·`Port` 로 옮긴다.
- */
-function validatePartCapability(c, raw, path) {
-    const spec = raw.capability;
-    if (spec === undefined)
-        return;
-    if (!isObject(spec)) {
-        c.error('bad-part-capability', `${path}.capability`, 'capability 는 { roles, … } 여야 한다');
-        return;
-    }
-    /*
-      역할은 **여럿일 수 있다.** AGV 의 상판이 그렇다 — 물건을 놓는 자리이면서 그 자리로 물건이
-      들어오고 나간다. 하나만 받으면 저작자가 같은 위치에 부품을 두 개 만들게 되고, 실물에 없는
-      구조를 형식이 만들어 낸다.
-  
-      비어 있는 배열은 막는다. 역할이 없는 부품은 그냥 그리는 부품이므로 `capability` 를 적지
-      않는 것이 맞고, 빈 배열을 통과시키면 「능력을 줬는데 아무 일도 없는」 부품이 생긴다.
-    */
-    if (!Array.isArray(spec.roles) || spec.roles.length === 0) {
-        c.error('bad-part-capability', `${path}.capability.roles`, 'roles 는 역할 하나 이상의 배열이어야 한다');
-    }
-    else {
-        const seen = new Set();
-        for (const [at, role] of spec.roles.entries()) {
-            if (typeof role !== 'string' || !PART_ROLES.includes(role)) {
-                c.error('bad-part-capability', `${path}.capability.roles[${at}]`, `역할은 ${PART_ROLES.join(' · ')} 중 하나여야 한다`);
-                continue;
-            }
-            if (seen.has(role)) {
-                c.error('bad-part-capability', `${path}.capability.roles[${at}]`, `역할 ${role} 이 두 번 적혔다`);
-            }
-            seen.add(role);
-        }
-    }
-    if (spec.accepts !== undefined) {
-        if (!Array.isArray(spec.accepts) || spec.accepts.some(one => typeof one !== 'string' || !one.trim())) {
-            c.error('bad-part-capability', `${path}.capability.accepts`, 'accepts 는 타입 이름의 배열이어야 한다');
-        }
-    }
-    if (spec.capacity !== undefined) {
-        if (typeof spec.capacity !== 'number' || !Number.isInteger(spec.capacity) || spec.capacity < 1) {
-            c.error('bad-part-capability', `${path}.capability.capacity`, 'capacity 는 1 이상의 정수여야 한다');
-        }
-        /*
-          `repeat` 인 자리는 **배율이 칸 수를 정한다.** 둘 다 적으면 어느 것이 이기는지 형식이 말하지
-          않게 되고, 저작자는 적어 둔 수가 지켜질 것으로 읽는다.
-        */
-        if (raw.sizing === 'repeat') {
-            c.violate('capacity-with-repeat', '반복하는 자리에 capacity 를 적었다 — 칸 수는 인스턴스 크기가 정하므로 이 값은 쓰이지 않는다');
-        }
-    }
-    if (spec.direction !== undefined) {
-        validateVec3(c, spec.direction, `${path}.capability.direction`, 'direction');
-    }
-}
-/**
- * 파라미터 — 값이 만드는 자세.
- *
- * 자세 표현이 `animations` 와 같은 모양이라 채널 검사는 같은 것을 부른다(ADR-0051 —
- * 「포즈 데이터는 glTF 꼴 한 벌」). 여기서 더 보는 것은 **그 위에 얹은 선언**이다.
- *
- * 이름이 clip 이름과 겹치는지도 본다. 인스턴스는 둘을 이름으로 부르므로, 겹치면 어느 쪽에 값을
- * 준 것인지 알 수 없다.
- */
-function checkParameters(c, source, clipNames, joints = NO_JOINTS) {
-    const said = source.parameters;
-    if (said === undefined)
-        return;
-    if (!Array.isArray(said)) {
-        c.error('not-object', 'parameters', 'parameters 는 배열이어야 한다');
-        return;
-    }
-    const names = new Set();
-    const parts = new Set(source.parts.map(part => part?.name).filter(isNonEmptyString));
-    said.forEach((raw, at) => {
-        const path = `parameters[${at}]`;
-        if (!isObject(raw)) {
-            c.error('not-object', path, '파라미터는 객체여야 한다');
-            return;
-        }
-        if (!isNonEmptyString(raw.name)) {
-            c.error('missing-name', `${path}.name`, '파라미터 이름이 없다 — 인스턴스가 이 이름으로 값을 준다');
-        }
-        else if (names.has(raw.name) || clipNames.has(raw.name)) {
-            c.error('duplicate-name', `${path}.name`, `이름이 겹친다: ${raw.name}`);
-        }
-        else {
-            names.add(raw.name);
-        }
-        /*
-          범위. 인스턴스가 물리량으로 주고받으므로 무엇부터 무엇까지인지 없으면 값을 줄 수가 없다.
-          단위는 형식이 해석하지 않는다 — 화면과 API 가 읽는 낱말이다.
-        */
-        const range = raw.range;
-        if (!isObject(range)) {
-            c.error('missing-range', `${path}.range`, 'range 가 없다 — 인스턴스가 어느 값을 줄지 모른다');
-        }
-        else {
-            if (!isNonEmptyString(range.unit)) {
-                c.error('missing-range', `${path}.range.unit`, 'unit 이 없다 — 화면이 무슨 수인지 말할 수 없다');
-            }
-            const lo = c.finite(range.min, `${path}.range.min`, 'min');
-            const hi = c.finite(range.max, `${path}.range.max`, 'max');
-            if (lo && hi && range.max <= range.min) {
-                c.error('bad-range', `${path}.range`, 'max 는 min 보다 커야 한다 — 같으면 움직일 자리가 없다');
-            }
-            if (raw.default !== undefined && c.finite(raw.default, `${path}.default`, 'default')) {
-                const value = raw.default;
-                if (lo && hi && (value < range.min || value > range.max)) {
-                    c.error('bad-range', `${path}.default`, '기본값이 범위 밖이다');
-                }
-            }
-        }
-        const clip = raw.clip;
-        if (!isObject(clip)) {
-            c.error('not-object', `${path}.clip`, 'clip 이 없다 — 값이 무슨 자세를 만드는지 모른다');
-            return;
-        }
-        checkChannels(c, clip.channels, `${path}.clip`, parts, joints);
-        /*
-          Transition time. 0 is accepted because it means instant. A negative value has no meaning.
-        */
-        if (clip.duration !== undefined && c.finite(clip.duration, `${path}.clip.duration`, 'duration')) {
-            if (clip.duration < 0) {
-                c.error('not-positive', `${path}.clip.duration`, 'duration 은 0 이상이어야 한다. 0 이면 즉시 움직인다');
-            }
-        }
-        /*
-          Parameter keys sit on the value span. A key above 1 is a pose no value can reach, which means
-          the author wrote seconds. Refuse it here instead of leaving an unreachable pose. Negative keys
-          and key order are already checked in checkChannels.
-        */
-        if (Array.isArray(clip.channels)) {
-            clip.channels.forEach((channel, index) => {
-                if (!isObject(channel) || !Array.isArray(channel.keys))
-                    return;
-                channel.keys.forEach((key, k) => {
-                    if (isObject(key) && isFiniteNumber(key.at) && key.at > 1) {
-                        c.error('out-of-range', `${path}.clip.channels[${index}].keys[${k}].at`, '파라미터 키의 at 은 0~1 사이여야 한다. 전이 시간은 clip.duration 에 적는다');
-                    }
-                });
-            });
-        }
-    });
-}
-function checkCapabilities(c, source) {
-    const said = source.capabilities;
-    if (said === undefined) {
-        return;
-    }
-    if (!Array.isArray(said)) {
-        c.error('bad-capability', 'capabilities', 'capabilities 는 이름의 배열이어야 한다');
-        return;
-    }
-    const seen = new Set();
-    said.forEach((name, at) => {
-        if (typeof name !== 'string' || !name.trim()) {
-            c.error('bad-capability', `capabilities[${at}]`, '능력 이름이 비어 있다');
-            return;
-        }
-        if (seen.has(name)) {
-            c.error('duplicate-capability', `capabilities[${at}]`, `능력 ${name} 이 두 번 선언되었다`);
-            return;
-        }
-        /*
-          모르는 이름은 **여기서** 막는다.
-    
-          한동안 목록이 씬에만 있어서 이 검사가 없었고, `capabilities: ['hoist']` 가 검증을
-          지나고 발행을 지나 렌더링에서 죽었다. 저작자는 자산을 내보내고 나서야 그것이 안
-          선다는 것을 알았다(ADR-0051 ④).
-        */
-        if (!FIGURE_CAPABILITIES.includes(name)) {
-            c.error('bad-capability', `capabilities[${at}]`, `모르는 능력이다: ${name} — 쓸 수 있는 것은 ${FIGURE_CAPABILITIES.join(' · ')}`);
-            return;
-        }
-        seen.add(name);
-    });
-    /*
-      혼자 설 수 없는 능력. 씬이 조립할 때 던지는 것과 같은 규칙인데, 그때는 이미 발행된
-      뒤다. 모르는 이름과 같은 자리에서 본다.
-    */
-    for (const [name, needs] of Object.entries(CAPABILITY_NEEDS)) {
-        if (!seen.has(name))
-            continue;
-        if (needs.some(one => seen.has(one)))
-            continue;
-        c.error('bad-capability', 'capabilities', `${name} 은 혼자 설 수 없다 — ${needs.join(' 이나 ')} 가 함께 있어야 한다`);
-    }
-}
-function checkPolicy(c, source) {
-    /*
-      그려지는 부품만 센다.
-  
-      능력의 닻은 재질도 기하도 없다 — `compile` 은 그것을 `groups` 가 아니라 `anchors` 로 보내고,
-      `costOf` 도 그리는 것만 센다. 여기서만 다 세면 **화면이 말하는 부품 수와 게이트가 말하는
-      부품 수가 갈린다.** 이 파일이 한 번 겪은 부류다(정책 3, 실제 17).
-  
-      수가 갈리는 것으로 끝나지도 않는다. `groupKeyOf` 는 재질을 읽으므로 닻이 섞여 들어오면
-      형식이 옳다고 한 원본에서 던진다.
-    */
-    const parts = source.parts.filter(isDrawn);
-    // 등급. 없으면 예산을 잡을 수 없다. 오류보고없이 넘기지 않는다.
-    if (source.detailLevel === undefined) {
-        c.violate('detail-level-missing', '디테일 등급이 없다 — 부품 수 예산을 잡을 수 없다');
-    }
-    else {
-        const limit = PART_LIMIT[source.detailLevel];
-        if (parts.length > limit) {
-            c.violate('too-many-parts', `등급 ${source.detailLevel} 의 부품 수 한도를 넘었다`, parts.length, limit);
-        }
-    }
-    const moving = movingNames(source);
-    if (moving.size > LIMITS.independentParts) {
-        c.violate('too-many-independent-parts', '따로 변환되는 부품이 많다 — 저마다 단독 묶음이라 한 화면에 세울 수 있는 대수가 준다', moving.size, LIMITS.independentParts);
-    }
-    /*
-      Draw calls per instance. **What compile and the renderer actually produce.**
-  
-      This counted distinct colour and slot combinations, which is smaller than
-      what gets drawn. A part that does not scale with the instance takes its own
-      transform and cannot merge, and a repeat part draws once per copy.
-  
-        conveyor   counted 3, drew 17
-        cell tray  counted 2, drew  9
-  
-      A tray drawing nine times passed a limit of three with room to spare. The
-      author was told the asset was cheap by the one number that did not measure
-      the cost.
-    */
-    // Parts merge only within one joint frame, as compile groups them (ADR-0066 decision 4).
-    const calls = drawCallsOf(parts, source.base, moving, jointFrames(source));
-    if (calls > LIMITS.materialGroups) {
-        c.violate('too-many-material-groups', 'draw call 이 많다 — 한 화면에 함께 세울 수 있는 개수가 준다', calls, LIMITS.materialGroups);
-    }
-    const transparent = new Set(parts.filter(p => p.material?.transparent).map(groupKeyOf));
-    if (transparent.size > LIMITS.transparentMaterials) {
-        c.violate('too-many-transparent', '투명 재질이 많다 — 정렬 비용이 크다', transparent.size, LIMITS.transparentMaterials);
-    }
-    // 팔레트 밖 표면 — 단색 규칙의 예외다. **종류 수**를 센다(같은 ref 는 한 텍스처다).
-    const surfaces = new Set(parts
-        .map(p => p.material?.surface)
-        .filter((u) => u !== undefined)
-        .map(u => `${u.kind}:${u.ref}`));
-    if (surfaces.size > LIMITS.surfaceTextures) {
-        c.violate('too-many-surface-textures', '팔레트 밖 표면이 많다 — 단색 규칙을 벗어나고 텍스처마다 GPU 메모리를 쓴다', surfaces.size, LIMITS.surfaceTextures);
-    }
-    const always = parts.filter(p => p.label?.when === 'always');
-    if (always.length > 1) {
-        c.violate('too-many-always-labels', "'always' 라벨이 여럿이다 — 대량 배치에서 DOM·텍스처가 는다", always.length, 1);
-    }
-    checkBaseBox(c, source);
-}
-/**
- * 부품이 기준 상자와 어떻게 놓여 있나 — **두 가지를 따로 본다.**
- *
- * ADR-0044 `operato-twin/design/04-decisions.md` — 결정 ① `base` 는 선언된 점유 부피 ·
- * 결정 ② 넘침은 violation 둘 · 결정 ③ 자리는 여기지 저작 도구가 아니다.
- *
- * ## 넘치는 것
- *
- * `base` 는 나누는 수다. 씬이 `instanceScale = width/base.x` 로 인스턴스 배율을 내므로
- * (`figure-instance.ts`), 부품이 상자를 넘으면 그 나누는 수가 거짓말을 하고 도면에 놓였을 때
- * 크기가 틀린다. 배치 기준의 높이도 `base.y` 에서 나오므로 높이까지 같이 틀린다.
- *
- * **덜 채우는 것은 보지 않는다.** `base` 는 감싸는 최소 상자가 아니라 저작자가 선언하는 점유
- * 부피다 — 컨베이어 앞의 접근 공간, 랙의 칸 pitch 가 그 여백에 담긴다.
- *
- * ## 기준면에 안 닿는 것
- *
- * 바닥 기반이면 부품이 상자 밑면까지 내려와야 하고, 천정 기반이면 윗면까지 올라가야 한다.
- * 안 그러면 「바닥에 선다」고 선언해 놓고 공중에 뜬다. 중심 기반에는 요구가 없다 — 떠 있는
- * 것이 그 배치의 뜻이다.
- *
- * **이것이 OHT 표본의 진짜 결함이었다.** 상자는 ±1.5 인데 부품이 -2.725..0 이었다. 「상자가
- * 크다」로 읽으면 저작자가 상자를 키우는 쪽으로 고치는데, 실제로 어긋난 것은 원점 규약이다.
- * 그래서 코드를 둘로 나눠 사유를 따로 말한다.
- *
- * **닿는 것은 「도달」로 본다** — 밑면 아래로 지나가는 것도 닿은 것이다. 지나간 것은
- * `part-outside-base` 가 이미 말하므로, 같은 사실을 두 번 말하지 않는다.
- *
- * 회전을 포함한 실제 부피로 잰다(`rotatedExtentOf`). 45도 돌린 판은 제 `size` 보다 넓다.
- * 그리지 않는 부품(능력의 닻)도 센다 — 물건이 놓이는 자리가 도형 밖이면 그것도 결함이다.
- */
-/**
- * What to change when a part leaves the base box — in the source's coordinates, which are what the author edits.
- *
- * X and Z are centred on the box, so a box grown by `size` gains half of it on each side: covering `mm` on one side
- * takes `2·mm`. Y is not centred in the source: its bottom is y 0 and its top is `base.y` (ADR-0065 decision 2). A part
- * over the top is covered by growing the box by `mm`; a part below the bottom cannot be covered by resizing at all,
- * because the bottom does not move. The check itself runs on the centred copy; the advice must not (09-24: it told
- * authors to grow Y by `2·mm` for both, and neither fixed a part through the floor).
- */
-function outsideBaseHow(base, axis, name, mm, overTheTop) {
-    const AXIS = axis.toUpperCase();
-    if (axis !== 'y')
-        return `기준 상자의 ${AXIS} 를 ${Math.round(base[axis] + 2 * mm)} 으로 키우거나(지금 ${base[axis]}), '${name}' 을 ${AXIS} 로 ${mm}mm 안으로 옮기세요.`;
-    if (overTheTop)
-        return `기준 상자의 Y 를 ${Math.round(base.y + mm)} 으로 키우거나(지금 ${base.y}), '${name}' 을 Y 로 ${mm}mm 내리세요.`;
-    return `'${name}' 을 Y 로 ${mm}mm 올리세요. 기준 상자의 밑면은 바닥(Y 0)에 고정이라 상자 크기로는 닿지 않습니다.`;
-}
-function checkBaseBox(c, source) {
-    const half = { x: source.base.x / 2, y: source.base.y / 2, z: source.base.z / 2 };
-    let low = Infinity;
-    let high = -Infinity;
-    let lowest = '';
-    let highest = '';
-    for (const part of source.parts) {
-        const extent = rotatedExtentOf(part);
-        const at = part.transform.position;
-        for (const axis of AXES) {
-            const centre = at[axis] ?? 0;
-            const reach = extent[axis] / 2;
-            const above = centre + reach - half[axis];
-            const below = -half[axis] - (centre - reach);
-            const over = Math.max(above, below);
-            if (over > SKIN) {
-                const mm = Math.round(over * 1e4) / 1e4;
-                const AXIS = axis.toUpperCase();
-                c.violate('part-outside-base', `'${part.name}' 부품이 기준 상자를 ${AXIS} 로 ${mm}mm 넘습니다.`, mm, 0, {
-                    why: `기준 상자가 도면에 놓일 때의 배율을 정합니다. 넘은 만큼은 그 배율에 들어가지 않아서, 도면에서 이 부품이 도형에 주어진 자리 밖으로 나갑니다.`,
-                    how: outsideBaseHow(source.base, axis, part.name, mm, above >= below)
-                });
-            }
-        }
-        const bottom = (at.y ?? 0) - extent.y / 2;
-        const top = (at.y ?? 0) + extent.y / 2;
-        if (bottom < low)
-            lowest = part.name;
-        if (top > high)
-            highest = part.name;
-        low = Math.min(low, bottom);
-        high = Math.max(high, top);
-    }
-    const placement = source.placement ?? 'floor';
-    if (placement === 'floor' && low > -half.y + SKIN) {
-        const mm = Math.round((low + half.y) * 1e4) / 1e4;
-        c.violate('parts-off-placement-face', `가장 낮은 '${lowest}' 부품이 기준 상자 밑면에서 ${mm}mm 떠 있습니다.`, mm, 0, {
-            why: '배치 기준이 바닥 기반입니다. 도형이 밑면으로 바닥에 닿는다는 뜻이라서, 밑면에 닿지 않으면 도면에서 그만큼 떠 보이고 자리에 놓인 물건도 함께 뜹니다.',
-            /* No box change is offered: the box's bottom is y 0 in the source (ADR-0065), so resizing it moves only its top. */
-            how: `부품 전체를 Y 로 ${mm}mm 내리거나, 떠 있는 것이 뜻이라면 배치 기준을 중심 기반으로 바꾸세요.`
-        });
-    }
-    if (placement === 'ceiling' && high < half.y - SKIN) {
-        const mm = Math.round((half.y - high) * 1e4) / 1e4;
-        c.violate('parts-off-placement-face', `가장 높은 '${highest}' 부품이 기준 상자 윗면에서 ${mm}mm 떨어져 있습니다.`, mm, 0, {
-            why: '배치 기준이 천장 기반입니다. 도형이 윗면으로 천장에 매달린다는 뜻이라서, 윗면에 닿지 않으면 도면에서 그만큼 내려와 걸립니다.',
-            /* The top face is at base.y in the source, so shrinking the box by the gap brings it down to the parts. */
-            how: `부품 전체를 Y 로 ${mm}mm 올리거나, 기준 상자의 Y 를 ${Math.round(source.base.y - mm)} 으로 줄이거나(지금 ${source.base.y}), 떨어져 있는 것이 뜻이라면 배치 기준을 중심 기반으로 바꾸세요.`
-        });
-    }
-}
-/**
- * 원본 데이터를 검증한다.
- *
- * 바깥에서 온 데이터(DB · API · 파일)를 받으므로 `unknown` 을 받는다.
- * `errors` 가 비어 있으면 `source` 는 `FigureSource` 로 다룰 수 있다.
- */
-/**
- * Type name: its shape, and whether a person has named it. These are violations that hold back a
- * release, not errors. Building something before naming it is fine; what gets blocked is the release
- * that makes a promise to drawings.
- */
-function checkTypeName(c, type) {
-    if (isPlaceholderType(type)) {
-        c.violate('type-is-placeholder', `type '${type}' 은 저장할 때 자동으로 붙은 임시 이름입니다. 발행하려면 이름을 정하세요.`);
-        return;
-    }
-    if (!TYPE_PATTERN.test(type) || type.length < TYPE_LENGTH.min || type.length > TYPE_LENGTH.max) {
-        c.violate('type-not-identifier', `type '${type}' 은 쓸 수 없는 이름입니다. 대문자와 밑줄로 ${TYPE_LENGTH.min}~${TYPE_LENGTH.max} 자로 적으세요(예: ROLLER_CONVEYOR).`);
-    }
-}
-export function validate(source) {
-    const c = new Collector();
-    if (!isObject(source)) {
-        c.error('not-object', '', '원본 데이터는 객체여야 한다');
-        return { errors: c.errors, violations: c.violations };
-    }
-    if (!isNonEmptyString(source.type)) {
-        c.error('missing-type', 'type', 'type 이 없다 — 저장되는 식별자다');
-    }
-    if (source.version !== undefined && (typeof source.version !== 'number' || !Number.isInteger(source.version) || source.version <= 0)) {
-        c.error('not-positive', 'version', 'version 은 양의 정수여야 한다');
-    }
-    else if (source.version !== FIGURE_SOURCE_VERSION) {
-        /*
-          A missing version is refused too. Sources saved before the field existed were written with y
-          measured from the box centre, so reading them as the current edition would move every part.
-        */
-        c.error('source-version-unsupported', 'version', `원본 판이 ${source.version ?? '없음'} 이다. 판 ${FIGURE_SOURCE_VERSION} 원본만 읽는다`);
-    }
-    if (!isObject(source.base)) {
-        c.error('missing-base', 'base', 'base 가 없다 — 배치 비율의 근거다');
-    }
-    else {
-        c.positive(source.base.x, 'base.x', 'base.x');
-        c.positive(source.base.y, 'base.y', 'base.y');
-        c.positive(source.base.z, 'base.z', 'base.z');
-    }
-    if (source.detailLevel !== undefined) {
-        c.oneOf(source.detailLevel, DETAIL_LEVELS, 'detailLevel', 'detailLevel');
-    }
-    if (source.placement !== undefined) {
-        c.oneOf(source.placement, FIGURE_PLACEMENTS, 'placement', 'placement');
-    }
-    if (source.styleKit !== undefined && !isNonEmptyString(source.styleKit)) {
-        c.error('bad-style-kit', 'styleKit', 'styleKit 은 비어 있지 않은 문자여야 한다');
-    }
-    if (!Array.isArray(source.parts) || source.parts.length === 0) {
-        c.error('missing-parts', 'parts', 'parts 가 없다 — 부품이 하나는 있어야 한다');
-        return { errors: c.errors, violations: c.violations };
-    }
-    const seen = new Set();
-    source.parts.forEach((part, i) => validatePart(c, part, i, seen));
-    // Parents and joints need every part name; channels need the joints.
-    checkHierarchy(c, source);
-    const joints = checkJoints(c, source);
-    // 부품 이름을 다 읽은 뒤라야 channel 의 target 이 가리키는 것이 있는지 볼 수 있다
-    checkAnimations(c, source, joints);
-    /*
-      clip 이름을 함께 넘긴다 — 파라미터와 clip 이 같은 이름을 쓰면 인스턴스가 어느 쪽에 값을 준
-      것인지 알 수 없다. `animations` 가 배열이 아닌 것은 `checkAnimations` 가 이미 말했으므로
-      여기서는 셀 것이 없다고 보고 넘어간다.
-    */
-    const clips = source.animations;
-    checkParameters(c, source, new Set((Array.isArray(clips) ? clips : [])
-        .map((clip) => clip?.name)
-        .filter(isNonEmptyString)), joints);
-    /* 능력 선언의 모양 — 부품과 무관하므로 순서를 따지지 않는다 */
-    checkCapabilities(c, source);
-    // 정책 검사는 형식이 성립할 때만 뜻이 있다
-    if (c.errors.length === 0) {
-        checkTypeName(c, source.type);
-        checkPolicy(c, centredSource(source));
-    }
-    return { errors: c.errors, violations: c.violations };
-}
-//# sourceMappingURL=validate.js.map