@operato/twin-kernel 0.2.3 → 0.4.0

package/dist/forecast.d.ts

@@ -8,7 +8,7 @@ export interface ForecastTwin {
     /**
      * 시뮬 시각(ms) — **구동 루프가 시각만 읽을 때 쓰는 값.**
      *
-     * 없으면 `getSnapshot().simClockMs` 로 떨어지지만, 그 경로는 전 노드·물품·자원·작업·오더를 새로
+     * 없으면 `getSnapshot().simClockMs` 로 떨어지지만, 그 경로는 전 자리·물품·자원·작업·오더를 새로
      * 재료화하고 주목 신호까지 계산한 뒤 숫자 하나만 꺼내 버린다 — tick 마다 그러면 상태 크기 × 지평선
      * 길이만큼 낭비가 쌓인다(물품 1만 건·30분 지평선에서 측정: 루프 조건에만 149ms vs 0ms).
      */

package/dist/index.d.ts

@@ -15,12 +15,15 @@ export * from './iso-duration.ts';
 export * from './observed-reducer.ts';
 export * from './state-projector.ts';
 export * from './task-fold.ts';
+export * from './job-response.ts';
 export * from './face2-adapter.ts';
 export * from './runtime.ts';
 export * from './yms-profile.ts';
 export * from './mes-profile.ts';
 export * from './flow-engine.ts';
+export * from './capacity.ts';
 export { WmsKernel } from './kernel.ts';
 export { YmsKernel } from './yms-kernel.ts';
 export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS, MES_PRODUCTS } from './mes-kernel.ts';
 export type { MesDefinitionSpec } from './mes-kernel.ts';
+export * from './vocabulary.ts';

package/dist/index.js

@@ -15,11 +15,14 @@ export * from "./iso-duration.js";
 export * from "./observed-reducer.js";
 export * from "./state-projector.js";
 export * from "./task-fold.js";
+export * from "./job-response.js";
 export * from "./face2-adapter.js";
 export * from "./runtime.js";
 export * from "./yms-profile.js";
 export * from "./mes-profile.js";
 export * from "./flow-engine.js";
+export * from "./capacity.js";
 export { WmsKernel } from "./kernel.js";
 export { YmsKernel } from "./yms-kernel.js";
 export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS, MES_PRODUCTS } from "./mes-kernel.js";
+export * from "./vocabulary.js";

package/dist/job-response.d.ts

@@ -0,0 +1,59 @@
+import type { ISOTime } from './contract.ts';
+import { type TaskDeltaRow } from './task-fold.ts';
+/** 표준 `JobState` — 우리 작업 상태를 표준 낱말로 옮긴다. */
+export type JobState = 'ready' | 'running' | 'completed';
+/** 자원 실적 한 줄 — 표준 `OpPersonnelActualType`/`OpEquipmentActualType` 의 우리 부분집합. */
+export interface ResourceActual {
+    /** 표준 `PersonID`/`EquipmentID`. */
+    id: string;
+    /** 표준 `Quantity`. 우리는 개체를 지목하므로 언제나 1이다(등급 단위 집계는 소비처의 일). */
+    quantity: number;
+}
+/** 자재 실적 한 줄 — 표준 `OpMaterialActualType` 의 우리 부분집합. */
+export interface MaterialActual {
+    /** 표준 `MaterialDefinitionID`. */
+    definitionId: string;
+    /** 표준 `MaterialUse`. */
+    use: 'consumed' | 'produced';
+    quantity: number;
+    uom?: string;
+}
+export interface JobResponse {
+    /** 표준 `ID` — 작업 식별자. */
+    id: string;
+    /** 표준 `JobOrderID` — 소속 오더. **없으면 없는 것이다**(다른 식별자로 대체하지 않는다). */
+    jobOrderId?: string;
+    /** 표준 `WorkType` — 작업 종류(우리 `kind`). */
+    workType?: string;
+    /** 표준 `JobState`. */
+    jobState: JobState;
+    /** 표준 `StartTime` — **실제** 착수. 착수 기록을 못 찾으면 없다(짐작하지 않는다). */
+    startTime?: ISOTime;
+    /** 표준 `EndTime` — **실제** 완료. */
+    endTime?: ISOTime;
+    /** 표준 `PersonnelActual`. */
+    personnelActual?: ResourceActual[];
+    /** 표준 `EquipmentActual`. */
+    equipmentActual?: ResourceActual[];
+    /**
+     * 표준 `PhysicalAssetActual` — **실제로 쓰인 반복사용 자산**(팔레트·용기 등).
+     *
+     * 작업이 이미 들고 있던 사실인데 실적에서 빠져 있었다. 빠지면 "그 출고에 팔레트 몇 장이 나갔나" 를
+     * 실적으로 답할 수 없고, 자산 회수 계획이 근거를 잃는다.
+     */
+    physicalAssetActual?: ResourceActual[];
+    /** 표준 `MaterialActual`. */
+    materialActual?: MaterialActual[];
+}
+/** 저널 한 줄에서 자원·자재 실적을 읽기 위한 최소 모양(작업 폴드가 보는 것과 같은 줄). */
+type Row = TaskDeltaRow;
+/**
+ * 저널을 접어 **작업별 실적 회신**을 만든다 — 표준 이름으로.
+ *
+ * 짝맞춤(어느 전이가 한 작업인가)은 **커널 규칙**(`foldTaskRecords`)을 그대로 쓴다. 여기서 다시 짝을
+ * 맞추면 같은 저널이 지표에서는 3건, 실적에서는 4건이 되는 일이 생긴다 — 실제로 겪은 부류다.
+ *
+ * 자원·자재 실적은 전이가 실어 온 값에서 모은다. **마지막에 본 값**이 사실이다(재전송이면 나중 것).
+ */
+export declare function foldJobResponses(rows: readonly Row[]): JobResponse[];
+export {};

