@operato/twin-kernel 0.8.1 → 0.8.3

package/dist-cjs/index.cjs

@@ -63,7 +63,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../ops-contract/dist/capability.js
+// node_modules/@operato/ops-contract/dist/capability.js
 var CAPABILITIES = {
   operable: {
     key: "operable",
@@ -198,7 +198,7 @@ function stateFieldsOf(caps) {
   return [...out];
 }
 
-// ../ops-contract/dist/contract.js
+// node_modules/@operato/ops-contract/dist/contract.js
 var ORDER_TERMINAL_STATUS = ["completed", "cancelled"];
 function isOrderTerminal(o) {
   const status = String(o?.status ?? "").trim().toLowerCase();
@@ -779,7 +779,7 @@ function gs1Namespaces(prefix) {
   return [`urn:epc:idpat:sgtin:${prefix}.`, `urn:epc:class:lgtin:${prefix}.`, `urn:epc:id:sgtin:${prefix}.`];
 }
 
-// ../ops-contract/dist/capacity.js
+// node_modules/@operato/ops-contract/dist/capacity.js
 function isoDurationHours(iso2) {
   if (!iso2)
     return 0;
@@ -887,7 +887,7 @@ function analyzeCapacity(input) {
   };
 }
 
-// ../ops-contract/dist/wms-profile.js
+// node_modules/@operato/ops-contract/dist/wms-profile.js
 var BIZSTEP = {
   receiving: "urn:epcglobal:cbv:bizstep:receiving",
   storing: "urn:epcglobal:cbv:bizstep:storing",
@@ -917,7 +917,7 @@ var WMS_TYPES = [
   { key: "packer", role: "equipment", label: "twin.type.packer", standardClass: { epcis: "object", isa95: "Equipment" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
-// ../ops-contract/dist/yms-profile.js
+// node_modules/@operato/ops-contract/dist/yms-profile.js
 var YARD_BIZSTEP = {
   arriving: "urn:epcglobal:cbv:bizstep:arriving",
   // 게이트-인
@@ -943,7 +943,7 @@ var YMS_TYPES = [
   { key: "hostler", role: "equipment", label: "twin.type.hostler", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
 ];
 
-// ../ops-contract/dist/mes-profile.js
+// node_modules/@operato/ops-contract/dist/mes-profile.js
 var MES_BIZSTEP = {
   receiving: "urn:epcglobal:cbv:bizstep:receiving",
   // 원자재 수령
@@ -981,7 +981,7 @@ var MES_TYPES = [
   { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
-// ../ops-contract/dist/ems-profile.js
+// node_modules/@operato/ops-contract/dist/ems-profile.js
 var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
 var METER_DIRECTION = ["import", "export", "bidirectional"];
 var EMS_PROPERTY = {
@@ -1302,7 +1302,7 @@ function isElectricalLocationType(type) {
   return EMS_LOCATION_TYPES.includes(type);
 }
 
-// ../ops-contract/dist/domain-catalog.js
+// node_modules/@operato/ops-contract/dist/domain-catalog.js
 var locationKeys = (types) => types.filter((t) => t.role === "location").map((t) => t.key);
 var DOMAIN_CATALOG = {
   // label 은 언어 중립 i18n 키(twin.system.<code>) — 사람 언어는 표현계층이 렌더(L2).
@@ -1312,7 +1312,7 @@ var DOMAIN_CATALOG = {
   ems: { system: "ems", label: "twin.system.ems", types: EMS_TYPES, locationTypes: locationKeys(EMS_TYPES) }
 };
 
-// ../ops-contract/dist/domain-definition.js
+// node_modules/@operato/ops-contract/dist/domain-definition.js
 var OP_PARAM = {
   /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
   yield: "yield",
@@ -1321,7 +1321,7 @@ var OP_PARAM = {
   setupDuration: "setupDuration"
 };
 
-// ../ops-contract/dist/energy-ingest.js
+// node_modules/@operato/ops-contract/dist/energy-ingest.js
 function resolveSubject(kind, localId, opts) {
   const declared = opts.identityOf?.(kind, localId);
   if (declared)
@@ -1332,7 +1332,7 @@ function periodFactId(tenantId, kind, subject, from, to) {
   return [tenantId, kind, subject, from, to].join("|");
 }
 
-// ../ops-contract/dist/epcis.js
+// node_modules/@operato/ops-contract/dist/epcis.js
 var EPCIS_CONTEXT = "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld";
 var UTC_OFFSET = "+00:00";
 var DISP = {
@@ -1591,7 +1591,7 @@ function transformationEvent(p) {
   return e;
 }
 
-// ../ops-contract/dist/iso-duration.js
+// node_modules/@operato/ops-contract/dist/iso-duration.js
 var RE = /^(-)?P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
 function parseIsoDuration(text) {
   if (typeof text !== "string")
@@ -1617,7 +1617,7 @@ function parseIsoDuration(text) {
   return sign ? -ms2 : ms2;
 }
 
-// ../ops-contract/dist/master-data.js
+// node_modules/@operato/ops-contract/dist/master-data.js
 function expiryFromAttributes(attrs) {
   return readEpochMs(attrs?.[ILMD_ATTR.expiry]);
 }
@@ -1634,7 +1634,7 @@ function readEpochMs(raw) {
   return Number.isNaN(at) ? void 0 : at;
 }
 
-// ../ops-contract/dist/operational-ingest.js
+// node_modules/@operato/ops-contract/dist/operational-ingest.js
 var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
 var EQUIPMENT_STATUS = ["idle", "busy", "down"];
 var PERSON_STATUS = ["idle", "busy"];
@@ -1842,7 +1842,7 @@ var SPECS = {
   }
 };
 
-// ../ops-contract/dist/operations-capability.js
+// node_modules/@operato/ops-contract/dist/operations-capability.js
 function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
   if (!(toMs > fromMs))
     return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {
@@ -28,6 +28,6 @@
     "test": "node --test test/*.test.ts"
   },
   "dependencies": {
-    "@operato/ops-contract": "^0.1.0"
+    "@operato/ops-contract": "^0.3.0"
   }
 }

package/dist/capability.d.ts

@@ -1,142 +0,0 @@
-export type CapabilityKey = 'operable' | 'storable' | 'mobile' | 'processable' | 'trackable' | 'switching' | 'metered' | 'curtailable' | 'energyGenerating' | 'energyStoring';
-/** 이동 관측 — Mobile 이 노출. */
-export interface Motion {
-    fromNode: string;
-    toNode: string;
-    startedAtSimMs: number;
-    durationMs: number;
-    progress: number;
-    elapsedMs: number;
-}
-export interface OperableState {
-    status: 'idle' | 'busy' | 'down';
-}
-export interface StorableState {
-    occupancy: number;
-    capacity: number;
-}
-export interface MobileState {
-    location: string;
-    motion?: Motion;
-}
-export interface ProcessableState {
-    output?: {
-        good: number;
-        scrap: number;
-    };
-}
-export interface TrackableState {
-    lifecycle: string;
-    progress?: number;
-    held: boolean;
-}
-/**
- * 계량 — 이 자원은 **자기 소비를 잰다.**
- *
- * `kW` 는 그 계량 주기의 평균이고 순시값이 아니다(순시는 전력 품질의 영역이라 범위 밖).
- * `kWh` 는 계기 누적값 — 차분은 소비처가 한다(계기 교체·리셋을 우리가 지어내지 않는다).
- * 값이 오지 않는 계량기는 `0` 이 아니라 **모르는 것**이므로 필드가 없다(선택 필드인 이유).
- */
-export interface MeteredState {
-    kW?: number;
-    kWh?: number;
-    powerFactor?: number;
-}
-/** 감축 가능 — 줄일 수 있다. `minKW` 는 최소 유지(그 아래로 내리면 공정이 죽는다). */
-export interface CurtailableState {
-    curtailable: boolean;
-    minKW?: number;
-}
-/**
- * 전기 계측 — 전압(V)·전류(A). 전기를 만들거나 쓰는 어떤 설비에서나 같은 모양이다.
- *
- * 발전·저장·개폐 어느 능력에나 붙을 수 있어 따로 둔다. 상별 값은 배열이다(단상이면 원소 하나).
- */
-export interface ElectricalMeasurementState {
-    dcVoltage?: number;
-    dcCurrent?: number;
-    acVoltage?: number[];
-    acCurrent?: number[];
-}
-/** 발전 — 만든다. 역송(`exportKW`)은 소비의 음수가 아니라 별개 사실이다. */
-export interface GeneratingState extends ElectricalMeasurementState {
-    generatedKW?: number;
-    exportKW?: number;
-    generatedKWh?: number;
-    generatedKWhResetAt?: string;
-    /** 지금 든 적산이 무엇부터 쌓인 것인가 — 원본이 말했을 때만 있다. */
-    generatedKWhSince?: string;
-    /** 되돌아간 판정이 사실인가 짐작인가 — 'declared' 또는 'inferred'. */
-    generatedKWhBasis?: 'declared' | 'inferred';
-    /** 어떤 누적인가 — 원본이 말하지 않으면 'unknown' 이다(칸이 비지 않는다). */
-    generatedKWhAccumulation?: 'lifetime' | 'daily' | 'monthly' | 'billing' | 'unknown';
-    /** 끝난 기간의 발전량(kWh) — 성과지표가 기간당 에너지로 정의된다. */
-    generatedKWhLastPeriod?: number;
-    /** 그 기간이 끝난 시각. */
-    generatedKWhLastPeriodEnd?: string;
-    /** 그 기간에서 처음·마지막으로 관측한 시각 — 기간 경계와 다르면 그만큼 재지 않았다. */
-    generatedKWhLastPeriodObservedFrom?: string;
-    generatedKWhLastPeriodObservedTo?: string;
-}
-/** 저장 — 담고 낸다. 충전과 방전을 나눈다(손실·수명 판단이 둘을 구별해야 한다). */
-export interface StoringState {
-    soc?: number;
-    chargeKW?: number;
-    dischargeKW?: number;
-}
-/**
- * 개폐 위치 — IEC 61850 `XCBR.Pos`·`XSWI.Pos` 의 넷 값을 그대로 쓴다.
- *
- * `intermediate`(과도)와 `bad`(위치 불량)를 **뭉개지 않는다**: 실 계통에서 이 둘은 이중 접점이 서로
- * 다른 말을 하는 상태이고, 「열림/닫힘」으로 반올림하면 트윈이 없는 확신을 갖는다.
- */
-export interface SwitchingState {
-    position?: 'open' | 'closed' | 'intermediate' | 'bad';
-}
-/** 능력 관측 계약 메타(발견·검증). ops 없음(원칙 ①). */
-export interface CapabilitySpec {
-    key: CapabilityKey;
-    label: string;
-    semantics: string;
-    /** 관측 상태 필드(데이터 형식). 직교 — 어느 필드도 두 능력에 중복 없음(원칙 ②). */
-    stateFields: string[];
-    /**
-     * 이 능력을 가진 자원이 **받는 명령** — 나가는 사실(`results`)의 짝.
-     *
-     * ── 계약이 반쪽이었다 (2026-08-15) ────────────────────────────────────────
-     * 능력은 「무슨 값을 내보내는가」만 선언하고 있었다. 그런데 저작면이 알아야 할 것이 하나 더 있다:
-     * 「여기에 제어를 붙여도 되는가」. 적을 자리가 없어서 **능력 이름으로 눈치껏** 판단했다 —
-     * `operable` 이면 제어를 권하고 아니면 안 권했다.
-     *
-     * 차단기에서 그 방식이 막혔다. 상태는 보여주고 싶은데 `operable` 을 주면 화면이 우리가 하지 않기로
-     * 한 조작을 권한다. 그래서 능력을 새로 만들었고(`switching`), 능력은 상태 필드로 정의되므로 새
-     * 필드가 필요했는데 마침 표준이 `position` 이라는 이름을 줘서 됐다 — **그건 운이었다.**
-     *
-     * 없던 것은 참/거짓 하나가 아니라 **대칭**이다: 나가는 것은 선언돼 있고 들어오는 것은 없었다.
-     * 명령 어휘(`CMD`)는 이미 능력별로 묶여 있었지만 그 묶임이 **주석에만** 있었다 — 여기로 옮긴다.
-     *
-     * 비어 있다는 것이 곧 「조작하지 않는다」이다. 「명령을 받나」는 이 목록에서 **파생**된다 —
-     * 그래서 형용사를 새로 만들지 않는다.
-     *
-     * 트윈 수준 명령(`attention.ack`·`resource.add`)은 특정 자원의 능력이 아니므로 여기 넣지 않는다.
-     * 모든 명령이 능력에 속해야 한다는 규칙을 만들면 그것이 다음 땜빵이 된다.
-     */
-    commands: string[];
-    /** 교환 데이터 모델 이름. */
-    models?: string[];
-    /** 불변식(모두 준수·신뢰). */
-    invariants?: string[];
-    /** 실행 결과(이벤트) 형식. */
-    results?: string[];
-}
-export declare const CAPABILITIES: Record<CapabilityKey, CapabilitySpec>;
-export declare const CAPABILITY_KEYS: CapabilityKey[];
-/** 능력 집합이 관측 노출하는 상태 필드 합집합(직교이므로 단순 병합). */
-export declare function stateFieldsOf(caps: CapabilityKey[]): string[];
-/**
- * 능력 집합이 **받는 명령**의 합집합 — `stateFieldsOf` 의 짝.
- *
- * 「이 자원에 제어를 붙여도 되는가」는 이 목록이 비었는지로 **파생**한다. 그래서 `controllable` 같은
- * 형용사를 따로 두지 않는다 — 형용사를 두면 목록과 형용사가 언젠가 어긋나고, 어긋난 쪽이 화면이 된다.
- */
-export declare function commandsOf(caps: CapabilityKey[]): string[];

package/dist/capability.js

@@ -1,127 +0,0 @@
-/*
- * 능력(capability) = 관측 계약(observable contract). 사상 토대: design/plans/capability-contract.md.
- *
- * 원칙 ① 관측만 — state(데이터형식)+models+invariants+results 만 계약. ops/구현은 없음(커널·씬 각 시뮬 자유).
- *        "교환되는 것"을 계약하고 "계산하는 법"은 계약하지 않는다(결정성 지옥 회피·공유 가능성 핵심).
- * 원칙 ② 직교·조합 — 교차 관심사 status 는 Operable 하나에만(중복 제거). 엔티티는 능력 *조합*.
- * 원칙 ③ 작은 코어 + 열린 확장(무방언) — 도메인이 능력 선언, 코어는 발명 안 함.
- * 원칙 ④ 능력 ⟂ standardClass — 다른 축, 파생 없음.
- *
- * things-scene 정합: 이건 "의도(intent)" 계층(관측). 씬 기제 믹스(Capacity/Transferable/CarrierLine …)가
- * 이 의도를 *실현*한다 — 공유 계약은 관측(계층 B)뿐, 기제 methods(계층 A)는 공유 안 함.
- * ⚠ Mobile ≠ Transferable: Mobile=자원 자신이 이동, Transferable=자리가 아이템 이동(씬 기제).
- */
-/*
- * `label` 은 **언어 중립 i18n 키**(`twin.capability.<key>`) — 사람 언어는 표현계층이 렌더한다(L2).
- * 타입/시스템 라벨(domain-catalog)이 먼저 이 규약으로 옮겨졌고, 능력 라벨만 사람 말로 남아
- * 영어 화면에 한글이 새고 있었다. `semantics` 는 설계 문서용 산문이므로 대상이 아니다.
- */
-export const CAPABILITIES = {
-    operable: {
-        key: 'operable', label: 'twin.capability.operable', semantics: '능동 자원의 운영 상태(유휴/가동/고장). status 교차 관심사를 여기 하나로.',
-        commands: ['resource.hold', 'resource.resume', 'resource.down', 'resource.repair', 'resource.reset-metrics'],
-        stateFields: ['status'], results: ['statusChanged']
-    },
-    storable: {
-        key: 'storable', label: 'twin.capability.storable', semantics: '아이템을 보유하는 위치 — 점유/용량. (씬 기제: Capacity)',
-        commands: [],
-        stateFields: ['occupancy', 'capacity'], invariants: ['0 <= occupancy <= capacity (capacity>0)'], results: ['occupancyChanged']
-    },
-    mobile: {
-        key: 'mobile', label: 'twin.capability.mobile', semantics: '자원 자신이 자리 간 이동. Transferable(아이템 이동)과 다름. (씬 기제: CarrierLine)',
-        commands: [],
-        stateFields: ['location', 'motion'], models: ['Motion'], results: ['moved', 'motionTick']
-    },
-    processable: {
-        key: 'processable', label: 'twin.capability.processable', semantics: '변환/가공 수행 — 산출(양품/불량). 운영 status 는 Operable 조합. progress 방출은 후속.',
-        commands: [],
-        stateFields: ['output'], results: ['completed']
-    },
-    /*
-     * ── 「위치를 읽는다」 ≠ 「조작할 수 있다」 (2026-08-14) ─────────────────────
-     * 차단기는 이 둘이 갈리는 자리다. 상태를 읽어 계통 구성을 알지만 **우리는 조작하지 않는다**
-     * (안전 계통은 범위 밖: profiles/ems.md §1). 그런데 능력을 `operable` 로 주면 저작면이 그 설비에
-     * **제어 컴포넌트를 권한다** — 화면이 우리가 하지 않기로 한 것을 하라고 부추긴다.
-     *
-     * 그래서 개폐 기기의 관측을 따로 세운다. 이름을 `observable` 로 하지 않은 이유: 그러면 상태 필드가
-     * `status` 여야 하고 그건 `operable` 의 것이다(원칙 ② 직교). 없는 필드를 지어내는 대신 **표준이 주는
-     * 이름**을 쓴다 — 개폐 기기의 관측은 `Pos`(위치)다.
-     *
-     * `operable` 은 그대로 「명령을 받는 능동 자원」의 자리로 남는다.
-     */
-    switching: {
-        key: 'switching', label: 'twin.capability.switching', semantics: '회로를 열고 닫는 기기의 **위치를 읽는다** — 우리는 조작하지 않는다(명령 없음). IEC 61850 XCBR/XSWI Pos.',
-        commands: [],
-        stateFields: ['position'], models: ['SwitchingState'], results: ['positionChanged']
-    },
-    trackable: {
-        key: 'trackable', label: 'twin.capability.trackable', semantics: '오더/아이템 생애 추적 — 생애단계(도메인 라벨, 무방언)·진행·보류.',
-        commands: ['order.hold', 'order.resume', 'order.release'],
-        stateFields: ['lifecycle', 'progress', 'held'], results: ['lifecycleChanged']
-    },
-    /*
-     * ── 에너지 능력 넷 ──────────────────────────────────────────────────────
-     * 상태 필드는 기존 능력과 **직교**한다(원칙 ②) — 어느 필드도 두 능력에 겹치지 않는다.
-     * 계량은 `operable`(가동 상태)과도 직교한다: 도는 것과 재는 것은 다른 사실이고, 멈춘 설비도
-     * 대기전력을 쓴다.
-     */
-    metered: {
-        key: 'metered', label: 'twin.capability.metered', semantics: '자기 소비를 잰다 — 유효전력·누적량·역률. 값이 없으면 모르는 것이다(0 이 아니다).',
-        commands: [],
-        stateFields: ['kW', 'kWh', 'powerFactor'], models: ['MeteredState'], results: ['measured']
-    },
-    curtailable: {
-        key: 'curtailable', label: 'twin.capability.curtailable', semantics: '줄일 수 있다 — 최소 유지 아래로는 내리지 않는다. 판정만 하고 집행은 사람과 그 시스템의 몫이다.',
-        commands: [],
-        stateFields: ['curtailable', 'minKW'], models: ['CurtailableState'], invariants: ['minKW >= 0'], results: ['drSuggested']
-    },
-    energyGenerating: {
-        key: 'energyGenerating', label: 'twin.capability.energyGenerating', semantics: '전기를 만든다 — 역송은 소비의 음수가 아니라 별개 사실이다.',
-        commands: [],
-        /*
-         * ── 적산을 더한다 (2026-08-26) ─────────────────────────────────────────────
-         * 이 능력이 순시 출력만 선언하고 있었다. 그래서 「지금 발전 중」은 말하고 「얼마나 발전했나」는 말할
-         * 수 없었다 — 사건 이름(`energy.generated`)과 설계 문서에는 처음부터 있던 사실이다.
-         *
-         * 계량 능력(`metered`)이 `kW` 와 `kWh` 를 함께 선언한 것과 같은 짝이다. 적산은 발전 설비의 보편적
-         * 사실이고(태양광·열병합·디젤), 그것이 없으면 성능비·발전시간 같은 성과를 아무도 셀 수 없다.
-         */
-        stateFields: ['generatedKW', 'exportKW', 'generatedKWh', 'generatedKWhResetAt', 'generatedKWhSince', 'generatedKWhBasis', 'generatedKWhAccumulation', 'generatedKWhLastPeriod', 'generatedKWhLastPeriodEnd', 'generatedKWhLastPeriodObservedFrom', 'generatedKWhLastPeriodObservedTo', 'dcVoltage', 'dcCurrent', 'acVoltage', 'acCurrent'], models: ['GeneratingState'], results: ['generated']
-    },
-    /*
-     * ── 왜 `storing` 이 아니라 `energyStoring` 인가 (2026-08-15) ────────────────
-     * 같은 카탈로그에 `storable`(물건을 담는 자리)이 있다. 전기를 담는 것과 물건을 담는 것이 한 글자
-     * 차이로 붙어 있어서, 컴포넌트를 만들 때 `twin-storage` 를 피해 `twin-storage-energy` 로 도망쳤다 —
-     * 한 이름을 두 번 피해 갔다면 그 이름이 틀린 것이다.
-     *
-     * 도메인(EMS)이 아니라 **양(에너지)** 을 이름에 넣는다. 그래서 MES 트윈 안의 디젤 발전기도 그대로
-     * `energyGenerating` 이다 — 능력은 도메인이 아니라 관측의 면이다(방언 없음).
-     */
-    energyStoring: {
-        key: 'energyStoring', label: 'twin.capability.energyStoring', semantics: '담고 낸다 — 충전과 방전을 나눈다(손실·수명 판단이 둘을 구별해야 한다).',
-        commands: [],
-        stateFields: ['soc', 'chargeKW', 'dischargeKW'], models: ['StoringState'], invariants: ['0 <= soc <= 100'], results: ['stored', 'discharged']
-    }
-};
-export const CAPABILITY_KEYS = ['operable', 'storable', 'mobile', 'processable', 'trackable', 'switching', 'metered', 'curtailable', 'energyGenerating', 'energyStoring'];
-/** 능력 집합이 관측 노출하는 상태 필드 합집합(직교이므로 단순 병합). */
-export function stateFieldsOf(caps) {
-    const out = new Set();
-    for (const c of caps)
-        for (const f of CAPABILITIES[c]?.stateFields ?? [])
-            out.add(f);
-    return [...out];
-}
-/**
- * 능력 집합이 **받는 명령**의 합집합 — `stateFieldsOf` 의 짝.
- *
- * 「이 자원에 제어를 붙여도 되는가」는 이 목록이 비었는지로 **파생**한다. 그래서 `controllable` 같은
- * 형용사를 따로 두지 않는다 — 형용사를 두면 목록과 형용사가 언젠가 어긋나고, 어긋난 쪽이 화면이 된다.
- */
-export function commandsOf(caps) {
-    const out = new Set();
-    for (const c of caps)
-        for (const cmd of CAPABILITIES[c]?.commands ?? [])
-            out.add(cmd);
-    return [...out];
-}

package/dist/capacity.d.ts

@@ -1,99 +0,0 @@
-import { type WorkCalendarEntry } from './contract.ts';
-import type { OperationDef } from './domain-definition.ts';
-/** 제약이 걸린 축 — 무엇을 늘려야 하는지가 여기서 갈린다. */
-export type CapacityAxis = 'equipment' | 'personnel' | 'asset' | 'location';
-export interface CapacityRequirement {
-    axis: CapacityAxis;
-    /** 요구 등급/종류(설비 kind · 인원 class · 자산 class · 자리 type). */
-    className: string;
-    /** 작업 한 건이 동시에 잡는 수. */
-    quantity: number;
-    /** 실제로 있는 수. */
-    available: number;
-    /** 가동률 — 설비만 mtbf/mttr 에서 나온다. 나머지는 1(모델 없음). */
-    availability: number;
-    /** 이 요구만 놓고 봤을 때 시간당 낼 수 있는 대수. */
-    perHour: number;
-}
-export interface OperationCapacity {
-    operation: string;
-    cycleHours: number;
-    /** 이 공정이 시간당 낼 수 있는 대수 = 요구들 중 가장 낮은 것. */
-    perHour: number;
-    /** 하류 수율까지 물린 소요량. */
-    requiredPerHour: number;
-    ok: boolean;
-    /** 이 공정을 묶고 있는 요구(가장 낮은 것). 요구가 하나도 없으면 없다. */
-    constraint?: CapacityRequirement;
-    requirements: CapacityRequirement[];
-}
-export interface CapacityAnalysis {
-    /** 근무 캘린더를 실제로 샘플링해서 얻는다 — 규칙을 다시 적지 않는다. */
-    workingHoursPerWeek: number;
-    workingDaysPerWeek: number;
-    demandPerHour: number;
-    operations: OperationCapacity[];
-    /** 라인 전체를 묶고 있는 공정과 축. 공정이 없으면 없다. */
-    bottleneck?: {
-        operation: string;
-        axis?: CapacityAxis;
-        className?: string;
-    };
-    /** 이 공장의 상한(하루). */
-    maxUnitsPerDay: number;
-    ok: boolean;
-}
-export interface CapacityInput {
-    operations: readonly OperationDef[];
-    /** 라우트 순서 — 수율을 거슬러 올릴 때 쓴다. 없으면 `operations` 순서를 쓴다. */
-    route?: readonly string[];
-    equipment?: readonly {
-        kind: string;
-        mtbfMs?: number;
-        mttrMs?: number;
-    }[];
-    persons?: readonly {
-        personnelClassIds?: readonly string[];
-    }[];
-    assets?: readonly {
-        assetClassIds?: readonly string[];
-    }[];
-    locations?: readonly {
-        type?: string;
-        capacity?: number;
-    }[];
-    calendar?: readonly WorkCalendarEntry[];
-    /**
-     * 가용 시간을 샘플링할 기준 주의 시작(월요일 00:00, ms).
-     *
-     * **공휴일이 없는 평상주를 골라야 한다** — 공휴일은 연간 가용량을 따로 깎지, 이 공장의 평상시
-     * 상한을 정하지 않는다. 기본값을 두지 않는 이유: 커널이 임의의 주를 고르면 그 주에 공휴일이
-     * 들어 있을 때 상한이 조용히 낮아진다.
-     */
-    sampleWeekStartMs: number;
-    utcOffsetMinutes?: number;
-    /** 하루 몇 대를 낼 것인가 — 선언된 수요. */
-    unitsPerDay: number;
-}
-/** ISO 8601 기간 → 시간. 명세가 쓰는 표기 그대로 읽는다(`PT1H40M`). */
-export declare function isoDurationHours(iso: string | undefined): number;
-/**
- * 근무 캘린더에서 **가용 시간과 조업일**을 읽는다 — 1분 간격 샘플링.
- *
- * 교대·휴게·비근무 규칙을 여기 다시 적지 않는다. 규칙은 `inWorkCalendarAt` 한 곳에만 있고, 이 함수는
- * 그것에 묻기만 한다. 두 벌이 되면 달력을 고칠 때 한쪽만 고쳐져 어긋난다.
- *
- * 캘린더가 없으면 **종일 가동**으로 본다(7일 × 24h) — 제약이 없는 것이 아니라 **선언되지 않은** 것이고,
- * 선언이 없으면 커널은 멈출 이유를 모른다.
- */
-export declare function workingTimeOfWeek(calendar: readonly WorkCalendarEntry[] | undefined, weekStartMs: number, utcOffsetMinutes?: number): {
-    hoursPerWeek: number;
-    daysPerWeek: number;
-};
-/**
- * 이 공장이 선언된 물량을 낼 수 있는가 — 공정마다, 자원 축마다.
- *
- * 순수 함수다. 커널 상태를 읽지 않고 넘겨받은 것만 본다 — 그래야 "이 설비를 두 대 더 놓으면?" 을
- * 실행해 보지 않고 물을 수 있다(what-if 의 가장 싼 형태).
- */
-export declare function analyzeCapacity(input: CapacityInput): CapacityAnalysis;