@operato/twin-kernel 0.0.1

package/dist/forecast.js

@@ -0,0 +1,34 @@
+/*
+ * Probabilistic Forecast — 몬테카를로 예측 (단일 결정값 → 분포).
+ *
+ * 예측은 본질적으로 불확실하다. 현재 상태를 fork 하고 seed 를 달리해(확률적 미래) N회 굴려,
+ * 관심 지표를 분포로 준다: "언제 끝나?"가 아니라 "P50/P90 완료시각·재고소진 확률".
+ * fork(현재예측) + 시나리오 재시드로 미래만 변주 — 현재 상태(재고·오더·태스크)는 보존.
+ */
+/**
+ * 현재 상태에서 N개 확률적 미래를 표본화 → 지표 분포.
+ * run 마다 fork(현재 보존) + scenario.load(seed+i)(미래 변주) + horizon 까지 구동. 원본 무간섭.
+ */
+export function monteCarloForecast(twin, opts) {
+    const now = twin.getSnapshot().simClockMs;
+    const step = opts.tickMs ?? 1000;
+    const baseSeed = opts.scenario.seed ?? 1;
+    const samples = [];
+    for (let i = 0; i < opts.runs; i++) {
+        const fc = twin.fork();
+        fc.scenario.load({ ...opts.scenario, seed: baseSeed + i }); // 미래만 변주(현재 상태는 fork 로 보존)
+        fc.scenario.start();
+        const target = now + opts.horizonMs;
+        let guard = 0;
+        while (fc.getSnapshot().simClockMs < target && guard++ < 1_000_000)
+            fc.tick(step);
+        samples.push(opts.metric(fc.getSnapshot()));
+    }
+    return summarize(opts.runs, samples);
+}
+function summarize(runs, samples) {
+    const sorted = [...samples].sort((a, b) => a - b);
+    const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
+    const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
+    return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './contract.ts';
+export * from './counterfactual.ts';
+export * from './forecast.ts';
+export * from './twin-observer.ts';
+export * from './event-journal.ts';
+export * from './divergence.ts';
+export * from './epcis.ts';
+export * from './wms-profile.ts';
+export * from './allocation-policy.ts';
+export * from './duration-estimator.ts';
+export * from './state-projector.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 { WmsKernel } from './kernel.ts';
+export { YmsKernel } from './yms-kernel.ts';
+export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS } from './mes-kernel.ts';

package/dist/index.js

@@ -0,0 +1,19 @@
+export * from "./contract.js";
+export * from "./counterfactual.js";
+export * from "./forecast.js";
+export * from "./twin-observer.js";
+export * from "./event-journal.js";
+export * from "./divergence.js";
+export * from "./epcis.js";
+export * from "./wms-profile.js";
+export * from "./allocation-policy.js";
+export * from "./duration-estimator.js";
+export * from "./state-projector.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 { WmsKernel } from "./kernel.js";
+export { YmsKernel } from "./yms-kernel.js";
+export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS } from "./mes-kernel.js";

package/dist/kernel.d.ts

@@ -0,0 +1,28 @@
+import type { Command, CommandAck, GeneratorSpec } from './contract.ts';
+import type { AllocationPolicy } from './allocation-policy.ts';
+import { FlowEngine } from './flow-engine.ts';
+import type { FlowOrder, FlowTask } from './flow-engine.ts';
+export declare class WmsKernel extends FlowEngine {
+    private poSeq;
+    constructor(tenantId: string, policy?: AllocationPolicy);
+    /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
+    protected onArrival(spec: GeneratorSpec): void;
+    /**
+     * SO 오더 자극(생성기) → 오더 생성. `linesPerOrder` 지정 시 멀티SKU(라인별 distinct gtin),
+     * 미지정 시 단일 SKU(기존 경로 — rng 소비 순서 보존 = pickGtin → randInt).
+     */
+    protected onOrder(spec: GeneratorSpec): void;
+    /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
+    protected handleCommand(cmd: Command): CommandAck;
+    private createSalesOrder;
+    /**
+     * created 오더를 정책으로 할당 → SO TransactionEvent(라인 통합) + pick task(라인별).
+     * 라인마다 selectStock(정책) → firstFit=라인 전량확보 대기 / partialFit=가용분 백오더.
+     * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
+     */
+    protected allocate(o: FlowOrder): void;
+    /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
+    protected onTaskComplete(t: FlowTask): void;
+    /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
+    private finalizeOrder;
+}

