@operato/twin-kernel 0.0.1

package/dist/state-projector.js

@@ -0,0 +1,124 @@
+/*
+ * State Projector — 이벤트 스트림 → State 투영 (모니터링의 "수동 미러").
+ *
+ * sim 모드: 커널이 State 를 능동 생산(내부 상태 + 이벤트 방출).
+ * live 모드: 외부(실 WMS)에서 이벤트가 도착 → 이 projector 가 State 를 재구성.
+ * → "계약 동일, 데이터원만 스왑"(execution-model.md §5, ADR-0010). 같은 이벤트면 같은 State.
+ *
+ * 두 갈래 이벤트를 함께 접는다:
+ *  - EPCIS(epcis.*)      → 재고/위치/조립 (What/Where)
+ *  - 운영 델타(task/equipment/order.status) → tasks·movers·orders (EPCIS 로 재구성 불가한 절반)
+ * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
+ */
+import { OP_EVENT } from "./contract.js";
+export class StateProjector {
+    master = new Map();
+    items = new Map();
+    aggregation = new Map(); // parent SSCC → child EPCs
+    tasks = new Map();
+    movers = new Map();
+    orders = new Map();
+    revision = 0;
+    constructor(board) {
+        for (const n of board.nodes)
+            this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity });
+        // 무버 기준선(마스터) — equipment.status 델타로 갱신됨.
+        for (const m of board.movers)
+            this.movers.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeNode });
+    }
+    /** 마스터 동기 — 로케이션 추가/변경/제거. */
+    applyMaster(u) {
+        if (u.op === 'remove') {
+            this.master.delete(u.node.id);
+            return;
+        }
+        const cur = this.master.get(u.node.id);
+        this.master.set(u.node.id, {
+            id: u.node.id,
+            type: u.node.type ?? cur?.type ?? 'unknown',
+            capacity: u.node.capacity ?? cur?.capacity ?? 0
+        });
+    }
+    /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
+    apply(e) {
+        this.revision++;
+        if (e.eventType.startsWith('epcis.')) {
+            this.applyEpcis(e.data);
+            return;
+        }
+        switch (e.eventType) {
+            case OP_EVENT.task: {
+                const d = e.data;
+                this.tasks.set(d.taskId, { id: d.taskId, kind: d.kind, status: d.status, fromNode: d.fromNode, toNode: d.toNode, itemRefs: d.itemRefs, resourceRef: d.resourceRef });
+                break;
+            }
+            case OP_EVENT.equipment: {
+                const d = e.data;
+                this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, motion: d.motion });
+                break;
+            }
+            case OP_EVENT.order: {
+                const d = e.data;
+                this.orders.set(d.orderId, { id: d.orderId, kind: d.kind, status: d.status, progress: d.requested ? d.fulfilled / d.requested : 0, held: d.held });
+                break;
+            }
+            // 알 수 없는 eventType 은 무시(전방 호환).
+        }
+    }
+    applyEpcis(ev) {
+        if (ev.type === 'AggregationEvent') {
+            if (ev.action === 'ADD' && ev.childEPCs?.length)
+                this.aggregation.set(ev.parentID, [...ev.childEPCs]);
+            else if (ev.action === 'DELETE')
+                this.aggregation.delete(ev.parentID);
+            return;
+        }
+        if (ev.type === 'TransactionEvent')
+            return; // 거래 연결 — 오더 상태는 order.status 델타로
+        if (ev.type === 'TransformationEvent') {
+            // 변환: 입력 소비(제거) → 출력 생산(readPoint 에 등장)
+            for (const epc of ev.inputEPCList ?? [])
+                this.remove(epc);
+            const loc = ev.readPoint?.id ?? '';
+            for (const epc of ev.outputEPCList ?? [])
+                this.items.set(epc, { epc, location: loc, disposition: ev.disposition });
+            return;
+        }
+        // ObjectEvent
+        if (ev.action === 'DELETE') {
+            for (const epc of ev.epcList)
+                this.remove(epc);
+            return;
+        }
+        const loc = ev.readPoint?.id;
+        const gtin = ev.quantityList?.[0]?.epcClass;
+        for (const epc of ev.epcList) {
+            const cur = this.items.get(epc);
+            this.items.set(epc, { epc, gtin: gtin ?? cur?.gtin, location: loc ?? cur?.location ?? '', disposition: ev.disposition ?? cur?.disposition });
+        }
+    }
+    /** 이탈(DELETE) — 아이템 + 조립 자식(재귀) 제거. 화물 SSCC DELETE 시 팔레트도 함께 이탈. */
+    remove(epc) {
+        this.items.delete(epc);
+        const children = this.aggregation.get(epc);
+        if (children) {
+            this.aggregation.delete(epc);
+            for (const c of children)
+                this.remove(c);
+        }
+    }
+    /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+    snapshot() {
+        const occ = new Map();
+        for (const it of this.items.values())
+            occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
+        return {
+            revision: this.revision,
+            nodes: [...this.master.values()].map(n => ({ id: n.id, type: n.type, capacity: n.capacity, occupancy: occ.get(n.id) ?? 0 })),
+            items: [...this.items.values()].map(i => ({ epc: i.epc, gtin: i.gtin, location: i.location, disposition: i.disposition })),
+            tasks: [...this.tasks.values()].map(t => ({ ...t })),
+            movers: [...this.movers.values()].map(m => ({ ...m })),
+            orders: [...this.orders.values()].map(o => ({ ...o }))
+        };
+    }
+}

