@operato/twin-kernel 0.0.4 → 0.0.6

package/dist/mes-kernel.js

@@ -14,6 +14,8 @@ import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass } from "./epci
 import { MES_BIZSTEP, BTT_PRODORDER, sgtinUri } from "./mes-profile.js";
 const CYCLE_MS = 40_000;
 const SETUP_MS = 15_000; // 체인지오버(제품 전환) 셋업 — OEE 가용성 손실
+// MES 도메인 커맨드(Tier 2, 무방언 — MES 어휘는 MES 커널 소유). handleCommand 로 처리.
+const MES_CMD = { changeover: 'mes.changeover' };
 const CP = '0614141';
 const WIP_ITEMREF = '066666';
 const WIP_GTIN = sgtinClass(CP, WIP_ITEMREF);
@@ -30,15 +32,56 @@ const PRODUCTS = [
 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 };
+/** 레거시 MES 제품 목록(gtin+라벨) — mes.changeover 대상 제품 소싱용. 정의-구동 전환 시 recipe 출력으로 교체. */
+export const MES_PRODUCTS = PRODUCTS.map(p => ({ gtin: p.gtin, label: p.key }));
+/*
+ * 트레일러 제조 라우트 — 순차 스테이션. 각 스테이션 완료가 다음 WIP 로 변환 + 다음 스테이션 태스크 발행.
+ * 첫 스테이션(cut)은 BOM 부품 N→WIP, 중간은 WIP→WIP, 마지막(assembly)은 WIP→완성차(+수율/OEE).
+ * 각 스테이션 = 이종 자원(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' }
+];
 export class MesKernel extends FlowEngine {
     wipSeq = 0;
     prodSeq = 0;
-    constructor(tenantId, policy = firstFitPolicy) {
+    /** 정의-구동 모드(선택). 미지정 시 레거시 하드코딩 경로 — byte-identical. */
+    mesSpec;
+    constructor(tenantId, policy = firstFitPolicy, mesSpec) {
         super(tenantId, policy);
+        this.mesSpec = mesSpec;
     }
     productOf(gtin) { return PRODUCTS.find(p => p.gtin === gtin); }
+    /**
+     * MES 도메인 커맨드(Tier 2) — mes.changeover: 설비를 제품 gtin 으로 강제 전환.
+     * 자동 체인지오버(task.changeoverKey 상이 시 셋업)의 수동 버전 — 운영자가 사전 전환(툴링 교체) 지시.
+     * 이미 그 제품이면 no-op, 아니면 셋업(SETUP_MS, OEE 가용성 손실) + lastChangeoverKey 각인
+     * (이후 그 제품 task 는 자동 셋업 생략). command → 변이 → State 델타(폐루프).
+     */
+    handleCommand(cmd) {
+        if (cmd.type === MES_CMD.changeover) {
+            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);
+            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) {
+                m.setupMs += SETUP_MS; // 셋업 = OEE 가용성 손실
+                m.lastChangeoverKey = a.gtin;
+                this.emitMover(m);
+            }
+            return { commandId: cmd.commandId, accepted: true };
+        }
+        return super.handleCommand(cmd);
+    }
     /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
     onArrival(spec) {
+        if (this.mesSpec)
+            return this.onArrivalDef(spec);
         const rawStore = this.nodeByType('raw-store');
         if (!rawStore)
             return;
@@ -53,6 +96,8 @@ export class MesKernel extends FlowEngine {
     }
     /** 작업지시 — 제품 2종 교대(체인지오버 유발). 제품 gtin 을 오더에 기록. */
     onOrder(_spec) {
+        if (this.mesSpec)
+            return this.onOrderDef(_spec);
         const product = PRODUCTS[this.orderSeq % PRODUCTS.length];
         const id = `order-${++this.orderSeq}`;
         const wo = gdtiUri(CP, '403', ++this.soSeq);
@@ -60,11 +105,14 @@ export class MesKernel extends FlowEngine {
         this.orders.set(id, order);
         this.emitOrder(order);
     }
-    /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + op1(cut, 체인지오버 셋업). */
+    /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + 라우트 첫 스테이션(절단) 태스크. */
     allocate(o) {
-        const cut = this.nodeByType('cut-station');
+        if (this.mesSpec)
+            return this.allocateDef(o);
+        const s0 = ROUTE[0];
+        const first = this.nodeByType(s0.node);
         const product = this.productOf(o.gtin);
-        if (!cut || !product)
+        if (!first || !product)
             return;
         // BOM 전 라인 확보 확인(부족하면 아무것도 예약 안 하고 대기)
         const picks = [];
@@ -82,42 +130,155 @@ export class MesKernel extends FlowEngine {
             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.emitStation(o, s0, o.allocated[0], product.gtin);
+        o.status = 'op-' + s0.kind;
+        this.emitOrder(o);
+    }
+    /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(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 }, CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, 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 품질 보고). */
+    /** op 완료 = 변환. 라우트 인덱스로 분기: 첫=BOM 소비→WIP, 중간=WIP→WIP, 마지막(조립)=WIP→완성차(수율→OEE 품질). */
     onTaskComplete(t) {
+        if (this.mesSpec)
+            return this.onTaskCompleteDef(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 i = ROUTE.findIndex(s => s.kind === t.kind);
+        const node = this.nodes.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);
-            // 변환(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 }] });
+            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 }] });
             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';