package/dist/kernel.js

@@ -0,0 +1,187 @@
+/*
+ * WMS Kernel — 입출고 flow 동사(도메인). mechanics 는 FlowEngine base 재사용.
+ * 결정적 · 프레임워크 무관 · 퍼시스턴스 무관.
+ *
+ * 입고: 도착 → receiving(Txn PO + Agg 팔레트←케이스 + Object) → putaway → storing.
+ * 출고: SO 오더 → 할당(Txn SO) → pick(bin→staging) → picking → packing(Agg 화물←팔레트) → staging → shipping(DELETE).
+ */
+import { CMD } from "./contract.js";
+import { firstFitPolicy } from "./allocation-policy.js";
+import { FlowEngine } from "./flow-engine.js";
+import { BIZSTEP, BTT } from "./wms-profile.js";
+import { DISP, aggregationEvent, gdtiUri, objectEvent, ssccUri, transactionEvent } from "./epcis.js";
+const TRAVEL_MS = 30_000;
+const COMPANY_PREFIX = '0614141';
+const SHELF_MS = 30 * 24 * 3_600_000; // 기본 유통기한(30일)
+const SHELF_JITTER_MS = 5 * 24 * 3_600_000; // 로트별 만료 편차(FEFO 가 FIFO 와 갈리게)
+export class WmsKernel extends FlowEngine {
+    poSeq = 0;
+    constructor(tenantId, policy = firstFitPolicy) {
+        super(tenantId, policy);
+    }
+    /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
+    onArrival(spec) {
+        const dock = this.nodeByType('dock');
+        if (!dock)
+            return;
+        const epc = ssccUri(COMPANY_PREFIX, ++this.epcSeq); // 팔레트 SSCC
+        const gtin = this.pickGtin(spec.content.skuMix); // SGTIN idpat = epcClass
+        const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max); // 케이스 수(비직렬)
+        const po = gdtiUri(COMPANY_PREFIX, '401', ++this.poSeq);
+        const eventTime = this.now();
+        const qtyList = [{ epcClass: gtin, quantity: qty }];
+        const poTxn = [{ type: BTT.po, bizTransaction: po }];
+        // 로트 만료(FEFO 용, 결정적 — rng 무소비로 byte-identical 유지). 편차로 도착순≠만료순 → FEFO 가 유의미.
+        const expiry = this.clockMs + SHELF_MS - (this.epcSeq % 5) * SHELF_JITTER_MS;
+        this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry });
+        dock.occupancy++;
+        this.emit(transactionEvent({ eventTime, action: 'ADD', bizStep: BIZSTEP.receiving, bizTransactionList: poTxn, epcList: [epc], quantityList: qtyList, readPoint: dock.id }));
+        this.emit(aggregationEvent({ eventTime, action: 'ADD', bizStep: BIZSTEP.receiving, parentID: epc, childQuantityList: qtyList, readPoint: dock.id }));
+        this.emit(objectEvent({ eventTime, action: 'ADD', bizStep: BIZSTEP.receiving, disposition: DISP.in_progress, epcList: [epc], quantityList: qtyList, readPoint: dock.id, bizLocation: dock.id, bizTransactionList: poTxn }));
+        const binId = this.policy.selectPlacement({ item: { epc, gtin, qty }, slots: this.slotViews('storage') });
+        if (!binId)
+            return; // 수용 불가 → 도크 대기
+        const id = `task-${++this.taskSeq}`;
+        const task = { id, kind: 'putaway', status: 'created', itemEpc: epc, fromNode: dock.id, toNode: binId, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'putaway', fromNode: dock.id, toNode: binId }, TRAVEL_MS) };
+        this.tasks.set(id, task);
+        this.emitTask(task);
+    }
+    /**
+     * SO 오더 자극(생성기) → 오더 생성. `linesPerOrder` 지정 시 멀티SKU(라인별 distinct gtin),
+     * 미지정 시 단일 SKU(기존 경로 — rng 소비 순서 보존 = pickGtin → randInt).
+     */
+    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) }]);
+            return;
+        }
+        const n = Math.min(this.randInt(lpl.min, lpl.max), spec.content.skuMix.length);
+        const lines = [];
+        let pool = spec.content.skuMix;
+        for (let i = 0; i < n && pool.length > 0; i++) {
+            const gtin = this.pickGtin(pool);
+            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);
+    }
+    /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
+    handleCommand(cmd) {
+        if (cmd.type === CMD.orderRelease) {
+            const a = cmd.args;
+            const lines = a?.lines ?? (a?.gtin ? [{ gtin: a.gtin, qty: a.qty ?? 1 }] : []);
+            if (lines.length === 0)
+                return { commandId: cmd.commandId, accepted: false, error: 'order.release: gtin 또는 lines 필요' };
+            this.createSalesOrder(lines);
+            return { commandId: cmd.commandId, accepted: true };
+        }
+        return super.handleCommand(cmd);
+    }
+    createSalesOrder(lines) {
+        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 }))
+        };
+        this.orders.set(id, order);
+        this.emitOrder(order);
+    }
+    /**
+     * created 오더를 정책으로 할당 → SO TransactionEvent(라인 통합) + pick task(라인별).
+     * 라인마다 selectStock(정책) → firstFit=라인 전량확보 대기 / partialFit=가용분 백오더.
+     * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
+     */
+    allocate(o) {
+        const staging = this.nodeByType('staging');
+        if (!staging || !o.lines)
+            return;
+        const chosenAll = [];
+        for (const line of o.lines) {
+            const already = o.allocated.filter(e => this.items.get(e)?.gtin === line.gtin).length;
+            const need = line.requested - already;
+            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')
+                .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) {
+                this.items.get(epc).disposition = DISP.reserved;
+                o.allocated.push(epc);
+                chosenAll.push(epc);
+            }
+        }
+        if (chosenAll.length === 0)
+            return;
+        this.emit(transactionEvent({ eventTime: this.now(), action: 'ADD', bizStep: BIZSTEP.picking, bizTransactionList: [{ type: BTT.so, bizTransaction: o.bizTransaction }], epcList: chosenAll.slice() }));
+        for (const epc of chosenAll) {
+            const it = this.items.get(epc);
+            const id = `task-${++this.taskSeq}`;
+            const task = { id, kind: 'pick', status: 'created', itemEpc: epc, fromNode: it.location, toNode: staging.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'pick', fromNode: it.location, toNode: staging.id }, TRAVEL_MS), orderId: o.id };
+            this.tasks.set(id, task);
+            this.emitTask(task);
+        }
+        o.status = 'picking';
+        this.emitOrder(o);
+    }
+    /** 태스크 완료 — 이동 반영 후 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);
+        from.occupancy--;
+        to.occupancy++;
+        item.location = to.id;
+        if (t.kind === 'putaway') {
+            item.disposition = DISP.sellable;
+            this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: BIZSTEP.storing, disposition: DISP.sellable, epcList: [item.epc], quantityList: [{ epcClass: item.gtin, quantity: item.qty }], readPoint: to.id, bizLocation: to.id }));
+            return;
+        }
+        // pick
+        item.disposition = DISP.reserved;
+        this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: BIZSTEP.picking, disposition: DISP.reserved, epcList: [item.epc], quantityList: [{ epcClass: item.gtin, quantity: item.qty }], readPoint: to.id, bizLocation: to.id }));
+        const order = t.orderId ? this.orders.get(t.orderId) : undefined;
+        if (!order)
+            return;
+        order.picked.push(item.epc);
+        if (order.picked.length === order.allocated.length)
+            this.finalizeOrder(order, to);
+    }
+    /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
+    finalizeOrder(order, staging) {
+        const shipDock = this.nodeByType('dock-ship') ?? staging;
+        const eventTime = this.now();
+        const shipment = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
+        order.shipmentEpc = shipment;
+        const soTxn = [{ type: BTT.so, bizTransaction: order.bizTransaction }];
+        // 패킹: 화물(shipment) ← 팔레트 조립(merge). 팔레트는 출하 DELETE 까지 독립 유지 → consume 없음.
+        this.aggregate(shipment, order.picked.slice(), { bizStep: BIZSTEP.packing, readPoint: staging.id, bizLocation: staging.id });
+        order.status = 'packed';
+        this.emit(objectEvent({ eventTime, action: 'OBSERVE', bizStep: BIZSTEP.staging_outbound, disposition: DISP.reserved, epcList: [shipment], readPoint: staging.id, bizLocation: staging.id, bizTransactionList: soTxn }));
+        this.emit(objectEvent({ eventTime, action: 'DELETE', bizStep: BIZSTEP.shipping, disposition: DISP.in_transit, epcList: [shipment], readPoint: shipDock.id, bizTransactionList: soTxn }));
+        order.fulfilled += order.allocated.length;
+        // 라인 잔량 차감(멀티SKU 백오더) — 출하 팔레트의 gtin 으로 라인 매핑(라인 SKU distinct).
+        if (order.lines)
+            for (const epc of order.picked) {
+                const g = this.items.get(epc)?.gtin;
+                const line = order.lines.find(l => l.gtin === g && l.requested > 0);
+                if (line)
+                    line.requested--;
+            }
+        for (const epc of order.picked) {
+            this.items.delete(epc);
+            staging.occupancy--;
+        }
+        if (order.fulfilled >= order.requested)
+            order.status = 'shipped';
+        else {
+            order.allocated = [];
+            order.picked = [];
+            order.status = 'created';
+        } // 백오더 잔량 재할당
+        this.emitOrder(order);
+    }
+}

package/dist/mes-kernel.d.ts

@@ -0,0 +1,28 @@
+import type { GeneratorSpec } from './contract.ts';
+import type { AllocationPolicy } from './allocation-policy.ts';
+import { FlowEngine } from './flow-engine.ts';
+import type { FlowOrder, FlowTask } from './flow-engine.ts';
+/** 편의 — 시나리오 skuMix 로 쓸 부품 클래스. */
+export declare const MES_PART_GTINS: {
+    partA: string;
+    partB: string;
+};
+/** 편의 — 완제품 클래스(제품 2종). */
+export declare const MES_PRODUCT_GTINS: {
+    p1: string;
+    p2: string;
+};
+export declare class MesKernel extends FlowEngine {
+    private wipSeq;
+    private prodSeq;
+    constructor(tenantId: string, policy?: AllocationPolicy);
+    private productOf;
+    /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
+    protected onArrival(spec: GeneratorSpec): void;
+    /** 작업지시 — 제품 2종 교대(체인지오버 유발). 제품 gtin 을 오더에 기록. */
+    protected onOrder(_spec: GeneratorSpec): void;
+    /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + op1(cut, 체인지오버 셋업). */
+    protected allocate(o: FlowOrder): void;
+    /** op 완료 = 변환. cut: BOM 부품 소비 → WIP. weld: WIP → 완제품(수율: 양품/불량 → OEE 품질 보고). */
+    protected onTaskComplete(t: FlowTask): void;
+}