package/dist/twin-observer.d.ts

@@ -0,0 +1,28 @@
+import type { StateSnapshot } from './contract.ts';
+import { type StateDivergence } from './divergence.ts';
+/** 관찰 대상 = fork 가능한 트윈(FlowEngine 이 만족). */
+export interface ObservableTwin {
+    getSnapshot(): StateSnapshot;
+    tick(dtMs: number): void;
+    fork(): ObservableTwin;
+}
+export interface DivergenceAlert {
+    forecastAtSimMs: number;
+    horizonSimMs: number;
+    divergence: StateDivergence;
+}
+export interface TwinObserverOptions {
+    horizonMs: number;
+    tickMs?: number;
+    onDivergence?: (alert: DivergenceAlert) => void;
+}
+export declare class TwinObserver {
+    private live;
+    private opts;
+    private pending;
+    constructor(live: ObservableTwin, opts: TwinObserverOptions);
+    /** 관측 1회 — 만기 예측을 실제와 대조(발산 알림) + 새 예측 생성. 호스트가 주기적으로 호출. */
+    observe(): void;
+    /** 대기 중(아직 만기 안 된) 예측 수 — 진단용. */
+    get pendingCount(): number;
+}

package/dist/twin-observer.js

@@ -0,0 +1,41 @@
+/*
+ * TwinObserver — 자동 정합 루프 (트윈이 자기 모델↔현실 이탈을 능동 감지).
+ *
+ * fork(현재예측) + compareStates(정합)를 살아있는 루프로: 주기적으로 fork 해서 horizon 앞으로 굴려
+ * 예측을 저장하고, 실제(live)가 그 시점에 도달하면 예측과 대조해 드리프트를 알린다.
+ * 순수 sim(방해 없음)이면 예측=미래(RNG 연속) → 발산 0. 방해(커맨드·실이벤트)면 발산 → 이상/개입 신호.
+ */
+import { compareStates } from "./divergence.js";
+export class TwinObserver {
+    live;
+    opts;
+    pending = [];
+    constructor(live, opts) {
+        this.live = live;
+        this.opts = opts;
+    }
+    /** 관측 1회 — 만기 예측을 실제와 대조(발산 알림) + 새 예측 생성. 호스트가 주기적으로 호출. */
+    observe() {
+        const now = this.live.getSnapshot().simClockMs;
+        // 1) 만기 도래 예측을 실제와 대조
+        const due = this.pending.filter(p => p.horizonSimMs <= now);
+        this.pending = this.pending.filter(p => p.horizonSimMs > now);
+        for (const p of due) {
+            const d = compareStates(p.predicted, this.live.getSnapshot());
+            if (d.hasDrift)
+                this.opts.onDivergence?.({ forecastAtSimMs: p.madeAtSimMs, horizonSimMs: p.horizonSimMs, divergence: d });
+        }
+        // 2) 새 예측: fork → horizon 까지 굴림 → 저장
+        const fc = this.live.fork();
+        const step = this.opts.tickMs ?? 1000;
+        const target = now + this.opts.horizonMs;
+        let guard = 0;
+        while (fc.getSnapshot().simClockMs < target && guard++ < 1_000_000)
+            fc.tick(step);
+        this.pending.push({ madeAtSimMs: now, horizonSimMs: fc.getSnapshot().simClockMs, predicted: fc.getSnapshot() });
+    }
+    /** 대기 중(아직 만기 안 된) 예측 수 — 진단용. */
+    get pendingCount() {
+        return this.pending.length;
+    }
+}