package/dist/job-response.js

@@ -0,0 +1,56 @@
+import { foldTaskRecords } from "./task-fold.js";
+const iso = (ms) => (typeof ms === 'number' ? new Date(ms).toISOString() : undefined);
+const dataOf = (r) => {
+    const p = r.payload;
+    return r.data ?? p?.data ?? p ?? {};
+};
+/**
+ * 저널을 접어 **작업별 실적 회신**을 만든다 — 표준 이름으로.
+ *
+ * 짝맞춤(어느 전이가 한 작업인가)은 **커널 규칙**(`foldTaskRecords`)을 그대로 쓴다. 여기서 다시 짝을
+ * 맞추면 같은 저널이 지표에서는 3건, 실적에서는 4건이 되는 일이 생긴다 — 실제로 겪은 부류다.
+ *
+ * 자원·자재 실적은 전이가 실어 온 값에서 모은다. **마지막에 본 값**이 사실이다(재전송이면 나중 것).
+ */
+export function foldJobResponses(rows) {
+    const { records } = foldTaskRecords(rows);
+    /* 자원·자재는 작업 폴드가 모으는 축(facets) 밖이라 여기서 한 번 더 훑는다 — 작업 폴드의 뜻을
+       넓히지 않는다(그것은 "언제" 를 아는 모듈이고, 이것은 "무엇으로" 를 아는 모듈이다). */
+    const extra = new Map();
+    for (const r of rows) {
+        const d = dataOf(r);
+        const id = typeof d.taskId === 'string' ? d.taskId : undefined;
+        if (!id)
+            continue;
+        const cur = extra.get(id) ?? {};
+        if (Array.isArray(d.personnel))
+            cur.personnel = d.personnel;
+        /* 대표 자원 하나만 온 전이도 있다(`resourceRef`) — 함께 잡힌 목록이 있으면 그것이 더 완전하다. */
+        if (Array.isArray(d.resources))
+            cur.resources = d.resources;
+        else if (typeof d.resourceRef === 'string' && !cur.resources)
+            cur.resources = [d.resourceRef];
+        if (Array.isArray(d.assets))
+            cur.assets = d.assets;
+        if (Array.isArray(d.materialActual))
+            cur.material = d.materialActual;
+        extra.set(id, cur);
+    }
+    return records.map(rec => {
+        const x = extra.get(rec.taskId) ?? {};
+        const jobState = rec.completedMs !== undefined ? 'completed' : rec.startedMs !== undefined ? 'running' : 'ready';
+        const one = (ids) => ids?.length ? ids.map(id => ({ id, quantity: 1 })) : undefined;
+        return {
+            id: rec.taskId,
+            ...(rec.facets.order ? { jobOrderId: rec.facets.order } : {}),
+            ...(rec.facets.kind ? { workType: rec.facets.kind } : {}),
+            jobState,
+            ...(iso(rec.startedMs) ? { startTime: iso(rec.startedMs) } : {}),
+            ...(iso(rec.completedMs) ? { endTime: iso(rec.completedMs) } : {}),
+            ...(one(x.personnel) ? { personnelActual: one(x.personnel) } : {}),
+            ...(one(x.resources) ? { equipmentActual: one(x.resources) } : {}),
+            ...(one(x.assets) ? { physicalAssetActual: one(x.assets) } : {}),
+            ...(x.material?.length ? { materialActual: x.material.map(m => ({ ...m })) } : {})
+        };
+    });
+}