+            const next = ROUTE[i + 1];
+            this.emitStation(order, next, wip, product.gtin);
+            order.status = 'op-' + next.kind;
             this.emitOrder(order);
             return;
         }
-        // weld → 완제품 (transform 1→1, disposition 으로 수율 loss 반영 → OEE 품질)
-        const weld = this.nodes.get(t.toNode);
+        // 마지막 스테이션(조립) → 완성차 (transform 1→1, disposition 으로 수율 loss → OEE 품질)
         const fgStore = this.nodeByType('fg-store');
         const wip = order.allocated[0];
         const good = this.rng() < YIELD;
-        this.recordOutput(t.resource, good); // OEE 품질(welder 자원별 양품/불량)
+        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: 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 }));
+        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.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;
+        order.status = good ? 'produced' : 'scrapped';
+        this.emitOrder(order);
+    }
+    // ── 정의-구동 모드 (도메인 정의 데이터로 실행 — 레거시와 분리, 하드코딩 대체) ──
+    recipeDef() {
+        const d = this.mesSpec.definition;
+        return (this.mesSpec.recipeKey ? d.recipes?.find(r => r.key === this.mesSpec.recipeKey) : d.recipes?.[0]);
+    }
+    /** 자재 키 → 구체 gtin 클래스(idpat). 구체 식별은 바인딩+prefix 로 인스턴스가 주입. */
+    classOf(materialKey) {
+        return sgtinClass(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey]);
+    }
+    serialOf(materialKey, serial) {
+        return sgtinUri(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey], serial);
+    }
+    /** recipe.route → 오퍼레이션 시퀀스 해소. */
+    routeOps() {
+        const d = this.mesSpec.definition;
+        const route = d.routes?.find(r => r.key === this.recipeDef().route);
+        return (route?.steps ?? []).map(sk => d.operations?.find(o => o.key === sk)).filter((o) => !!o);
+    }
+    /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 raw-store 에 생성. */
+    onArrivalDef(spec) {
+        const rawStore = this.nodeByType('raw-store');
+        if (!rawStore)
+            return;
+        const gtin = this.pickGtin(spec.content.skuMix);
+        const inputKey = this.recipeDef().inputs.map(i => i.material).find(k => this.classOf(k) === gtin);
+        if (!inputKey)
+            return;
+        const epc = this.serialOf(inputKey, ++this.epcSeq);
+        this.items.set(epc, { epc, 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: gtin, quantity: 1 }], readPoint: rawStore.id, bizLocation: rawStore.id }));
+    }
+    /** 정의 모드 작업지시 — 레시피 산출물 1개. */
+    onOrderDef(_spec) {
+        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: [] };
+        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))
+            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')
+                .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)
+                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() }));
+        this.emitStationDef(o, ops[0], o.allocated[0]);
+        o.status = 'op-' + ops[0].key;
+        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 }, CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: SETUP_MS, intent: op.intent };
+        this.tasks.set(task.id, task);
+        this.emitTask(task);
+    }
+    /** 정의 모드 완료 — 라우트 인덱스: 중간=WIP 변환+다음 스텝, 마지막=완제품(수율). */
+    onTaskCompleteDef(t) {
+        const order = this.orders.get(t.orderId);
+        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 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 }] });
+            order.allocated = [wip];
+            const next = ops[i + 1];
+            this.emitStationDef(order, next, wip);
+            order.status = 'op-' + next.key;
+            this.emitOrder(order);
+            return;
+        }
+        const fgStore = this.nodeByType('fg-store');
+        const wip = order.allocated[0];
+        const good = this.rng() < 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.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;
         order.status = good ? 'produced' : 'scrapped';