package/dist/wms-profile.d.ts

@@ -0,0 +1,13 @@
+export declare const BIZSTEP: {
+    readonly receiving: "urn:epcglobal:cbv:bizstep:receiving";
+    readonly storing: "urn:epcglobal:cbv:bizstep:storing";
+    readonly picking: "urn:epcglobal:cbv:bizstep:picking";
+    readonly packing: "urn:epcglobal:cbv:bizstep:packing";
+    readonly staging_outbound: "urn:epcglobal:cbv:bizstep:staging_outbound";
+    readonly shipping: "urn:epcglobal:cbv:bizstep:shipping";
+    readonly replenishing: "urn:epcglobal:cbv:bizstep:replenishing";
+};
+export declare const BTT: {
+    readonly po: "urn:epcglobal:cbv:btt:po";
+    readonly so: "urn:epcglobal:cbv:btt:so";
+};

package/dist/wms-profile.js

@@ -0,0 +1,20 @@
+/*
+ * WMS Profile — 물류창고 어휘(CBV bizStep + business transaction type).
+ * EPCIS machinery(타입·빌더·검증기·URI·DISP)는 도메인-중립 `epcis.ts` 에 있다.
+ * 설계 SoT: operato-twin/design/profiles/wms.md §11
+ */
+// bizStep — CBV URN (wms.md §11 확정 어휘)
+export const BIZSTEP = {
+    receiving: 'urn:epcglobal:cbv:bizstep:receiving',
+    storing: 'urn:epcglobal:cbv:bizstep:storing',
+    picking: 'urn:epcglobal:cbv:bizstep:picking',
+    packing: 'urn:epcglobal:cbv:bizstep:packing',
+    staging_outbound: 'urn:epcglobal:cbv:bizstep:staging_outbound',
+    shipping: 'urn:epcglobal:cbv:bizstep:shipping',
+    replenishing: 'urn:epcglobal:cbv:bizstep:replenishing'
+};
+// bizTransaction 유형 — CBV btt (§2 "거래" 매핑: PO=입고 ASN, SO=출고 오더)
+export const BTT = {
+    po: 'urn:epcglobal:cbv:btt:po',
+    so: 'urn:epcglobal:cbv:btt:so'
+};

package/dist/yms-kernel.d.ts

@@ -0,0 +1,29 @@
+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';
+export type YardMode = 'live' | 'drop';
+export declare class YmsKernel extends FlowEngine {
+    private doorRR;
+    private cargoSeq;
+    private trailerCargo;
+    private apptMode;
+    /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
+    mode: YardMode;
+    constructor(tenantId: string, policy?: AllocationPolicy, mode?: YardMode);
+    /** 인바운드(하차) 자극 — 화물 적재된 트레일러 도착. */
+    protected onArrival(_spec: GeneratorSpec): void;
+    /** 아웃바운드(상차) 자극 — 빈 트레일러 도착(도크에서 staging 화물 적재 예정). */
+    protected onOrder(_spec: GeneratorSpec): void;
+    /** 게이트-인 — 트레일러 도착 → 어포인트먼트(도크도어 배정 + 창). drop 은 야드 주차 태스크, live 는 게이트 대기. */
+    private spawnAppointment;
+    /**
+     * 스케줄 게이트(base 가 created 오더마다 매 tick 호출) — 조건 충족 시 도크로 이동:
+     *   ① 창 도래(clock ≥ windowStart)  ② 배정 도크도어 예약 가능
+     *   ③ drop: 트레일러가 야드 주차됨 / live: 게이트 대기 중  ④ 아웃바운드: staging 적재 화물 충분
+     * 하나라도 안 되면 대기(다음 tick 재시도). = 시간창 예약 스케줄링.
+     */
+    protected allocate(o: FlowOrder): void;
+    /** 태스크 완료 — 목적지 타입으로 분기: yard-slot=주차, dock-door=상/하차+depart, gate=출차. */
+    protected onTaskComplete(t: FlowTask): void;
+}