package/dist/mes-kernel.js

@@ -0,0 +1,126 @@
+/*
+ * MES Kernel — 제조: BOM 조립 + 다단계 라우팅(cut→weld) + 수율 + 셋업/체인지오버 + OEE. mechanics 는 FlowEngine base.
+ * 부품 수령(다품종) → 작업지시(제품 2종 교대) → BOM 예약 → op1 cut(BOM 소비→WIP) → op2 weld(→완제품, 수율) → 저장.
+ *
+ * 도메인 깊이:
+ *  ① BOM = 제품별 다품목 레시피(P1=2A+1B / P2=1A+2B — 상이 → 체인지오버 유발).
+ *  ② 수율 = 일부 불량(non_sellable) → OEE Quality.
+ *  ③ 셋업/체인지오버 = work-center 가 제품 전환 시 셋업(changeoverKey=제품 gtin) → OEE Availability.
+ *  ④ OEE = base 가 무버(설비)별 계측(가동/셋업/기아/품질). cut=cutter·weld=welder 이종 자원.
+ */
+import { firstFitPolicy } from "./allocation-policy.js";
+import { FlowEngine } from "./flow-engine.js";
+import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass } from "./epcis.js";
+import { MES_BIZSTEP, BTT_PRODORDER, sgtinUri } from "./mes-profile.js";
+const CYCLE_MS = 40_000;
+const SETUP_MS = 15_000; // 체인지오버(제품 전환) 셋업 — OEE 가용성 손실
+const CP = '0614141';
+const WIP_ITEMREF = '066666';
+const WIP_GTIN = sgtinClass(CP, WIP_ITEMREF);
+const YIELD = 0.8; // 양품률 — 나머지는 불량(non_sellable) → OEE 품질 손실
+// 부품(공용) — BOM 라인의 품목 클래스.
+const PART_A = { itemRef: '055551', gtin: sgtinClass(CP, '055551') };
+const PART_B = { itemRef: '055552', gtin: sgtinClass(CP, '055552') };
+// 제품 2종 — BOM 상이(제품 전환 시 cut/weld 체인지오버 셋업 발생).
+const PRODUCTS = [
+    { key: 'P1', ref: '077777', gtin: sgtinClass(CP, '077777'), bom: [{ part: PART_A, qty: 2 }, { part: PART_B, qty: 1 }] },
+    { key: 'P2', ref: '077778', gtin: sgtinClass(CP, '077778'), bom: [{ part: PART_A, qty: 1 }, { part: PART_B, qty: 2 }] }
+];
+/** 편의 — 시나리오 skuMix 로 쓸 부품 클래스. */
+export const MES_PART_GTINS = { partA: PART_A.gtin, partB: PART_B.gtin };
+/** 편의 — 완제품 클래스(제품 2종). */
+export const MES_PRODUCT_GTINS = { p1: PRODUCTS[0].gtin, p2: PRODUCTS[1].gtin };
+export class MesKernel extends FlowEngine {
+    wipSeq = 0;
+    prodSeq = 0;
+    constructor(tenantId, policy = firstFitPolicy) {
+        super(tenantId, policy);
+    }
+    productOf(gtin) { return PRODUCTS.find(p => p.gtin === gtin); }
+    /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
+    onArrival(spec) {
+        const rawStore = this.nodeByType('raw-store');
+        if (!rawStore)
+            return;
+        const gtin = this.pickGtin(spec.content.skuMix);
+        const part = [PART_A, PART_B].find(p => p.gtin === gtin);
+        if (!part)
+            return; // BOM 부품 아님
+        const epc = sgtinUri(CP, part.itemRef, ++this.epcSeq);
+        this.items.set(epc, { epc, gtin: part.gtin, qty: 1, location: rawStore.id, disposition: DISP.sellable });
+        rawStore.occupancy++;
+        this.emit(objectEvent({ eventTime: this.now(), action: 'ADD', bizStep: MES_BIZSTEP.receiving, disposition: DISP.sellable, epcList: [epc], quantityList: [{ epcClass: part.gtin, quantity: 1 }], readPoint: rawStore.id, bizLocation: rawStore.id }));
+    }
+    /** 작업지시 — 제품 2종 교대(체인지오버 유발). 제품 gtin 을 오더에 기록. */
+    onOrder(_spec) {
+        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: [] };
+        this.orders.set(id, order);
+        this.emitOrder(order);
+    }
+    /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + op1(cut, 체인지오버 셋업). */
+    allocate(o) {
+        const cut = this.nodeByType('cut-station');
+        const product = this.productOf(o.gtin);
+        if (!cut || !product)
+            return;
+        // BOM 전 라인 확보 확인(부족하면 아무것도 예약 안 하고 대기)
+        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')
+                .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)
+                return; // 부품 부족 → 대기
+            picks.push(...chosen);
+        }
+        for (const epc of picks) {
+            this.items.get(epc).disposition = DISP.reserved;
+            o.allocated.push(epc);
+        }
+        this.emit(transactionEvent({ eventTime: this.now(), action: 'ADD', bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
+        const task = { id: `task-${++this.taskSeq}`, kind: 'cut', status: 'created', itemEpc: o.allocated[0], fromNode: cut.id, toNode: cut.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'cut', fromNode: cut.id, toNode: cut.id, resourceKind: 'cutter' }, CYCLE_MS), orderId: o.id, resourceType: 'cutter', changeoverKey: product.gtin, setupMs: SETUP_MS, intent: 'process' };
+        this.tasks.set(task.id, task);
+        this.emitTask(task);
+        o.status = 'op-cut';
+        this.emitOrder(o);
+    }
+    /** op 완료 = 변환. cut: BOM 부품 소비 → WIP. weld: WIP → 완제품(수율: 양품/불량 → OEE 품질 보고). */
+    onTaskComplete(t) {
+        const order = this.orders.get(t.orderId);
+        const product = this.productOf(order.gtin);
+        const eventTime = this.now();
+        if (t.kind === 'cut') {
+            const cut = this.nodes.get(t.toNode);
+            const weld = this.nodeByType('weld-station');
+            const inputs = order.allocated.slice(); // BOM 부품 전부
+            const wip = sgtinUri(CP, WIP_ITEMREF, ++this.wipSeq);
+            // 변환(merge N→1 + product-change): BOM 부품 → WIP. base 원시가 소비·생산·계보 방출.
+            this.transform(inputs, [{ epc: wip, gtin: WIP_GTIN, qty: 1, location: cut.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: cut.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+            order.allocated = [wip];
+            const wtask = { id: `task-${++this.taskSeq}`, kind: 'weld', status: 'created', itemEpc: wip, fromNode: weld.id, toNode: weld.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'weld', fromNode: weld.id, toNode: weld.id, resourceKind: 'welder' }, CYCLE_MS), orderId: order.id, resourceType: 'welder', changeoverKey: product.gtin, setupMs: SETUP_MS, intent: 'process' };
+            this.tasks.set(wtask.id, wtask);
+            this.emitTask(wtask);
+            order.status = 'op-weld';
+            this.emitOrder(order);
+            return;
+        }
+        // weld → 완제품 (transform 1→1, disposition 으로 수율 loss 반영 → OEE 품질)
+        const weld = this.nodes.get(t.toNode);
+        const fgStore = this.nodeByType('fg-store');
+        const wip = order.allocated[0];
+        const good = this.rng() < YIELD;
+        this.recordOutput(t.resource, good); // OEE 품질(welder 자원별 양품/불량)
+        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: weld.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+        this.emit(objectEvent({ eventTime, 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;
+        order.status = good ? 'produced' : 'scrapped';
+        this.emitOrder(order);
+    }
+}

package/dist/mes-profile.d.ts

@@ -0,0 +1,9 @@
+export declare const MES_BIZSTEP: {
+    readonly receiving: "urn:epcglobal:cbv:bizstep:receiving";
+    readonly producing: "urn:epcglobal:cbv:bizstep:commissioning";
+    readonly storing: "urn:epcglobal:cbv:bizstep:storing";
+};
+/** 작업지시(Work Order) = 생산 오더 거래 유형. */
+export declare const BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
+/** 직렬 SGTIN URI (원자재 단위·완제품). */
+export declare function sgtinUri(companyPrefix: string, itemRef: string, serial: number): string;

package/dist/mes-profile.js

@@ -0,0 +1,17 @@
+/*
+ * MES Profile — 제조(manufacturing) 버티컬. 세 번째 프로파일 = base 를 "변환"으로 가장 강하게 stress.
+ * 재료 소비 → 제품 생산(이동 아님). EPCIS 2.0 TransformationEvent + epcis 빌더 재사용.
+ * (MES=ISA-95 앵커지만 이벤트 모델은 EPCIS TransformationEvent 가 제조 추적의 정합 표준.)
+ */
+// MES bizStep — CBV 재사용. producing = commissioning(신규 제품 커미셔닝).
+export const MES_BIZSTEP = {
+    receiving: 'urn:epcglobal:cbv:bizstep:receiving', // 원자재 수령
+    producing: 'urn:epcglobal:cbv:bizstep:commissioning', // 생산(제품 최초 생성)
+    storing: 'urn:epcglobal:cbv:bizstep:storing' // 완제품 저장
+};
+/** 작업지시(Work Order) = 생산 오더 거래 유형. */
+export const BTT_PRODORDER = 'urn:epcglobal:cbv:btt:prodorder';
+/** 직렬 SGTIN URI (원자재 단위·완제품). */
+export function sgtinUri(companyPrefix, itemRef, serial) {
+    return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,42 @@
+import type { CanonicalEnvelope, Command, CommandAck, ScenarioControl, StateSnapshot, TwinKernel } from './contract.ts';
+export type SubscriptionMessage = {
+    kind: 'snapshot';
+    revision: number;
+    state: StateSnapshot;
+} | {
+    kind: 'delta';
+    revision: number;
+    event: CanonicalEnvelope;
+} | {
+    kind: 'clock';
+    revision: number;
+    simClockMs: number;
+};
+export type SubscriptionHandler = (msg: SubscriptionMessage) => void;
+export interface RuntimeSubscription {
+    unsubscribe(): void;
+}
+export declare class TwinRuntime {
+    private kernel;
+    private subscribers;
+    private currentRevision;
+    constructor(kernel: TwinKernel);
+    /** State 채널 구독 — 즉시 현재 snapshot, 이후 델타(revision 연속). 멀티 구독자 독립. */
+    subscribe(handler: SubscriptionHandler): RuntimeSubscription;
+    /** gap(revision 불연속) 감지 시 재동기 — 현재 스냅샷. */
+    resync(): {
+        revision: number;
+        state: StateSnapshot;
+    };
+    /** 클록-싱크 하트비트 메시지 — host 가 자기 send-rate 로 방송(⊥ tick). 클라 보간의 nowSim. */
+    nowClock(): Extract<SubscriptionMessage, {
+        kind: 'clock';
+    }>;
+    /** Command 채널. */
+    dispatch(cmd: Command): CommandAck;
+    /** Clock — host 가 서버 클럭/RAF 로 구동. 실행당 엔진 1개(ADR-0010). */
+    tick(dtMs: number): void;
+    /** Scenario 채널(sim 모드). */
+    get scenario(): ScenarioControl;
+    get revision(): number;
+}

package/dist/runtime.js

@@ -0,0 +1,59 @@
+/*
+ * Twin Runtime — host-facing 3채널 facade + 구독 프로토콜 (framework-agnostic).
+ * 설계 SoT: integration/face1-contract.md "구독 프로토콜", execution-model.md §3·§4
+ *
+ * 커널(엔진)을 감싸 host 가 붙일 표면을 제공한다:
+ *  - State  : subscribe(snapshot → delta…, revision 연속) + resync(gap 복구)
+ *  - Command: dispatch
+ *  - Scenario: scenario (sim 모드)
+ *  - Clock  : tick (host 가 서버 클럭/RAF 로 구동 — 실행당 엔진 1개)
+ *
+ * 델타는 커널 이벤트(전이·move-start)로 **sparse** — 매 tick 스트림 아님(execution-model §4).
+ * GraphQL sub 등 실제 전송은 이 표면을 얇게 래핑(host 계층). 여기엔 프레임워크 결합 없음.
+ */
+export class TwinRuntime {
+    kernel;
+    subscribers = new Set();
+    currentRevision;
+    constructor(kernel) {
+        this.kernel = kernel;
+        this.currentRevision = kernel.getSnapshot().revision;
+        // 단일 내부 구독으로 revision 을 추적하고 구독자에게 fan-out.
+        // (커널은 emit 당 revision++ 1회 → currentRevision 이 커널 revision 을 미러.)
+        kernel.onEvent(event => {
+            this.currentRevision++;
+            const msg = { kind: 'delta', revision: this.currentRevision, event };
+            for (const s of this.subscribers)
+                s(msg);
+        });
+    }
+    /** State 채널 구독 — 즉시 현재 snapshot, 이후 델타(revision 연속). 멀티 구독자 독립. */
+    subscribe(handler) {
+        handler({ kind: 'snapshot', revision: this.currentRevision, state: this.kernel.getSnapshot() });
+        this.subscribers.add(handler);
+        return { unsubscribe: () => { this.subscribers.delete(handler); } };
+    }
+    /** gap(revision 불연속) 감지 시 재동기 — 현재 스냅샷. */
+    resync() {
+        return { revision: this.currentRevision, state: this.kernel.getSnapshot() };
+    }
+    /** 클록-싱크 하트비트 메시지 — host 가 자기 send-rate 로 방송(⊥ tick). 클라 보간의 nowSim. */
+    nowClock() {
+        return { kind: 'clock', revision: this.currentRevision, simClockMs: this.kernel.getSnapshot().simClockMs };
+    }
+    /** Command 채널. */
+    dispatch(cmd) {
+        return this.kernel.dispatch(cmd);
+    }
+    /** Clock — host 가 서버 클럭/RAF 로 구동. 실행당 엔진 1개(ADR-0010). */
+    tick(dtMs) {
+        this.kernel.tick(dtMs);
+    }
+    /** Scenario 채널(sim 모드). */
+    get scenario() {
+        return this.kernel.scenario;
+    }
+    get revision() {
+        return this.currentRevision;
+    }
+}

package/dist/state-projector.d.ts

@@ -0,0 +1,37 @@
+import type { BoardDef, CanonicalEnvelope, NodeState, ItemState, MoverState, TaskState, OrderState } from './contract.ts';
+/** 마스터 동기 — 선언적 로케이션 upsert/remove (실 소스 연동은 host 계층 Face2 커넥터). */
+export interface MasterUpdate {
+    op: 'upsert' | 'remove';
+    node: {
+        id: string;
+        type?: string;
+        capacity?: number;
+    };
+}
+export interface ProjectedState {
+    revision: number;
+    nodes: NodeState[];
+    items: ItemState[];
+    tasks: TaskState[];
+    movers: MoverState[];
+    orders: OrderState[];
+}
+export declare class StateProjector {
+    private master;
+    private items;
+    private aggregation;
+    private tasks;
+    private movers;
+    private orders;
+    revision: number;
+    constructor(board: BoardDef);
+    /** 마스터 동기 — 로케이션 추가/변경/제거. */
+    applyMaster(u: MasterUpdate): void;
+    /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
+    apply(e: CanonicalEnvelope): void;
+    private applyEpcis;
+    /** 이탈(DELETE) — 아이템 + 조립 자식(재귀) 제거. 화물 SSCC DELETE 시 팔레트도 함께 이탈. */
+    private remove;
+    /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+    snapshot(): ProjectedState;
+}