package/dist/kernel.d.ts

@@ -14,6 +14,11 @@ export declare class WmsKernel extends FlowEngine {
     protected onOrder(spec: GeneratorSpec): void;
     /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
     protected handleCommand(cmd: Command): CommandAck;
+    /**
+     * 오더 생성 — 약속(`promised`)이 있으면 **납기와 우선순위를 함께 싣는다**(표준 `EndTime`·`Priority`).
+     * 없으면 싣지 않는다: 없는 약속을 만들면 그 뒤 모든 지연 판정이 거짓 위에 선다.
+     */
+    /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
     private createSalesOrder;
     /**
      * created 오더를 정책으로 할당 → SO TransactionEvent(라인 통합) + pick task(라인별).

package/dist/kernel.js

@@ -21,11 +21,14 @@ export class WmsKernel extends FlowEngine {
     }
     /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
     onArrival(spec) {
-        const dock = this.nodeByType('dock');
+        const dock = this.locationByType('dock');
         if (!dock)
             return;
         const epc = ssccUri(COMPANY_PREFIX, ++this.epcSeq); // 팔레트 SSCC
         const gtin = this.pickGtin(spec.content.skuMix); // SGTIN idpat = epcClass
+        /* 품목 구성이 비어 있으면 **도착을 만들지 않는다** — 무엇이 왔는지 말할 수 없는 입고는 사실이 아니다. */
+        if (!gtin)
+            return;
         const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max); // 케이스 수(비직렬)
         const po = gdtiUri(COMPANY_PREFIX, '401', ++this.poSeq);
         const eventTime = this.now();
@@ -62,7 +65,10 @@ export class WmsKernel extends FlowEngine {
     onOrder(spec) {
         const lpl = spec.content.linesPerOrder;
         if (!lpl) {
-            this.createSalesOrder([{ gtin: this.pickGtin(spec.content.skuMix), qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) }]);
+            const only = this.pickGtin(spec.content.skuMix);
+            if (!only)
+                return; // 품목 구성이 없으면 오더도 없다(무엇을 달라는 오더인지 말할 수 없다)
+            this.createSalesOrder([{ gtin: only, qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) }], spec);
             return;
         }
         const n = Math.min(this.randInt(lpl.min, lpl.max), spec.content.skuMix.length);
@@ -70,10 +76,14 @@ export class WmsKernel extends FlowEngine {
         let pool = spec.content.skuMix;
         for (let i = 0; i < n && pool.length > 0; i++) {
             const gtin = this.pickGtin(pool);
+            if (!gtin)
+                break;
             lines.push({ gtin, qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) });
             pool = pool.filter(m => m.gtin !== gtin); // 라인 SKU 중복 방지(distinct)
         }
-        this.createSalesOrder(lines);
+        if (!lines.length)
+            return; // 라인이 하나도 안 나오면 오더를 만들지 않는다
+        this.createSalesOrder(lines, spec);
     }
     /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
     handleCommand(cmd) {
@@ -87,13 +97,19 @@ export class WmsKernel extends FlowEngine {
         }
         return super.handleCommand(cmd);
     }