package/dist/yms-kernel.js

@@ -0,0 +1,181 @@
+/*
+ * YMS Kernel — 야드 어포인트먼트 스케줄링(도메인). mechanics 는 FlowEngine base 재사용.
+ * 인바운드(하차): 게이트-인 → 야드 대기 → (창+도어) 도크 → 하차 → 출차.
+ * 아웃바운드(상차): 빈 트레일러 도착 → 야드 대기 → (창+도어+staging 화물) 도크 → 상차 → 적재 출차.
+ *
+ * ★ 검증 질문: base 가 "시간창 예약 스케줄링"을 흡수하는가?
+ *   → clock(base) + 노드 점유(도크도어 예약) + allocate hook(스케줄 게이트)로 표현 — base 변경 0.
+ *
+ * 상·하차 대칭(AggregationEvent):
+ *   - 하차(inbound): 게이트-인에 트레일러←화물 조립(ADD), 도크에서 분해(DELETE) → 화물이 staging 에 등장(WMS receiving hand-off).
+ *   - 상차(outbound): 빈 트레일러 도착, 도크에서 staging 화물을 트레일러로 조립(ADD) → 적재 트레일러 출차(WMS shipping hand-off).
+ *   두 방향이 inbound-unload → staging → outbound-load 로 이어지면 크로스도크.
+ *
+ * live vs drop(야드 운영 모드):
+ *   - drop(기본): 트레일러를 야드 슬롯에 내려놓고(주차) 창 도래 시 호슬러가 도크로 pull. 야드 버퍼 사용.
+ *   - live: 게이트에서 대기하다 창 도래 시 도크로 직행(야드 미경유). 게이트/도크를 더 오래 점유.
+ */
+import { firstFitPolicy } from "./allocation-policy.js";
+import { FlowEngine } from "./flow-engine.js";
+import { DISP, objectEvent, transactionEvent, gdtiUri, ssccUri } from "./epcis.js";
+import { YARD_BIZSTEP, BTT_DELIVERY, graiUri } from "./yms-profile.js";
+const TRAVEL_MS = 20_000; // 야드 이동
+const DWELL_MS = 30_000; // 도크 체류(상·하차) — depart 이동에 folded
+const WINDOW_DELAY_MS = 40_000; // 도착 후 어포인트먼트 창까지(early arrival → 대기)
+const CARGO_PER_TRAILER = 2; // 트레일러 적재/하역 화물(SSCC) 수
+const CP = '0614141';
+export class YmsKernel extends FlowEngine {
+    doorRR = 0;
+    cargoSeq = 0;
+    trailerCargo = new Map(); // 트레일러 epc → 화물 SSCC(하차 전 opaque / 상차 예약분)
+    apptMode = new Map(); // orderId → 상하차 모드(생성 시 캡처)
+    /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
+    mode;
+    constructor(tenantId, policy = firstFitPolicy, mode = 'drop') {
+        super(tenantId, policy);
+        this.mode = mode;
+    }
+    /** 인바운드(하차) 자극 — 화물 적재된 트레일러 도착. */
+    onArrival(_spec) { this.spawnAppointment('appointment'); }
+    /** 아웃바운드(상차) 자극 — 빈 트레일러 도착(도크에서 staging 화물 적재 예정). */
+    onOrder(_spec) { this.spawnAppointment('appointment-out'); }
+    /** 게이트-인 — 트레일러 도착 → 어포인트먼트(도크도어 배정 + 창). drop 은 야드 주차 태스크, live 는 게이트 대기. */
+    spawnAppointment(kind) {
+        const gate = this.nodeByType('gate');
+        const doors = [...this.nodes.values()].filter(n => n.type === 'dock-door').sort((a, b) => a.id.localeCompare(b.id));
+        if (!gate || doors.length === 0)
+            return;
+        const inbound = kind === 'appointment';
+        const epc = graiUri(CP, '10', ++this.epcSeq);
+        this.items.set(epc, { epc, location: gate.id, disposition: DISP.in_progress });
+        gate.occupancy++;
+        this.emit(objectEvent({ eventTime: this.now(), action: 'ADD', bizStep: YARD_BIZSTEP.arriving, disposition: DISP.in_progress, epcList: [epc], readPoint: gate.id, bizLocation: gate.id }));
+        // 인바운드: 화물 적재된 채 도착 → 조립(트레일러←화물) 기록. 아웃바운드: 빈 트레일러(화물은 도크에서 적재).
+        if (inbound) {
+            const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => ssccUri(CP, ++this.cargoSeq));
+            this.trailerCargo.set(epc, cargo);
+            this.aggregate(epc, cargo, { bizStep: YARD_BIZSTEP.arriving, readPoint: gate.id }); // 적재된 채 도착(자식 opaque, 미materialize)
+        }
+        const door = doors[this.doorRR++ % doors.length];
+        const id = `order-${++this.orderSeq}`;
+        const appt = gdtiUri(CP, '404', ++this.soSeq);
+        const order = { id, kind, status: 'created', requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [epc], picked: [], dockDoor: door.id, windowStartMs: this.clockMs + WINDOW_DELAY_MS };
+        this.orders.set(id, order);
+        this.apptMode.set(id, this.mode);
+        this.emitOrder(order);
+        // drop: 야드 주차(gate→yard-slot). live: 태스크 없음(게이트 대기 → allocate 가 도크 직행).
+        if (this.mode === 'drop') {
+            const slotId = this.policy.selectPlacement({ item: { epc, gtin: 'trailer', qty: 1 }, slots: this.slotViews('yard-slot') });
+            if (!slotId)
+                return; // 야드 만차 → 게이트 대기
+            const task = { id: `task-${++this.taskSeq}`, kind: 'spot', status: 'created', itemEpc: epc, fromNode: gate.id, toNode: slotId, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'spot', fromNode: gate.id, toNode: slotId }, TRAVEL_MS) };
+            this.tasks.set(task.id, task);
+            this.emitTask(task);
+        }
+    }
+    /**
+     * 스케줄 게이트(base 가 created 오더마다 매 tick 호출) — 조건 충족 시 도크로 이동:
+     *   ① 창 도래(clock ≥ windowStart)  ② 배정 도크도어 예약 가능
+     *   ③ drop: 트레일러가 야드 주차됨 / live: 게이트 대기 중  ④ 아웃바운드: staging 적재 화물 충분
+     * 하나라도 안 되면 대기(다음 tick 재시도). = 시간창 예약 스케줄링.
+     */
+    allocate(o) {
+        const trailer = this.items.get(o.allocated[0]);
+        if (!trailer)
+            return;
+        if (this.clockMs < (o.windowStartMs ?? 0))
+            return; // 창 도래 전
+        const door = this.nodes.get(o.dockDoor);
+        const inflight = [...this.tasks.values()].some(t => t.status !== 'completed' && t.toNode === door.id);
+        if (door.occupancy > 0 || inflight)
+            return; // 도어 사용중/예약됨 → 대기(직렬화)
+        const mode = this.apptMode.get(o.id) ?? 'drop';
+        if (mode === 'drop' && this.nodes.get(trailer.location)?.type !== 'yard-slot')
+            return; // 아직 미주차
+        const outbound = o.kind === 'appointment-out';
+        const bizStep = outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading;
+        if (outbound) {
+            // 아웃바운드: staging 에 적재 화물(sellable, 미예약) 충분해야 도크로. 예약(disposition 미변경 → 조용한 예약).
+            const staging = this.nodeByType('staging');
+            const reserved = new Set([...this.trailerCargo.values()].flat());
+            const avail = [...this.items.values()]
+                .filter(i => i.location === staging?.id && i.disposition === DISP.sellable && !reserved.has(i.epc))
+                .sort((a, b) => a.epc.localeCompare(b.epc));
+            if (!staging || avail.length < CARGO_PER_TRAILER)
+                return; // 적재 화물 부족 → 대기
+            this.trailerCargo.set(trailer.epc, avail.slice(0, CARGO_PER_TRAILER).map(i => i.epc));
+        }
+        trailer.disposition = DISP.reserved;
+        this.emit(transactionEvent({ eventTime: this.now(), action: 'ADD', bizStep, bizTransactionList: [{ type: BTT_DELIVERY, bizTransaction: o.bizTransaction }], epcList: [trailer.epc], readPoint: door.id }));
+        // drop: 야드→도크 pull. live: 게이트→도크 직행(spot-live). 둘 다 toNode=도크도어.
+        const dockKind = mode === 'drop' ? 'pull' : 'spot-live';
+        const task = { id: `task-${++this.taskSeq}`, kind: dockKind, status: 'created', itemEpc: trailer.epc, fromNode: trailer.location, toNode: door.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: dockKind, fromNode: trailer.location, toNode: door.id }, TRAVEL_MS), orderId: o.id };
+        this.tasks.set(task.id, task);
+        this.emitTask(task);
+        o.status = 'docking';
+        this.emitOrder(o);
+    }
+    /** 태스크 완료 — 목적지 타입으로 분기: yard-slot=주차, dock-door=상/하차+depart, gate=출차. */
+    onTaskComplete(t) {
+        const trailer = this.items.get(t.itemEpc);
+        const from = this.nodes.get(t.fromNode);
+        const to = this.nodes.get(t.toNode);
+        from.occupancy--;
+        to.occupancy++;
+        trailer.location = to.id;
+        if (t.kind === 'dwell') {
+            // 도크 체류(무자원 dwell) 완료 → 출차 이동(transport). 체류 중 호슬러 미점유(drop-and-hook 충실).
+            const gate = this.nodeByType('gate');
+            const dep = { id: `task-${++this.taskSeq}`, kind: 'depart', status: 'created', itemEpc: trailer.epc, fromNode: t.toNode, toNode: gate.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'depart', fromNode: t.toNode, toNode: gate.id }, TRAVEL_MS), orderId: t.orderId };
+            this.tasks.set(dep.id, dep);
+            this.emitTask(dep);
+            return;
+        }
+        if (to.type === 'yard-slot') {
+            // drop 주차 — 야드 대기(창 도래까지). 도어는 depart 완료까지 미점유.
+            trailer.disposition = DISP.sellable;
+            this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: YARD_BIZSTEP.staging, disposition: DISP.sellable, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+            return;
+        }
+        if (to.type === 'dock-door') {
+            const order = t.orderId ? this.orders.get(t.orderId) : undefined;
+            const outbound = order?.kind === 'appointment-out';
+            const staging = this.nodeByType('staging');
+            const cargo = this.trailerCargo.get(trailer.epc) ?? [];
+            // 도크 도착 — 상·하차 관측. 도어는 depart 완료까지 점유(예약 유지).
+            this.emit(objectEvent({ eventTime: this.now(), action: 'OBSERVE', bizStep: outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading, disposition: DISP.in_progress, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+            if (outbound) {
+                // 상차: staging 화물 → 트레일러 조립(merge). 화물은 staging 이탈(consume → 트레일러 안 opaque, 적재 출차).
+                if (cargo.length && staging) {
+                    this.aggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.loading, readPoint: to.id, consume: { readPoint: staging.id, disposition: DISP.in_transit } });
+                }
+                this.trailerCargo.delete(trailer.epc); // 적재 완료 → 예약분 소진(트레일러가 화물 보유)
+                trailer.disposition = DISP.sellable; // 적재 완료(loaded)
+            }
+            else if (cargo.length && staging) {
+                // 하차: 트레일러←화물 분해(split) → 화물이 staging 에 materialize(WMS receiving hand-off).
+                this.disaggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.unloading, readPoint: to.id, materialize: { location: staging.id, disposition: DISP.sellable } });
+                this.trailerCargo.delete(trailer.epc);
+            }
+            // 도크 체류 = 무자원 dwell 태스크(호슬러 해방). 완료 시 depart 이동 생성.
+            const dwell = { id: `task-${++this.taskSeq}`, kind: 'dwell', status: 'created', itemEpc: trailer.epc, fromNode: to.id, toNode: to.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: 'dwell', fromNode: to.id, toNode: to.id }, DWELL_MS), orderId: t.orderId, intent: 'dwell' };
+            this.tasks.set(dwell.id, dwell);
+            this.emitTask(dwell);
+            if (order) {
+                order.status = 'dwelling';
+                this.emitOrder(order);
+            }
+            return;
+        }
+        // gate (depart 완료) → 출차(DELETE). 인바운드=빈 트레일러, 아웃바운드=적재 트레일러(화물은 상차 시 이미 opaque 이탈).
+        this.emit(objectEvent({ eventTime: this.now(), action: 'DELETE', bizStep: YARD_BIZSTEP.departing, disposition: DISP.in_transit, epcList: [trailer.epc], readPoint: to.id }));
+        this.items.delete(trailer.epc);
+        to.occupancy--; // 게이트 통과(잔류 안 함)
+        const order = t.orderId ? this.orders.get(t.orderId) : undefined;
+        if (order) {
+            order.fulfilled = 1;
+            order.status = 'departed';
+            this.emitOrder(order);
+        }
+    }
+}