package/dist/mes-profile.d.ts

@@ -1,3 +1,4 @@
+import type { TwinTypeInfo } from './domain-catalog.ts';
 export declare const MES_BIZSTEP: {
     readonly receiving: "urn:epcglobal:cbv:bizstep:receiving";
     readonly producing: "urn:epcglobal:cbv:bizstep:commissioning";
@@ -7,5 +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. */
-export declare const MES_NODE_TYPES: readonly ["raw-store", "cut-station", "weld-station", "fg-store"];
+/** MES 노드 타입 카탈로그 — 커널이 키로 쓰는 제조 로케이션 타입(nodeByType/.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_TYPES: TwinTypeInfo[];

package/dist/mes-profile.js

@@ -1,8 +1,3 @@
-/*
- * 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', // 원자재 수령
@@ -15,5 +10,26 @@ export const BTT_PRODORDER = 'urn:epcglobal:cbv:btt:prodorder';
 export function sgtinUri(companyPrefix, itemRef, serial) {
     return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
 }
-/** MES 노드 타입 카탈로그 — 커널이 키로 쓰는 제조 로케이션 타입(nodeByType/.type). 도메인 SSOT. */
-export const MES_NODE_TYPES = ['raw-store', 'cut-station', 'weld-station', 'fg-store'];
+/** MES 노드 타입 카탈로그 — 커널이 키로 쓰는 제조 로케이션 타입(nodeByType/.type). 도메인 SSOT.
+ * 트레일러 제조 라인: 자재→프레임 절단→용접→도장→조립→완성차(kernel ROUTE 와 일치). */
+export const MES_NODE_TYPES = ['raw-store', 'cut-station', 'weld-station', 'paint-booth', 'assembly-line', 'fg-store'];
+/*
+ * 트윈 타입 서술(ADR-0018 확장) — 노드 키는 MES_NODE_TYPES 단일 출처에서 파생 + 무버(자원) 타입 추가.
+ * MES=ISA-95 앵커: 스테이션=WorkCenter, 저장소=bizLocation. 무버(가공설비)=Equipment/자산(GIAI). key 는 flow resourceType 과 일치.
+ */
+// label 은 언어 중립 i18n 키(twin.type.<key>) — cls(표준 클래스)만 노드별 메타로 유지. 사람 언어는 표현계층(L2).
+const MES_NODE_CLS = {
+    'raw-store': { epcis: 'bizLocation' },
+    'cut-station': { isa95: 'WorkCenter', epcis: 'bizLocation' },
+    'weld-station': { isa95: 'WorkCenter', epcis: 'bizLocation' },
+    'paint-booth': { isa95: 'WorkCenter', epcis: 'bizLocation' },
+    'assembly-line': { isa95: 'WorkCenter', epcis: 'bizLocation' },
+    'fg-store': { epcis: 'bizLocation' }
+};
+export const MES_TYPES = [
+    ...MES_NODE_TYPES.map((k) => ({ key: k, role: 'node', label: `twin.type.${k}`, standardClass: MES_NODE_CLS[k] ?? {}, identity: { scheme: 'gs1:SGLN' }, capabilities: ['storable'] })),
+    { key: 'cutter', role: 'mover', label: 'twin.type.cutter', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] },
+    { key: 'welder', role: 'mover', label: 'twin.type.welder', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] },
+    { key: 'painter', role: 'mover', label: 'twin.type.painter', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] },
+    { key: 'assembler', role: 'mover', label: 'twin.type.assembler', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] }
+];

package/dist/state-projector.js

@@ -21,7 +21,7 @@ export class StateProjector {
     revision = 0;
     constructor(board) {
         for (const n of board.nodes)
-            this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity });
+            this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parentId: n.parentId });
         // 무버 기준선(마스터) — equipment.status 델타로 갱신됨.
         for (const m of board.movers)
             this.movers.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeNode });
@@ -114,7 +114,7 @@ export class StateProjector {
             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 })),
+            nodes: [...this.master.values()].map(n => ({ id: n.id, type: n.type, capacity: n.capacity, occupancy: occ.get(n.id) ?? 0, parentId: n.parentId })),
             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 })),

