@operato/twin-kernel 0.8.0 → 0.8.2

package/dist/operational-ingest.js

@@ -1,379 +0,0 @@
-/*
- * 운영 사실 인제스트 — **작업·설비·사람·자산·오더·품질이 들어오는 문.** (ADR-0029 어휘 넓히기)
- *
- * ── 무엇이 없었나 (2026-08-19) ──────────────────────────────────────────────
- * 관측 리듀서는 이 여섯을 **이미 다룬다**(`observed-reducer.ts` 의 `OP_EVENT.*` 분기). 그런데 라이브
- * 인제스트 문은 어휘를 셋만 알았다: EPCIS 품목 사실, 에너지 계량, 설비 에너지 상태. 그래서 원본이
- * 「이 작업이 끝났다」·「이 설비가 고장이다」를 말할 **길이 없었다** — 넣으면 `epc` 가 없어 EPCIS
- * 검증에서 거부됐다.
- *
- * 그 결과가 이 프로젝트가 가장 싫어하는 모양이었다: **시뮬만 아는 상태.** 시뮬 커널은 작업과 설비를
- * 알고 미러는 영원히 몰랐다. 그러면 같은 화면이 두 구동에서 다른 것을 말하고, 미러 위에 세운 예측은
- * 「진행 중인 일이 하나도 없는 현장」에서 출발한다.
- *
- * ── 어휘는 델타의 이름이다 ──────────────────────────────────────────────────
- * 필드 이름을 새로 짓지 않는다. `TaskStatusDelta`·`EquipmentStatusDelta`… 가 이미 계약이고, 리듀서가
- * 그 이름으로 읽는다. 여기서 다른 이름을 받아 옮기면 **같은 사실에 두 어휘**가 생긴다(에너지가 그
- * 규율을 먼저 세웠다: "필드 이름이 계약이다").
- *
- * ── 무엇을 거부하나 ─────────────────────────────────────────────────────────
- * 지어낼 수 없는 것이 빠지면 거부한다 — 정체(누구의 상태인가)와 상태다. 그리고 **계산할 수 없는 낱말**도
- * 거부한다: 설비 상태를 `'RUNNING'` 으로 받으면 아무 오류 없이 가동률이 0% 가 되고(누적기는 `busy`·
- * `down` 만 센다), 사람이 `'available'` 이면 배정에서 조용히 사라진다. 그 실패는 화면에서 「일이 없는
- * 공장」으로 보이고 원인을 되짚을 수 없다. 그래서 커널이 다룰 수 있는 낱말만 받고, **받는 낱말을 이유에
- * 적어** 커넥터가 매핑을 고칠 수 있게 한다(매핑=밖, 검증=커널).
- *
- * 오더의 상태·종류는 **열려 있다** — 도메인이 소유한다(`picking`·`packed`·`shipped`…). 커널이 그 낱말로
- * 무엇을 계산하지 않으므로 닫을 근거가 없다.
- *
- * ── 파생은 받아도 커널이 다시 계산한다 ──────────────────────────────────────
- * 작업의 진척(`progress`)은 계약에 있어 받지만, 상태에 앉는 값은 커널이 **소요·남은 시간에서 다시
- * 계산한 것**이다(`progressOf`). 그러니 원본이 진척을 보이게 하려면 `durationMs`·`remainingMs` 를 보내야
- * 한다 — 파생을 사실로 삼지 않는 규율이고, 이 문을 붙이는 사람이 알아야 하는 사실이라 여기 적는다.
- *
- * 모르는 필드는 **조용히 버리지 않고 거부한다.** `taskID` 처럼 한 글자 틀린 이름은 통과시키면 영원히
- * 보이지 않는 손실이 된다(이 문에는 아직 옛 발신자가 없어 호환 부담도 없다).
- */
-import { OP_EVENT } from "./contract.js";
-/**
- * 닫아 둔 낱말과 그 이유.
- *  · 작업 상태 — 성과 폴드가 `completed`·`in-progress` 로 갈린다(`kpi-fold`).
- *  · 설비 상태 — OEE 누적기가 `busy`·`down` 만 센다. 그 밖의 낱말은 가동률 0% 로 조용히 앉는다.
- *  · 사람·자산 상태 — 배정이 `idle` 을 찾는다. 다른 낱말이면 있는 자원이 없는 것이 된다.
- */
-const TASK_STATUS = ['created', 'assigned', 'in-progress', 'completed'];
-const EQUIPMENT_STATUS = ['idle', 'busy', 'down'];
-const PERSON_STATUS = ['idle', 'busy'];
-const ASSET_STATUS = ['idle', 'in-use'];
-const SPECS = {
-    task: {
-        eventType: OP_EVENT.task,
-        identity: 'taskId',
-        /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
-        required: ['taskId', 'kind', 'status'],
-        fields: {
-            taskId: 'string', kind: 'string', status: 'string', fromNode: 'string', toNode: 'string',
-            itemRefs: 'string[]', resourceRef: 'string', resources: 'string[]', personnel: 'string[]', assets: 'string[]',
-            orderId: 'string', intent: 'string', progress: 'number', remainingMs: 'number', durationMs: 'number',
-            startedAtSimMs: 'number', outcome: 'string', priority: 'number', startTime: 'string', endTime: 'string',
-            materialActual: 'object[]', recordTime: 'string'
-        },
-        enums: {
-            status: TASK_STATUS,
-            intent: ['transport', 'process', 'dwell'],
-            /* 품질 판정은 **있었던 작업만** — 없음은 「양품」이 아니라 「판정하지 않았다」다. */
-            outcome: ['good', 'scrap']
-        }
-    },
-    equipment: {
-        eventType: OP_EVENT.equipment,
-        identity: 'moverId', // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
-        required: ['moverId', 'kind', 'status'], // vocabulary-guard: allow 위와 같은 이유
-        fields: {
-            moverId: 'string', kind: 'string', status: 'string', location: 'string', homeLocation: 'string', // vocabulary-guard: allow
-            taskId: 'string', held: 'boolean', effectiveStart: 'string', effectiveEnd: 'string', recordTime: 'string',
-            /* 이동 구간 — 실 시스템도 줄 수 있는 사실이다(AGV·RTLS 가 출발·도착·소요를 낸다). 안쪽 필드까지
-               재검사하지는 않는다: 그 모양은 `EquipmentMotion` 계약이고, 여기서 두 번 지키면 두 벌이 된다. */
-            motion: 'object'
-        },
-        enums: { status: EQUIPMENT_STATUS }
-    },
-    person: {
-        eventType: OP_EVENT.person,
-        identity: 'personId',
-        required: ['personId', 'status'],
-        fields: {
-            personId: 'string', status: 'string', personnelClassIds: 'string[]', taskId: 'string', location: 'string',
-            offShift: 'boolean', effectiveStart: 'string', effectiveEnd: 'string', recordTime: 'string'
-        },
-        enums: { status: PERSON_STATUS }
-    },
-    asset: {
-        eventType: OP_EVENT.asset,
-        identity: 'assetId',
-        required: ['assetId', 'status'],
-        fields: {
-            assetId: 'string', status: 'string', assetClassIds: 'string[]', location: 'string', taskId: 'string',
-            carrying: 'string', effectiveStart: 'string', effectiveEnd: 'string', recordTime: 'string'
-        },
-        enums: { status: ASSET_STATUS }
-    },
-    order: {
-        eventType: OP_EVENT.order,
-        identity: 'orderId',
-        /*
-         * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
-         * 그것은 「모른다」가 아니라 「아무것도 안 됐다」로 읽힌다 — 결측을 0 으로 메우지 않는다.
-         */
-        required: ['orderId', 'kind', 'status', 'requested', 'fulfilled'],
-        fields: {
-            orderId: 'string', kind: 'string', status: 'string', requested: 'number', fulfilled: 'number',
-            gtin: 'string', held: 'boolean', lines: 'object[]', priority: 'number', startTime: 'string', endTime: 'string',
-            allocated: 'string[]', bizTransaction: 'string', operationsRequestId: 'string', dockDoor: 'string', windowStartMs: 'number', recordTime: 'string'
-        }
-        /* 상태·종류는 도메인이 소유한다 — 닫지 않는다. */
-    },
-    quality: {
-        eventType: OP_EVENT.quality,
-        identity: 'moverId', // vocabulary-guard: allow 저널 와이어 필드
-        /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
-        required: ['moverId', 'good', 'goodCount', 'scrapCount'], // vocabulary-guard: allow
-        fields: { moverId: 'string', good: 'boolean', goodCount: 'number', scrapCount: 'number', recordTime: 'string' } // vocabulary-guard: allow
-    },
-    /*
-     * **시험 결과** — 대상을 가리켜 들어온다(표준 `TestResult.TestableObjectID`).
-     *
-     * `result` 를 **요구하지 않는다**: 재기만 하고 판정하지 않는 원천이 정상이고, 요구하면 그 원천의
-     * 사실을 아예 담을 수 없다(§`TestResult.result`). 비어 있으면 커널이 선언된 기준으로 판정하고
-     * `derived` 를 세운다 — 판정하지 못하면 비워 둔다.
-     *
-     * `propertyMeasurements` 안쪽은 재검사하지 않는다 — 그 모양은 `PropertyMeasurement` 계약이고,
-     * 여기서 두 번 지키면 두 벌이 된다(설비 `motion` 과 같은 규율).
-     */
-    test: {
-        eventType: OP_EVENT.test,
-        identity: 'testableObjectId',
-        /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
-        required: ['testableObjectId', 'specId'],
-        fields: {
-            testableObjectId: 'string', specId: 'string', result: 'string', at: 'string', expiresAt: 'string',
-            derived: 'boolean', propertyMeasurements: 'object[]', recordTime: 'string'
-        },
-        enums: { result: ['pass', 'fail'] }
-    },
-    /*
-     * **자리의 물리 관측** — 어느 자리의 어느 속성을 언제 얼마로 쟀나.
-     *
-     * 값에 **단위를 함께** 받는다(`ValueType`). 단위 없는 물리량은 판정의 재료가 못 된다 — 3 이 섭씨인지
-     * 화씨인지 모르면 어떤 기준으로도 판정할 수 없다. 다만 **요구하지는 않는다**: 단위를 비우는 실 원본이
-     * 흔하고, 요구하면 그 원본의 관측을 아예 담지 못한다(그때 판정은 커널이 거부한다 — `outsideLimit`).
-     *
-     * `effectiveTime` 도 요구하지 않는다. 없으면 봉투의 시각이 그 자리를 대신한다(§`resolve`) — 원본이
-     * 시각을 말하지 않는 수기 점검이 실재하고, 그때 지어낸 시각보다 폴링 시각이 정직하다.
-     */
-    /*
-     * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 알린다.
-     *
-     * 둘 다 요구한다: 어느 목록인지와 그 주기를 **시작한** 시각. 시각이 없으면 무엇을 지울지 가릴 수
-     * 없고, 그때 지우면 전부 지운다 — 받지 않는 것이 옳다.
-     */
-    complete: {
-        eventType: OP_EVENT.complete,
-        identity: 'completeAxis',
-        required: ['completeAxis', 'since'],
-        fields: { completeAxis: 'string', since: 'string', recordTime: 'string' }
-    },
-    observation: {
-        eventType: OP_EVENT.observation,
-        identity: 'locationId',
-        /* 자리와 속성 — 둘 중 하나가 없으면 그 관측은 아무 데도 붙지 못한다. */
-        required: ['locationId', 'propertyId'],
-        fields: {
-            locationId: 'string', propertyId: 'string',
-            value: 'string', dataType: 'string', uom: 'string',
-            effectiveTime: 'string', effectiveEndTime: 'string', recordTime: 'string',
-            source: 'string', derived: 'boolean'
-        }
-    }
-};
-/**
- * 이 레코드가 어느 운영 사실인가 — **라우팅 판정을 한 곳에 둔다**(소비처가 각자 짐작하지 않게).
- *
- * EPCIS·에너지와 겹치지 않게 본다: `epc`·`meterId` 가 있으면 그쪽 어휘이고, `equipmentId` 는 설비
- * **에너지** 상태의 이름이다(운영 설비는 `moverId`). 품질은 설비와 정체 필드를 공유하므로 `good` 으로
- * 가른다 — 둘 다 아니면 어느 쪽인지 모르는 것이고, 모르면 받지 않는다.
- *
- * ── 순서가 뜻을 갖는다: **주체와 참조는 다르다** ────────────────────────────
- * 정체 필드는 하나만 오지 않는다. 설비·사람·자산 델타는 「지금 붙어 있는 작업」(`taskId`)을 함께 싣고,
- * 작업 델타는 「소속 오더」(`orderId`)를 함께 싣는다. 그래서 아무 정체 필드나 먼저 보면 **참조를 주체로
- * 읽는다** — 실제로 그랬다: `moverId` + `taskId` 인 설비 사실을 작업으로 읽어 「계약에 없는 필드」로
- * 거부했다. 자원(설비·사람·자산)을 먼저 보고, 작업을 오더보다 먼저 본다.
- */
-export function operationalKindOf(record) {
-    if (!record || typeof record !== 'object')
-        return undefined;
-    const r = record;
-    if (r.epc !== undefined || r.meterId !== undefined || r.equipmentId !== undefined)
-        return undefined;
-    const has = (k) => typeof r[k] === 'string' && r[k].trim().length > 0;
-    /* vocabulary-guard: allow 저널 와이어 필드로 가른다 */
-    if (has('moverId'))
-        return r.good !== undefined ? 'quality' : 'equipment';
-    if (has('personId'))
-        return 'person';
-    if (has('assetId'))
-        return 'asset';
-    if (has('taskId'))
-        return 'task'; // 작업이 든 `orderId` 는 소속(참조)이다
-    if (has('orderId'))
-        return 'order';
-    /*
-     * ── ★ **채널을 열고 들어오는 길을 내지 않았다** (2026-08-24) ─────────────────
-     * `OP_EVENT.test` 를 계약에 냈는데 이 라우팅이 `testableObjectId` 를 보지 않았다. 그래서 커넥터의
-     * 시험 결과가 **어느 통도 아니어서 조용히 버려졌다** — 거부 목록에도 남지 않았다(운영 경로를 아예
-     * 지나지 않으므로).
-     *
-     * 같은 부류가 하루에 세 번 났다: `ilmd`(매핑에 자리 없음) · 사건 시각(이름 어긋남) · 그리고 이것.
-     * **계약에 자리를 만드는 것과 그 자리로 가는 길을 내는 것은 다른 일이다.** 앞의 것만 하면 보내는
-     * 쪽에는 「실었다」로 보이고 화면에는 「없다」로 보인다.
-     *
-     * 순서상 뒤에 둔다 — 시험 결과가 작업·오더를 함께 가리킬 수 있고, 그때 그것은 **그 작업의 사실**이다.
-     */
-    if (has('testableObjectId'))
-        return 'test';
-    /*
-     * ── ★ **채널을 열고 또 길을 내지 않았다** (2026-08-24) ──────────────────────
-     * `OP_EVENT.observation`(`location.measured`)을 내고 상태(`LocationState.observations`)와 조회
-     * (`observationAt`)까지 붙였는데 **이 라우팅이 `locationId` 를 보지 않았다.** 커넥터가 방의 온습도를
-     * 실어 보내면 「어느 운영 사실인지 모른다」로 거부됐다.
-     *
-     * 같은 부류를 하루에 일곱 번 만났다. 다만 이번엔 **거부되고 이유가 남았다** — 시험 결과 때는 어느
-     * 통도 아니어서 조용히 사라졌다. 그 차이가 이것을 5분 만에 찾게 했다(§`isOperationalRecord`).
-     *
-     * **둘을 함께 요구한다.** `locationId` 만으로는 자리를 말하는 다른 사실과 섞인다. 관측은 「어느
-     * 자리의 **무엇**을 쟀나」이므로 속성 없이는 담을 곳이 없다 — 그때는 받지 않는 것이 옳다.
-     */
-    if (has('locationId') && has('propertyId'))
-        return 'observation';
-    /* 「이 목록이 전부다」 — 어느 목록인지를 스스로 말하므로 다른 사실과 섞이지 않는다. */
-    if (has('completeAxis'))
-        return 'complete';
-    return undefined;
-}
-/** 이 레코드가 운영 사실인가 — 호스트의 라우팅이 묻는 자리. */
-export function isOperationalRecord(record) {
-    return operationalKindOf(record) !== undefined;
-}
-/**
- * 운영 레코드들을 봉투로 — 유효한 것만 통과하고 나머지는 **이유와 함께** 남는다.
- *
- * 봉투는 다른 어휘와 같은 것을 쓴다(`CanonicalEnvelope`) — 그래서 저널·리플레이·시간여행·성과 폴드를
- * 그대로 얻는다. 어휘만 자기 것이다.
- */
-export function ingestOperationalRecords(records, opts) {
-    const arr = Array.isArray(records) ? records : records ? [records] : [];
-    const accepted = [];
-    const rejected = [];
-    let seq = 0;
-    for (const record of arr) {
-        const kind = operationalKindOf(record);
-        if (!kind) {
-            rejected.push({
-                record,
-                errors: ['어느 운영 사실인지 모른다 — 정체 필드가 필요하다(taskId · moverId(+good=품질) · personId · assetId · orderId)'] // vocabulary-guard: allow 거부 이유가 계약 필드 이름을 말한다
-            });
-            continue;
-        }
-        const spec = SPECS[kind];
-        const r = record;
-        const errors = [];
-        /*
-         * 모르는 이름은 거부한다 — 한 글자 틀린 필드가 오류 없이 사라지는 것을 막는다.
-         *
-         * 둘은 뺀다. **사실의 칸이 아니라 봉투의 칸**이다: `at` 은 그 사실이 일어난 시각이고,
-         * `description` 은 사람이 그때 적어 둔 말이다(§`CanonicalEnvelope.description`). 사실 칸으로
-         * 검사하면 명세마다 같은 두 줄을 적어야 하고, 한 곳을 빠뜨리면 그 통로만 거부한다.
-         */
-        const ENVELOPE_FIELDS = ['at', 'description'];
-        const unknown = Object.keys(r).filter(k => !ENVELOPE_FIELDS.includes(k) && spec.fields[k] === undefined);
-        if (unknown.length)
-            errors.push(`${kind}: 계약에 없는 필드 — ${unknown.join(', ')}`);
-        for (const name of spec.required) {
-            const v = r[name];
-            if (v === undefined || v === null || v === '')
-                errors.push(`${kind}: ${name} 없음 — 지어낼 수 없는 값이다`);
-        }
-        const data = {};
-        for (const [name, type] of Object.entries(spec.fields)) {
-            const v = r[name];
-            if (v === undefined || v === null || v === '')
-                continue;
-            switch (type) {
-                case 'string': {
-                    if (typeof v !== 'string') {
-                        errors.push(`${kind}.${name} 이 문자열이 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    const allowed = spec.enums?.[name];
-                    if (allowed && !allowed.includes(v)) {
-                        errors.push(`${kind}.${name} 이 커널이 다루는 낱말이 아니다: ${JSON.stringify(v)} — 받는 값은 ${allowed.join(' · ')}`);
-                        break;
-                    }
-                    data[name] = v;
-                    break;
-                }
-                case 'number': {
-                    const n = Number(v);
-                    if (typeof v === 'boolean' || !Number.isFinite(n)) {
-                        errors.push(`${kind}.${name} 가 수가 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    /* 진척은 비율이다 — 백분율(95)을 그대로 받으면 화면이 9,500% 를 말한다. */
-                    if (name === 'progress' && (n < 0 || n > 1)) {
-                        errors.push(`${kind}.progress 는 0~1 비율이다: ${n}`);
-                        break;
-                    }
-                    if ((name === 'requested' || name === 'fulfilled' || name === 'goodCount' || name === 'scrapCount') && n < 0) {
-                        errors.push(`${kind}.${name} 가 음수다: ${n}`);
-                        break;
-                    }
-                    data[name] = n;
-                    break;
-                }
-                case 'boolean': {
-                    if (typeof v !== 'boolean') {
-                        errors.push(`${kind}.${name} 가 참/거짓이 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    data[name] = v;
-                    break;
-                }
-                case 'string[]': {
-                    if (!Array.isArray(v) || v.some(x => typeof x !== 'string')) {
-                        errors.push(`${kind}.${name} 가 문자열 배열이 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    data[name] = v.slice();
-                    break;
-                }
-                case 'object': {
-                    if (Array.isArray(v) || typeof v !== 'object') {
-                        errors.push(`${kind}.${name} 가 객체가 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    data[name] = { ...v };
-                    break;
-                }
-                case 'object[]': {
-                    if (!Array.isArray(v) || v.some(x => !x || typeof x !== 'object')) {
-                        errors.push(`${kind}.${name} 가 객체 배열이 아니다: ${JSON.stringify(v)}`);
-                        break;
-                    }
-                    data[name] = v.map(x => ({ ...x }));
-                    break;
-                }
-            }
-        }
-        const at = String(r.at ?? '').trim() || opts.defaultEventTime;
-        const atMs = at ? Date.parse(at) : Number.NaN;
-        if (!Number.isFinite(atMs)) {
-            /* 시각이 없으면 순서를 판정할 수 없다 — 늦게 온 옛 사실이 최신 상태를 덮어써 위치가 과거로 튄다. */
-            errors.push(`${kind}: at 없음/형식 오류 — 시각 없이는 늦게 온 옛 사실을 걸러낼 수 없다`);
-        }
-        if (errors.length) {
-            rejected.push({ record, errors });
-            continue;
-        }
-        /* 사람이 적어 둔 말 — 봉투에 싣는다(§`CanonicalEnvelope.description`). 물류 쪽과 같은 자리다. */
-        const note = typeof r.description === 'string' ? String(r.description).trim() : '';
-        accepted.push({
-            eventId: `${opts.tenantId}-op-${kind}-${++seq}`,
-            eventType: spec.eventType,
-            eventTime: new Date(atMs).toISOString(),
-            tenantId: opts.tenantId,
-            ...(note ? { description: note } : {}),
-            data
-        });
-    }
-    return { accepted, rejected };
-}

package/dist/operations-capability.d.ts

@@ -1,117 +0,0 @@
-import { type CapacityAnalysis, type CapacityInput, type CapacityRequirement } from './capacity.ts';
-import { type ISOTime, type WorkCalendarEntry } from './contract.ts';
-/**
- * 능력의 종류 — **표준 열거형**(B2MML `CapabilityTypeType`). 우리 낱말을 새로 만들지 않는다.
- *
- * 표준 정의(스키마 주석 그대로 옮김):
- *  - `Committed` — 앞으로 쓰기로 약정된 용량
- *  - `Unattainable` — 설비 상태·점유·인원·자재 때문에 앞으로 쓸 수 없는 용량
- *  - `Available` — 앞으로 더 쓸 수 있는 용량
- *  - `Used` / `Unused` — **과거** 값(품질 합격분 / 안 쓰였거나 불합격분)
- *  - `Total` — 과거로는 Used+Unused, 미래로는 Available+Unattainable+Committed
- */
-export type CapabilityType = 'Used' | 'Unused' | 'Total' | 'Committed' | 'Available' | 'Unattainable' | 'Other';
-/** 활동의 종류 — 표준 열거형(`OperationsTypeType`). 지금 우리는 생산만 다룬다. */
-export type OperationsType = 'Production' | 'Maintenance' | 'Quality' | 'Inventory' | 'Mixed' | 'Other';
-/** 한 공정의 능력 — 미래 분해. */
-export interface OperationCapability {
-    operation: string;
-    /**
-     * 이 공정이 이 구간에 낼 수 있는 최대량 — `Committed + Available + Unattainable`.
-     *
-     * **`null` 은 "능력 없음" 이 아니라 "모른다"** 다: 공정 명세가 자원을 하나도 요구하지 않으면 상한이
-     * 서지 않는다. 0 으로 메우면 "이 공정은 아무것도 못 한다" 는 없는 사실이 생긴다.
-     */
-    total: number | null;
-    /** 이미 약정된 몫 — 이 구간에 납기가 걸린 미완 오더의 잔량. */
-    committed: number;
-    /**
-     * 지금 쓸 수 없는 자원 때문에 잃는 몫. 자원의 현재 사실을 받지 못했으면 **`null`**(모른다).
-     * 0 으로 내면 "고장도 자격 만료도 없다" 는 없는 사실이 된다.
-     */
-    unattainable: number | null;
-    /**
-     * 남은 능력 — `total − committed − unattainable`.
-     *
-     * **음수를 0 으로 깎지 않는다.** 음수는 사실이다(받을 수 없는 물량을 받았다). 가장 알아야 할 상태를
-     * `Math.max(0, …)` 하나로 덮는 일이 실제로 이 트윈에서 여러 번 있었다.
-     */
-    available: number | null;
-    /** 무엇이 **상한**을 정하고 있나 — 축과 등급(용량 분석이 이미 낸다). 선언 기준이다. */
-    constraint?: CapacityRequirement;
-    /**
-     * **남은 능력을 제약하는 축** — 달성불가를 되찾으려면 여기부터다. `unattainable > 0` 일 때만 있다.
-     *
-     * 상한을 제약하는 축과 **다를 수 있고**, 그 차이가 곧 사람이 헛걸음하는 자리다: 용접기 2대와 용접
-     * 자격자 2명이 같은 상한을 낼 때 상한은 어느 쪽으로도 제약되지만, 자격 하나가 만료돼 잃은 몫의
-     * 원인은 인원이다. 화면이 상한 쪽만 보이면 사람이 **설비를 보러 간다**(실제로 그랬다).
-     *
-     * 값은 이미 손에 있다 — 달성불가를 내려고 가용 자원 기준으로 같은 계산을 한 번 더 실행하기 때문이다.
-     * 그 계산이 제약하는 축이 곧 이 답이고, 따로 판정을 만들지 않는다.
-     */
-    unattainableBy?: CapacityRequirement;
-}
-export interface OperationsCapabilityReport {
-    /** 표준 `OperationsType` — 지금은 생산뿐이다(정비·품질 능력은 별도 보고서가 될 자리). */
-    operationsType: OperationsType;
-    /**
-     * 어느 구간의 능력인가 — **구간 없이 능력은 존재하지 않는다**(표준 `StartTime`·`EndTime`).
-     * `workingHours` 는 그 구간의 **가동 시간**이다(벽시계 시간이 아니다 — 쉬는 시간에는 안 나온다).
-     */
-    window: {
-        fromTime: ISOTime;
-        toTime: ISOTime;
-        workingHours: number;
-    };
-    perOperation: OperationCapability[];
-    /** 라인을 묶는 공정 — 용량 분석의 판정을 그대로 쓴다. */
-    bottleneck?: CapacityAnalysis['bottleneck'];
-    /** 이 보고서를 낸 시각(표준 `PublishedDate`). 부르는 쪽이 준다 — 커널은 벽시계를 읽지 않는다. */
-    publishedDate?: ISOTime;
-}
-/** 이 구간에 납기가 걸린 미완 오더 — 약정의 재료. */
-export interface CommittedDemand {
-    /** 남은 수량(요청 − 이행). 음수는 0 으로 본다(이행 초과는 약정이 아니다). */
-    remaining: number;
-    /** 납기 — 이 구간 안이어야 이 구간의 약정이다. 없으면 구간에 속하지 않는다(짐작하지 않는다). */
-    dueTime?: ISOTime;
-    /** 어느 공정의 약정인가. 없으면 **모든 공정에** 걸린다(라인 전체가 그 물량을 통과시켜야 한다). */
-    operation?: string;
-}
-export interface OperationsCapabilityInput {
-    /** 전량 선언 기준 — 이 모델이 가진 모든 자원. */
-    capacity: CapacityInput;
-    /**
-     * **지금 쓸 수 있는 자원만** 남긴 같은 입력. 없으면 `unattainable` 은 `null` 이다.
-     *
-     * 판정을 여기서 다시 하지 않는 이유: 판정은 한 벌이어야 하고 그 한 벌은 `capabilityOf` 다
-     * (고장·보류·교대·휴일·자격 만료·유효기간). 부르는 쪽이 그것으로 걸러 준 자원을 넘긴다.
-     */
-    usableCapacity?: CapacityInput;
-    window: {
-        fromTime: ISOTime;
-        toTime: ISOTime;
-    };
-    calendar?: readonly WorkCalendarEntry[];
-    utcOffsetMinutes?: number;
-    demands?: readonly CommittedDemand[];
-    operationsType?: OperationsType;
-    publishedDate?: ISOTime;
-}
-/**
- * 구간의 **가동 시간** — 1분 간격으로 캘린더에 묻는다.
- *
- * 규칙을 다시 적지 않는다(`inWorkCalendarAt` 한 곳에만 있다). 캘린더가 없으면 종일 가동으로 본다 —
- * 제약이 **선언되지 않은** 것이고, 선언이 없으면 커널은 멈출 이유를 모른다(용량 분석과 같은 규율).
- *
- * 비용은 구간에 비례한다(1년 = 약 53만 번의 값싼 호출). 근사하지 않는 이유: 한 주를 재서 곱하면
- * 공휴일이 사라지고, 그 오차는 조용하다.
- */
-export declare function workingHoursBetween(calendar: readonly WorkCalendarEntry[] | undefined, fromMs: number, toMs: number, utcOffsetMinutes?: number): number;
-/**
- * 생산 능력 보고서 — 있는 용량 분석 위에 **구간 · 종류 · 약정**을 올린다.
- *
- * 용량 분석을 두 번 부른다(전량 · 가용). 같은 함수를 두 번 부르는 것이 요점이다: 달성불가를 따로
- * 계산하면 규칙이 두 벌이 되고, 두 벌은 어긋난다.
- */
-export declare function operationsCapabilityOf(input: OperationsCapabilityInput): OperationsCapabilityReport;

package/dist/operations-capability.js

@@ -1,120 +0,0 @@
-/*
- * 생산 능력 — **ISA-95 Part 4 `OperationsCapability`**: "이 현장이 어느 구간에 얼마나 할 수 있는가."
- *
- * ── 왜 용량 분석만으로는 부족한가 ────────────────────────────────────────────
- * `capacity.ts` 는 이미 네 축(설비·인원·자산·자리) 정상상태 상한과 병목을 낸다. 그런데 그것은 **비율**
- * 이다(시간당 몇 대). 표준이 게시하라는 것은 **구간의 양**이고, 그 양을 **종류로 구분한다.**
- *
- * 종류가 없으면 답할 수 없는 질문이 있다 — 그리고 그것이 이 개념을 쓰는 가장 흔한 질문이다:
- * **"지금 주문을 더 받을 수 있나."** 상한만 있으면 "시간당 12대" 까지고, 이미 약속한 물량을 빼야
- * 비로소 남은 능력이 나온다.
- *
- * ── 표준의 어휘를 그대로 쓴다 ────────────────────────────────────────────────
- * `CapabilityType` 은 자유 문자열이 아니라 **열거형**이다(B2MML-Common.xsd 대조 완료). 그리고 표준은
- * `Total` 을 **두 갈래**로 쪼갠다:
- *
- *   · 과거 — `Total = Used + Unused`                        (쓴 몫 · 못 쓴 몫)
- *   · 미래 — `Total = Committed + Available + Unattainable`  (약정 · 가용 · 달성불가)
- *
- * 이 보고서는 **미래 쪽**이다. 과거 쪽은 이미 두 곳에 있다(설비 OEE 의 가동/유휴, 호스트의 구간
- * 가동률) — 우리가 "가동률이 두 벌이다" 로 본 것이 여기서 설명된다: **두 벌인 것이 맞고, 표준이 그
- * 둘을 다른 종류로 부른다.** 합칠 일이 아니라 각자 어느 종류인지 밝힐 일이다.
- *
- * `Unattainable` 의 표준 정의는 우리 판정과 정확히 겹친다 — *설비 상태·설비 점유·인원 가용성·자재
- * 가용성 때문에 앞으로 쓸 수 없는 용량.* 그래서 이 모듈은 그것을 **다시 판정하지 않는다**:
- * 부르는 쪽이 "전량 선언 기준" 과 "지금 쓸 수 있는 자원 기준" 두 벌을 주면, 그 **차이가 곧
- * 달성불가**다(§unattainableOf). 판정은 한 벌이어야 하고 그 한 벌은 `capabilityOf` 다.
- */
-import { analyzeCapacity } from "./capacity.js";
-import { inWorkCalendarAt } from "./contract.js";
-/**
- * 구간의 **가동 시간** — 1분 간격으로 캘린더에 묻는다.
- *
- * 규칙을 다시 적지 않는다(`inWorkCalendarAt` 한 곳에만 있다). 캘린더가 없으면 종일 가동으로 본다 —
- * 제약이 **선언되지 않은** 것이고, 선언이 없으면 커널은 멈출 이유를 모른다(용량 분석과 같은 규율).
- *
- * 비용은 구간에 비례한다(1년 = 약 53만 번의 값싼 호출). 근사하지 않는 이유: 한 주를 재서 곱하면
- * 공휴일이 사라지고, 그 오차는 조용하다.
- */
-export function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
-    if (!(toMs > fromMs))
-        return 0;
-    if (!calendar?.length)
-        return (toMs - fromMs) / 3_600_000;
-    let minutes = 0;
-    for (let ms = fromMs; ms < toMs; ms += 60_000)
-        if (inWorkCalendarAt(calendar, ms, utcOffsetMinutes))
-            minutes++;
-    return minutes / 60;
-}
-/**
- * 생산 능력 보고서 — 있는 용량 분석 위에 **구간 · 종류 · 약정**을 올린다.
- *
- * 용량 분석을 두 번 부른다(전량 · 가용). 같은 함수를 두 번 부르는 것이 요점이다: 달성불가를 따로
- * 계산하면 규칙이 두 벌이 되고, 두 벌은 어긋난다.
- */
-export function operationsCapabilityOf(input) {
-    const fromMs = Date.parse(input.window.fromTime);
-    const toMs = Date.parse(input.window.toTime);
-    if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
-        throw new Error(`능력의 구간을 읽을 수 없다: ${input.window.fromTime} ~ ${input.window.toTime}`);
-    }
-    if (toMs <= fromMs)
-        throw new Error(`능력의 구간이 뒤집혔다: ${input.window.fromTime} ~ ${input.window.toTime}`);
-    const workingHours = workingHoursBetween(input.calendar ?? input.capacity.calendar, fromMs, toMs, input.utcOffsetMinutes);
-    const full = analyzeCapacity(input.capacity);
-    const usable = input.usableCapacity ? analyzeCapacity(input.usableCapacity) : undefined;
-    /** 비율(시간당) → 구간의 양. 상한이 무한(요구가 없는 공정)이면 **모른다**. */
-    const amountOf = (perHour) => (Number.isFinite(perHour) ? perHour * workingHours : null);
-    const committedOf = (operation) => {
-        let sum = 0;
-        for (const d of input.demands ?? []) {
-            if (d.operation !== undefined && d.operation !== operation)
-                continue;
-            /* 납기가 없으면 이 구간의 약정이 아니다 — 짐작해서 넣으면 남은 능력이 실제보다 적게 보인다. */
-            if (!d.dueTime)
-                continue;
-            const due = Date.parse(d.dueTime);
-            if (!Number.isFinite(due) || due < fromMs || due >= toMs)
-                continue;
-            sum += Math.max(0, d.remaining);
-        }
-        return sum;
-    };
-    const perOperation = full.operations.map(op => {
-        const total = amountOf(op.perHour);
-        const committed = committedOf(op.operation);
-        /*
-         * 달성불가 = 전량 기준 − 가용 자원 기준. 자원의 현재 사실을 못 받았으면 **모른다**(0 이 아니다).
-         * 음수가 되는 일은 없어야 하지만(가용 ⊆ 전량), 되면 그것을 감추지 않고 0 으로 깎는다 — 부분집합이
-         * 아닌 입력을 받은 것이므로 값을 지어내는 대신 아래 `available` 이 어긋남을 드러낸다.
-         */
-        let unattainable = null;
-        let unattainableBy;
-        if (usable) {
-            const left = usable.operations.find(o => o.operation === op.operation);
-            const usableAmount = amountOf(left?.perHour ?? NaN);
-            unattainable = total != null && usableAmount != null ? Math.max(0, total - usableAmount) : null;
-            /* 잃은 몫이 있을 때만 원인을 말한다 — 잃은 것이 없는데 "여기부터" 라고 하면 없는 일을 만든다. */
-            if (unattainable != null && unattainable > 0 && left?.constraint)
-                unattainableBy = left.constraint;
-        }
-        const available = total == null || unattainable == null ? null : total - committed - unattainable;
-        return {
-            operation: op.operation,
-            total,
-            committed,
-            unattainable,
-            available,
-            ...(op.constraint ? { constraint: op.constraint } : {}),
-            ...(unattainableBy ? { unattainableBy } : {})
-        };
-    });
-    return {
-        operationsType: input.operationsType ?? 'Production',
-        window: { fromTime: input.window.fromTime, toTime: input.window.toTime, workingHours },
-        perOperation,
-        ...(full.bottleneck ? { bottleneck: full.bottleneck } : {}),
-        ...(input.publishedDate ? { publishedDate: input.publishedDate } : {})
-    };
-}

package/dist/scenario-validate.d.ts

@@ -1,15 +0,0 @@
-import type { ScenarioDef } from './contract.ts';
-export type ScenarioValidation = {
-    ok: true;
-} | {
-    ok: false;
-    errorCode: string;
-    errorParams?: Record<string, string | number>;
-};
-/**
- * 시나리오 선언이 실릴 수 있는가.
- *
- * 첫 번째 잘못에서 멈추고 그것을 말한다 — 전부 모아 보고하면 화면이 무엇부터 고칠지 알 수 없다.
- * 생성기가 하나도 없는 것은 **잘못이 아니다**(자극 없이 관측만 하는 시나리오는 성립한다).
- */
-export declare function validateScenario(def: ScenarioDef | undefined | null): ScenarioValidation;