-    createSalesOrder(lines) {
+    /**
+     * 오더 생성 — 약속(`promised`)이 있으면 **납기와 우선순위를 함께 싣는다**(표준 `EndTime`·`Priority`).
+     * 없으면 싣지 않는다: 없는 약속을 만들면 그 뒤 모든 지연 판정이 거짓 위에 선다.
+     */
+    /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
+    createSalesOrder(lines, spec) {
         const id = `order-${++this.orderSeq}`;
         const so = gdtiUri(COMPANY_PREFIX, '402', ++this.soSeq);
         const requested = lines.reduce((s, l) => s + l.qty, 0);
         const order = {
             id, kind: 'outbound', status: 'created', requested, fulfilled: 0, bizTransaction: so,
-            allocated: [], picked: [], shipmentEpc: null, lines: lines.map(l => ({ gtin: l.gtin, requested: l.qty }))
+            allocated: [], picked: [], shipmentEpc: null, lines: lines.map(l => ({ gtin: l.gtin, requested: l.qty })),
+            ...(spec ? this.promiseOf(spec) : {})
         };
         this.orders.set(id, order);
         this.emitOrder(order);
@@ -104,7 +120,7 @@ export class WmsKernel extends FlowEngine {
      * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
      */
     allocate(o) {
-        const staging = this.nodeByType('staging');
+        const staging = this.locationByType('staging');
         if (!staging || !o.lines)
             return;
         const chosenAll = [];
@@ -114,7 +130,7 @@ export class WmsKernel extends FlowEngine {
             if (need <= 0)
                 continue;
             const available = [...this.items.values()]
-                .filter(i => i.gtin === line.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === 'storage')
+                .filter(i => i.gtin === line.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'storage')
                 .map(i => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
             const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
             for (const epc of chosen) {
@@ -140,9 +156,13 @@ export class WmsKernel extends FlowEngine {
     }
     /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
     onTaskComplete(t) {
-        const item = this.items.get(t.itemEpc);
-        const from = this.nodes.get(t.fromNode);
-        const to = this.nodes.get(t.toNode);
+        const item = this.itemByRef(t.itemEpc);
+        /* 여기 도달했다면 코어가 이미 물품을 확인했다(주체가 사라진 작업은 완료 전에 접힌다).
+           그래도 단정(`!`)은 쓰지 않는다 — 계약이 바뀌면 조용히 틀리는 대신 분명히 멈춘다. */
+        if (!item)
+            throw new Error(`task ${t.id}: item "${t.itemEpc}" vanished between the core check and the domain hook`);
+        const from = this.locations.get(t.fromNode);
+        const to = this.locations.get(t.toNode);
         from.occupancy--;
         to.occupancy++;
         item.location = to.id;
@@ -163,7 +183,7 @@ export class WmsKernel extends FlowEngine {
     }
     /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
     finalizeOrder(order, staging) {
-        const shipDock = this.nodeByType('dock-ship') ?? staging;
+        const shipDock = this.locationByType('dock-ship') ?? staging;
         const eventTime = this.now();
         const shipment = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
         order.shipmentEpc = shipment;

package/dist/mes-kernel.d.ts

@@ -36,6 +36,19 @@ export declare class MesKernel extends FlowEngine {
     /** 정의-구동 모드(선택). 미지정 시 레거시 하드코딩 경로 — byte-identical. */
     private mesSpec?;
     constructor(tenantId: string, policy?: AllocationPolicy, mesSpec?: MesDefinitionSpec);
+    /**
+     * **산출을 두 곳에서 만들지 않는다** — 기동 때 막는다.
+     *
+     * MES 는 레시피로 산출을 만든다: WIP 사슬(스텝마다 앞의 WIP 을 먹고 다음 WIP 을 낸다) · **직렬번호**
+     * (회사 프리픽스 + 일련번호) · **수율**(양품/불량이 처분을 가른다) · 생산오더 연결. 코어의 일반
+     * 자재 명세(`use: 'produced'`)는 **비직렬 클래스+수량**이라 그 넷을 표현하지 못한다.
+     *
+     * 그래서 MES 를 일반 선언으로 옮기지 않는다 — 옮기면 정체성·수율·오더 연결을 **잃는다**(§4-20).
+     * 대신 둘이 겹치면 **같은 산출을 두 번 만들게** 되므로, 그 조합을 기동 시점에 거부한다.
+     * 런타임에 조용히 두 배가 되는 것보다 기동이 실패하는 편이 낫다(재고가 거짓이 되면 그 위의
+     * 모든 계산이 거짓이 된다).
+     */
+    private assertNoDoubleProduction;
     private productOf;
     /**
      * MES 도메인 커맨드(Tier 2) — mes.changeover: 설비를 제품 gtin 으로 강제 전환.
@@ -53,11 +66,26 @@ export declare class MesKernel extends FlowEngine {
     /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(process), 이종 자원, 제품 전환 셋업. */
     private emitStation;
     /** op 완료 = 변환. 라우트 인덱스로 분기: 첫=BOM 소비→WIP, 중간=WIP→WIP, 마지막(조립)=WIP→완성차(수율→OEE 품질). */
+    /**
+     * MES 는 완료 시점에 **오더와 제품 정의**를 딛고 선다 — 둘 중 하나만 없어도 끝맺을 수 없다.
+     *
+     * 씨앗이 이미 이행된 오더를 심지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
+     * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 던졌고 **그 예외
+     * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
+     */
+    protected canComplete(t: FlowTask): boolean;
     protected onTaskComplete(t: FlowTask): void;
     private recipeDef;
     /** 자재 키 → 구체 gtin 클래스(idpat). 구체 식별은 바인딩+prefix 로 인스턴스가 주입. */
     private classOf;
     private serialOf;
+    /**
+     * 라우트를 용량 계산에 알려 준다 — 수율을 거슬러 올릴 때 순서가 곧 계산이다.
+     *
+     * 순서를 모르면 선언 순서대로 세는데, 그러면 하류에서 잃는 몫이 엉뚱한 공정에 얹힌다(조용히
+     * 틀린다). 생산 정의를 가진 커널만 이 답을 안다.
+     */
+    protected routeKeys(): string[] | undefined;
     /** recipe.route → 오퍼레이션 시퀀스 해소. */
     private routeOps;
     /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 raw-store 에 생성. */

package/dist/mes-kernel.js

@@ -6,7 +6,7 @@
  *  ① BOM = 제품별 다품목 레시피(P1=2A+1B / P2=1A+2B — 상이 → 체인지오버 유발).
  *  ② 수율 = 일부 불량(non_sellable) → OEE Quality.
  *  ③ 셋업/체인지오버 = work-center 가 제품 전환 시 셋업(changeoverKey=제품 gtin) → OEE Availability.
- *  ④ OEE = base 가 무버(설비)별 계측(가동/셋업/기아/품질). cut=cutter·weld=welder 이종 자원.
+ *  ④ OEE = base 가 설비(설비)별 계측(가동/셋업/기아/품질). cut=cutter·weld=welder 이종 자원.
  */
 import { firstFitPolicy } from "./allocation-policy.js";
 import { FlowEngine } from "./flow-engine.js";
@@ -44,10 +44,10 @@ export const MES_PRODUCTS = PRODUCTS.map(p => ({ gtin: p.gtin, label: p.key }));
  * 각 스테이션 = 이종 자원(resource) + 제품 전환 시 체인지오버 셋업.
  */
 const ROUTE = [
-    { kind: 'cut', node: 'cut-station', resource: 'cutter' },
-    { kind: 'weld', node: 'weld-station', resource: 'welder' },
-    { kind: 'paint', node: 'paint-booth', resource: 'painter' },
-    { kind: 'assembly', node: 'assembly-line', resource: 'assembler' }
+    { kind: 'cut', locationType: 'cut-station', resource: 'cutter' },
+    { kind: 'weld', locationType: 'weld-station', resource: 'welder' },
+    { kind: 'paint', locationType: 'paint-booth', resource: 'painter' },
+    { kind: 'assembly', locationType: 'assembly-line', resource: 'assembler' }
 ];
 export class MesKernel extends FlowEngine {
     wipSeq = 0;
@@ -58,8 +58,29 @@ export class MesKernel extends FlowEngine {
         super(tenantId, policy);
         this.mesSpec = mesSpec;
         /* 정의가 있으면 그 안의 오퍼레이션 명세(소요·변동·모수)를 커널이 소비한다 — 없으면 기본값 경로. */
-        if (mesSpec?.definition?.operations)
+        if (mesSpec?.definition?.operations) {
             this.loadOperations(mesSpec.definition.operations);
+            this.assertNoDoubleProduction(mesSpec.definition.operations);
+        }
+    }
+    /**
+     * **산출을 두 곳에서 만들지 않는다** — 기동 때 막는다.
+     *
+     * MES 는 레시피로 산출을 만든다: WIP 사슬(스텝마다 앞의 WIP 을 먹고 다음 WIP 을 낸다) · **직렬번호**
+     * (회사 프리픽스 + 일련번호) · **수율**(양품/불량이 처분을 가른다) · 생산오더 연결. 코어의 일반
+     * 자재 명세(`use: 'produced'`)는 **비직렬 클래스+수량**이라 그 넷을 표현하지 못한다.
+     *
+     * 그래서 MES 를 일반 선언으로 옮기지 않는다 — 옮기면 정체성·수율·오더 연결을 **잃는다**(§4-20).
+     * 대신 둘이 겹치면 **같은 산출을 두 번 만들게** 되므로, 그 조합을 기동 시점에 거부한다.
+     * 런타임에 조용히 두 배가 되는 것보다 기동이 실패하는 편이 낫다(재고가 거짓이 되면 그 위의
+     * 모든 계산이 거짓이 된다).
+     */
+    assertNoDoubleProduction(ops) {
+        const bad = ops.filter(o => (o.materialSpecification ?? []).some(m => m.use === 'produced')).map(o => o.key);
+        if (!bad.length)
+            return;
+        throw new Error(`MES recipe already produces outputs — operations [${bad.join(', ')}] must not also declare materialSpecification use:'produced' ` +
+            '(that would create the same output twice). Consumption specs are fine; declare production in the recipe.');
     }
     productOf(gtin) { return PRODUCTS.find(p => p.gtin === gtin); }
     /**
@@ -73,7 +94,7 @@ export class MesKernel extends FlowEngine {
             const a = cmd.args;
             if (!a?.resourceId || !a?.gtin)
                 return { commandId: cmd.commandId, accepted: false, errorCode: 'changeover-needs-args', error: 'mes.changeover: resourceId and gtin required' };
-            const m = this.movers.get(a.resourceId);
+            const m = this.equipment.get(a.resourceId);
             if (!m)
                 return { commandId: cmd.commandId, accepted: false, errorCode: 'resource-not-found', errorParams: { resourceId: a.resourceId }, error: `resource-not-found: ${a.resourceId}` };
             if (m.lastChangeoverKey !== a.gtin) {
@@ -81,7 +102,7 @@ export class MesKernel extends FlowEngine {
                  * 오퍼레이션별 셋업 명세는 작업 생성 경로(emitStation*)가 소비한다. */
                 m.setupMs += DEFAULT_SETUP_MS; // 셋업 = OEE 가용성 손실
                 m.lastChangeoverKey = a.gtin;
-                this.emitMover(m);
+                this.emitEquipment(m);
             }
             return { commandId: cmd.commandId, accepted: true };
         }
@@ -91,7 +112,7 @@ export class MesKernel extends FlowEngine {
     onArrival(spec) {
         if (this.mesSpec)
             return this.onArrivalDef(spec);
-        const rawStore = this.nodeByType('raw-store');
+        const rawStore = this.locationByType('raw-store');
         if (!rawStore)
             return;
         const gtin = this.pickGtin(spec.content.skuMix);
@@ -110,7 +131,7 @@ export class MesKernel extends FlowEngine {
         const product = PRODUCTS[this.orderSeq % PRODUCTS.length];
         const id = `order-${++this.orderSeq}`;
         const wo = gdtiUri(CP, '403', ++this.soSeq);
-        const order = { id, kind: 'workorder', status: 'created', gtin: product.gtin, requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [] };
+        const order = { id, kind: 'workorder', status: 'created', gtin: product.gtin, requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [], ...this.promiseOf(_spec) };
         this.orders.set(id, order);
         this.emitOrder(order);
     }
@@ -119,7 +140,7 @@ export class MesKernel extends FlowEngine {
         if (this.mesSpec)
             return this.allocateDef(o);
         const s0 = ROUTE[0];
-        const first = this.nodeByType(s0.node);
+        const first = this.locationByType(s0.locationType);
         const product = this.productOf(o.gtin);
         if (!first || !product)
             return;
@@ -127,7 +148,7 @@ export class MesKernel extends FlowEngine {
         const picks = [];
         for (const line of product.bom) {
             const available = [...this.items.values()]
-                .filter(i => i.gtin === line.part.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === 'raw-store')
+                .filter(i => i.gtin === line.part.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'raw-store')
                 .map(i => ({ epc: i.epc, location: i.location, qty: 1 }));
             const chosen = this.policy.selectStock({ gtin: line.part.gtin, qty: line.qty, available });
             if (chosen.length < line.qty)
@@ -144,25 +165,41 @@ export class MesKernel extends FlowEngine {
     }
     /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(process), 이종 자원, 제품 전환 셋업. */
     emitStation(o, stage, itemEpc, changeoverKey) {
-        const node = this.nodeByType(stage.node);
-        const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: 'created', itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: node.id, toNode: node.id, resourceKind: stage.resource }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: this.paramDuration(stage.kind, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: 'process' };
+        const loc = this.locationByType(stage.locationType);
+        const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: 'created', itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: loc.id, toNode: loc.id, resourceKind: stage.resource }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: this.paramDuration(stage.kind, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: 'process' };
         this.tasks.set(task.id, task);
         this.emitTask(task);
     }
     /** op 완료 = 변환. 라우트 인덱스로 분기: 첫=BOM 소비→WIP, 중간=WIP→WIP, 마지막(조립)=WIP→완성차(수율→OEE 품질). */
+    /**
+     * MES 는 완료 시점에 **오더와 제품 정의**를 딛고 선다 — 둘 중 하나만 없어도 끝맺을 수 없다.
+     *
+     * 씨앗이 이미 이행된 오더를 심지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
+     * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 던졌고 **그 예외
+     * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
+     */
+    canComplete(t) {
+        if (this.mesSpec)
+            return !!(t.orderId && this.orders.get(t.orderId));
+        const order = t.orderId ? this.orders.get(t.orderId) : undefined;
+        return !!order && !!this.productOf(order.gtin);
+    }
     onTaskComplete(t) {
         if (this.mesSpec)
             return this.onTaskCompleteDef(t);
+        /* 여기 도달했다면 `canComplete` 가 이미 확인했다 — 그래도 단정(`!`)은 쓰지 않는다. */
         const order = this.orders.get(t.orderId);
-        const product = this.productOf(order.gtin);
+        const product = order && this.productOf(order.gtin);
+        if (!order || !product)
+            throw new Error(`task ${t.id}: order/product vanished between the core check and the domain hook`);
         const i = ROUTE.findIndex(s => s.kind === t.kind);
-        const node = this.nodes.get(t.toNode);
+        const loc = this.locations.get(t.toNode);
         const isLast = i === ROUTE.length - 1;
         if (!isLast) {
             // 중간 스테이션 — 입력(첫=BOM 전부 / 이후=이전 WIP) → 다음 WIP, 다음 스테이션 태스크.
             const inputs = order.allocated.slice();
             const wip = sgtinUri(CP, WIP_ITEMREF, ++this.wipSeq);
-            this.transform(inputs, [{ epc: wip, gtin: WIP_GTIN, qty: 1, location: node.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+            this.transform(inputs, [{ epc: wip, gtin: WIP_GTIN, qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
             order.allocated = [wip];
             const next = ROUTE[i + 1];
             this.emitStation(order, next, wip, product.gtin);
@@ -171,13 +208,13 @@ export class MesKernel extends FlowEngine {
             return;
         }
         // 마지막 스테이션(조립) → 완성차 (transform 1→1, disposition 으로 수율 loss → OEE 품질)
-        const fgStore = this.nodeByType('fg-store');
+        const fgStore = this.locationByType('fg-store');
         const wip = order.allocated[0];
         const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
         this.recordOutput(t.resource, good); // OEE 품질(마지막 자원별 양품/불량)
         const disp = good ? DISP.sellable : DISP.non_sellable;
         const outputEpc = sgtinUri(CP, product.ref, ++this.prodSeq);
-        this.transform([wip], [{ epc: outputEpc, gtin: product.gtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep: MES_BIZSTEP.producing, disposition: disp, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+        this.transform([wip], [{ epc: outputEpc, gtin: product.gtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep: MES_BIZSTEP.producing, disposition: disp, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
         this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: MES_BIZSTEP.storing, disposition: disp, epcList: [outputEpc], quantityList: [{ epcClass: product.gtin, quantity: 1 }], readPoint: fgStore.id, bizLocation: fgStore.id }));
         order.allocated = [];
         order.fulfilled = 1;
@@ -196,6 +233,18 @@ export class MesKernel extends FlowEngine {
     serialOf(materialKey, serial) {
         return sgtinUri(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey], serial);
     }
+    /**
+     * 라우트를 용량 계산에 알려 준다 — 수율을 거슬러 올릴 때 순서가 곧 계산이다.
+     *
+     * 순서를 모르면 선언 순서대로 세는데, 그러면 하류에서 잃는 몫이 엉뚱한 공정에 얹힌다(조용히
+     * 틀린다). 생산 정의를 가진 커널만 이 답을 안다.
+     */
+    routeKeys() {
+        if (!this.mesSpec)
+            return undefined;
+        const d = this.mesSpec.definition;
+        return d.routes?.find(r => r.key === this.recipeDef().route)?.steps;
+    }
     /** recipe.route → 오퍼레이션 시퀀스 해소. */
     routeOps() {
         const d = this.mesSpec.definition;
@@ -204,10 +253,13 @@ export class MesKernel extends FlowEngine {
     }
     /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 raw-store 에 생성. */
     onArrivalDef(spec) {
-        const rawStore = this.nodeByType('raw-store');
+        const rawStore = this.locationByType('raw-store');
         if (!rawStore)
             return;
         const gtin = this.pickGtin(spec.content.skuMix);
+        /* 품목 구성이 비어 있으면 도착을 만들지 않는다 — 무엇이 왔는지 말할 수 없는 입고는 사실이 아니다. */
+        if (!gtin)
+            return;
         const inputKey = this.recipeDef().inputs.map(i => i.material).find(k => this.classOf(k) === gtin);
         if (!inputKey)
             return;
@@ -221,21 +273,21 @@ export class MesKernel extends FlowEngine {
         const rc = this.recipeDef();
         const id = `order-${++this.orderSeq}`;
         const wo = gdtiUri(this.mesSpec.companyPrefix, '403', ++this.soSeq);
-        const order = { id, kind: 'workorder', status: 'created', gtin: this.classOf(rc.outputs[0].material), requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [] };
+        const order = { id, kind: 'workorder', status: 'created', gtin: this.classOf(rc.outputs[0].material), requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [], ...this.promiseOf(_spec) };
         this.orders.set(id, order);
         this.emitOrder(order);
     }
     /** 정의 모드 할당 — 레시피 입력 BOM 전량 확보 후 첫 라우트 스텝 태스크. */
     allocateDef(o) {
         const ops = this.routeOps();
-        if (!ops.length || !ops[0].nodeType || !this.nodeByType(ops[0].nodeType))
+        if (!ops.length || !ops[0].locationType || !this.locationByType(ops[0].locationType))
             return;
         const rc = this.recipeDef();
         const picks = [];
         for (const line of rc.inputs) {
             const g = this.classOf(line.material);
             const available = [...this.items.values()]
-                .filter(i => i.gtin === g && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === 'raw-store')
+                .filter(i => i.gtin === g && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === 'raw-store')
                 .map(i => ({ epc: i.epc, location: i.location, qty: 1 }));
             const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
             if (chosen.length < line.qty)
@@ -251,25 +303,27 @@ export class MesKernel extends FlowEngine {
         this.emitOrder(o);
     }
     emitStationDef(o, op, itemEpc) {
-        const node = this.nodeByType(op.nodeType);
-        const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: 'created', itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: node.id, toNode: node.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
+        const loc = this.locationByType(op.locationType);
+        const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: 'created', itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
         this.tasks.set(task.id, task);
         this.emitTask(task);
     }
     /** 정의 모드 완료 — 라우트 인덱스: 중간=WIP 변환+다음 스텝, 마지막=완제품(수율). */
     onTaskCompleteDef(t) {
         const order = this.orders.get(t.orderId);
+        if (!order)
+            throw new Error(`task ${t.id}: order vanished between the core check and the domain hook`);
         const rc = this.recipeDef();
         const ops = this.routeOps();
         const i = ops.findIndex(s => s.key === t.kind);
-        const node = this.nodes.get(t.toNode);
+        const loc = this.locations.get(t.toNode);
         const bizStep = ops[i]?.bizStep ?? MES_BIZSTEP.producing;
         const isLast = i === ops.length - 1;
         if (!isLast) {
             const inputs = order.allocated.slice();
             const wip = sgtinUri(this.mesSpec.companyPrefix, 'WIP', ++this.wipSeq);
             const wipGtin = sgtinClass(this.mesSpec.companyPrefix, 'WIP');
-            this.transform(inputs, [{ epc: wip, gtin: wipGtin, qty: 1, location: node.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+            this.transform(inputs, [{ epc: wip, gtin: wipGtin, qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
             order.allocated = [wip];
             const next = ops[i + 1];
             this.emitStationDef(order, next, wip);
@@ -277,14 +331,14 @@ export class MesKernel extends FlowEngine {
             this.emitOrder(order);
             return;
         }
-        const fgStore = this.nodeByType('fg-store');
+        const fgStore = this.locationByType('fg-store');
         const wip = order.allocated[0];
         const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
         this.recordOutput(t.resource, good);
         const disp = good ? DISP.sellable : DISP.non_sellable;
         const outEpc = this.serialOf(rc.outputs[0].material, ++this.prodSeq);
         const outGtin = this.classOf(rc.outputs[0].material);
-        this.transform([wip], [{ epc: outEpc, gtin: outGtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep, disposition: disp, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+        this.transform([wip], [{ epc: outEpc, gtin: outGtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep, disposition: disp, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
         this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: MES_BIZSTEP.storing, disposition: disp, epcList: [outEpc], quantityList: [{ epcClass: outGtin, quantity: 1 }], readPoint: fgStore.id, bizLocation: fgStore.id }));
         order.allocated = [];
         order.fulfilled = 1;

package/dist/mes-profile.d.ts

@@ -8,7 +8,7 @@ export declare const MES_BIZSTEP: {
 export declare const BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
 /** 직렬 SGTIN URI (원자재 단위·완제품). */
 export declare function sgtinUri(companyPrefix: string, itemRef: string, serial: number): string;
-/** MES 노드 타입 카탈로그 — 커널이 키로 쓰는 제조 로케이션 타입(nodeByType/.type). 도메인 SSOT.
+/** MES 자리 타입 카탈로그 — 커널이 키로 쓰는 제조 로케이션 타입(locationByType/.type). 도메인 SSOT.
  * 트레일러 제조 라인: 자재→프레임 절단→용접→도장→조립→완성차(kernel ROUTE 와 일치). */
-export declare const MES_NODE_TYPES: readonly ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
+export declare const MES_LOCATION_TYPES: readonly ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
 export declare const MES_TYPES: TwinTypeInfo[];