package/dist/wms-profile.d.ts

@@ -1,3 +1,4 @@
+import type { TwinTypeInfo } from './domain-catalog.ts';
 export declare const BIZSTEP: {
     readonly receiving: "urn:epcglobal:cbv:bizstep:receiving";
     readonly storing: "urn:epcglobal:cbv:bizstep:storing";
@@ -16,3 +17,4 @@ export declare const BTT: {
  * 도메인 어휘 SSOT: 호스트·UI 는 이걸 소싱하고 재선언하지 않는다(방언 금지).
  */
 export declare const WMS_NODE_TYPES: readonly ["dock", "storage", "staging", "dock-ship"];
+export declare const WMS_TYPES: TwinTypeInfo[];

package/dist/wms-profile.js

@@ -1,8 +1,3 @@
-/*
- * 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',
@@ -23,3 +18,12 @@ export const BTT = {
  * 도메인 어휘 SSOT: 호스트·UI 는 이걸 소싱하고 재선언하지 않는다(방언 금지).
  */
 export const WMS_NODE_TYPES = ['dock', 'storage', 'staging', 'dock-ship'];
+/*
+ * 트윈 타입 서술(ADR-0018 확장) — 노드 키는 WMS_NODE_TYPES 단일 출처에서 파생 + 무버 타입 추가.
+ * WMS=EPCIS 도메인: 로케이션=bizLocation(SGLN), 무버(지게차)=추적 오브젝트/자산(GIAI). 능력은 씬 소유라 미포함.
+ */
+// label 은 언어 중립 i18n 키(twin.type.<key>) — 사람 언어는 표현계층이 렌더(design/plans/i18n.md L2).
+export const WMS_TYPES = [
+    ...WMS_NODE_TYPES.map((k) => ({ key: k, role: 'node', label: `twin.type.${k}`, standardClass: { epcis: 'bizLocation' }, identity: { scheme: 'gs1:SGLN' }, capabilities: ['storable'] })),
+    { key: 'forklift', role: 'mover', label: 'twin.type.forklift', standardClass: { epcis: 'object', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['mobile', 'operable'] }
+];

package/dist/yms-profile.d.ts

@@ -1,3 +1,4 @@
+import type { TwinTypeInfo } from './domain-catalog.ts';
 export declare const YARD_BIZSTEP: {
     readonly arriving: "urn:epcglobal:cbv:bizstep:arriving";
     readonly staging: "urn:epcglobal:cbv:bizstep:staging";
@@ -11,3 +12,4 @@ export declare const BTT_DELIVERY = "urn:epcglobal:cbv:btt:deliv";
 export declare function graiUri(companyPrefix: string, assetType: string, serial: number): string;
 /** YMS 노드 타입 카탈로그 — 커널이 키로 쓰는 야드 로케이션 타입(nodeByType/slotViews/.type). 도메인 SSOT. */
 export declare const YMS_NODE_TYPES: readonly ["gate", "yard-slot", "dock-door", "staging"];
+export declare const YMS_TYPES: TwinTypeInfo[];

package/dist/yms-profile.js

@@ -1,11 +1,3 @@
-/*
- * 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', // 게이트-인
@@ -22,3 +14,11 @@ export function graiUri(companyPrefix, assetType, serial) {
 }
 /** YMS 노드 타입 카탈로그 — 커널이 키로 쓰는 야드 로케이션 타입(nodeByType/slotViews/.type). 도메인 SSOT. */
 export const YMS_NODE_TYPES = ['gate', 'yard-slot', 'dock-door', 'staging'];
+/*
+ * 트윈 타입 서술(ADR-0018 확장) — 노드 키는 YMS_NODE_TYPES 단일 출처에서 파생 + 무버 타입 추가.
+ * YMS=EPCIS zone: 로케이션/존=bizLocation(SGLN), 무버(야드 트랙터)=오브젝트/자산(GIAI).
+ */
+export const YMS_TYPES = [
+    ...YMS_NODE_TYPES.map((k) => ({ key: k, role: 'node', label: `twin.type.${k}`, standardClass: { epcis: 'bizLocation' }, identity: { scheme: 'gs1:SGLN' }, capabilities: ['storable'] })),
+    { key: 'hostler', role: 'mover', label: 'twin.type.hostler', standardClass: { epcis: 'object', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['mobile', 'operable'] }
+];