package/dist/yms-profile.d.ts

@@ -0,0 +1,11 @@
+export declare const YARD_BIZSTEP: {
+    readonly arriving: "urn:epcglobal:cbv:bizstep:arriving";
+    readonly staging: "urn:epcglobal:cbv:bizstep:staging";
+    readonly loading: "urn:epcglobal:cbv:bizstep:loading";
+    readonly unloading: "urn:epcglobal:cbv:bizstep:unloading";
+    readonly departing: "urn:epcglobal:cbv:bizstep:departing";
+};
+/** 어포인트먼트/배송 거래 유형(CBV btt). */
+export declare const BTT_DELIVERY = "urn:epcglobal:cbv:btt:deliv";
+/** 트레일러/컨테이너 = GRAI(Global Returnable Asset Identifier, 반납형 자산). */
+export declare function graiUri(companyPrefix: string, assetType: string, serial: number): string;

package/dist/yms-profile.js

@@ -0,0 +1,22 @@
+/*
+ * YMS Profile — yard(야드) 버티컬. 공유 코어 재사용 검증용 두 번째 프로파일.
+ * EPCIS 빌더(objectEvent 등)·DISP 는 epcis 에서 재사용하고, 야드 어휘만 더한다.
+ * (설계: profiles/yms.md, 03-reference-standards §YMS=GS1 EPCIS zone)
+ *
+ * 목적: contract·state-projector·runtime·allocation-policy·EPCIS 빌더가 WMS 전용이 아니라
+ *       도메인-일반임을 야드로 증명. 코어 수정 없이 프로파일만 추가되면 헌장 원칙 2 검증.
+ */
+// 야드 bizStep — CBV (yms.md §11).
+export const YARD_BIZSTEP = {
+    arriving: 'urn:epcglobal:cbv:bizstep:arriving', // 게이트-인
+    staging: 'urn:epcglobal:cbv:bizstep:staging', // 야드 슬롯 주차·대기
+    loading: 'urn:epcglobal:cbv:bizstep:loading', // 도크 작업(상차: 트레일러←화물)
+    unloading: 'urn:epcglobal:cbv:bizstep:unloading', // 도크 작업(하차: 트레일러→화물)
+    departing: 'urn:epcglobal:cbv:bizstep:departing' // 게이트-아웃
+};
+/** 어포인트먼트/배송 거래 유형(CBV btt). */
+export const BTT_DELIVERY = 'urn:epcglobal:cbv:btt:deliv';
+/** 트레일러/컨테이너 = GRAI(Global Returnable Asset Identifier, 반납형 자산). */
+export function graiUri(companyPrefix, assetType, serial) {
+    return `urn:epc:id:grai:${companyPrefix}.${assetType}.${String(serial).padStart(6, '0')}`;
+}