@operato/twin-kernel 0.2.3 → 0.3.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

@@ -24,3 +24,4 @@ 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

@@ -23,3 +23,4 @@ export * from "./flow-engine.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/kernel.js

@@ -21,7 +21,7 @@ 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
@@ -104,7 +104,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 +114,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) {
@@ -141,8 +141,8 @@ 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 from = this.locations.get(t.fromNode);
+        const to = this.locations.get(t.toNode);
         from.occupancy--;
         to.occupancy++;
         item.location = to.id;
@@ -163,7 +163,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.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;
@@ -73,7 +73,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 +81,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 +91,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);
@@ -119,7 +119,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 +127,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,8 +144,8 @@ 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);
     }
@@ -156,13 +156,13 @@ export class MesKernel extends FlowEngine {
         const order = this.orders.get(t.orderId);
         const product = this.productOf(order.gtin);
         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 +171,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;
@@ -204,7 +204,7 @@ 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);
@@ -228,14 +228,14 @@ export class MesKernel extends FlowEngine {
     /** 정의 모드 할당 — 레시피 입력 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,8 +251,8 @@ 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);
     }
@@ -262,14 +262,14 @@ export class MesKernel extends FlowEngine {
         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 +277,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[];

package/dist/mes-profile.js

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

package/dist/observed-reducer.d.ts

@@ -1,4 +1,4 @@
-import type { AssetState, BoardDef, CanonicalEnvelope, NodeState, ItemState, MoverState, PersonState, TaskState, OrderState } from './contract.ts';
+import type { AssetState, BoardDef, CanonicalEnvelope, LocationState, ItemState, EquipmentState, PersonState, TaskState, OrderState } from './contract.ts';
 /**
  * 마스터 동기 — 선언적 로케이션 upsert/remove.
  *
@@ -8,7 +8,7 @@ import type { AssetState, BoardDef, CanonicalEnvelope, NodeState, ItemState, Mov
  */
 export interface MasterUpdate {
     op: 'upsert' | 'remove';
-    node: {
+    location: {
         id: string;
         type?: string;
         capacity?: number;
@@ -28,14 +28,14 @@ export interface ProjectedState {
         correctiveEventIDs: string[];
         eventID?: string;
     }[];
-    nodes: NodeState[];
+    locations: LocationState[];
     items: ItemState[];
     /** 사람 — 등급·교대·투입. 인원을 선언하지 않은 트윈에서는 빈 배열. */
     persons: PersonState[];
     /** 물리 자산(반복사용) — 자산을 선언하지 않은 트윈에서는 빈 배열. */
     assets: AssetState[];
     tasks: TaskState[];
-    movers: MoverState[];
+    equipment: EquipmentState[];
     orders: OrderState[];
 }
 export declare class ObservedReducer {
@@ -46,7 +46,7 @@ export declare class ObservedReducer {
     /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
     private pendingParent;
     private tasks;
-    private movers;
+    private equipment;
     private persons;
     private assets;
     private orders;
@@ -59,7 +59,7 @@ export declare class ObservedReducer {
     /**
      * 관측된 로케이션을 구조로 승격 — **이벤트가 가르쳐 준 것을 구조에서 지우지 않는다.**
      *
-     * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `nodes` 에는
+     * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `locations` 에는
      * 나타나지 않았다. 그 결과 그 자리는 스키매틱에 없고, 점유가 집계되지 않고, 병목 주목이 뜰 수
      * 없었다 — **사실은 들어왔는데 구조가 모르는 상태.** 이제 최소 형태로 승격한다:
      * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
@@ -98,6 +98,6 @@ export declare class ObservedReducer {
     private mergeItem;
     /** 이탈(DELETE) — 아이템 + 조립 자식(재귀) 제거. 화물 SSCC DELETE 시 팔레트도 함께 이탈. */
     private remove;
-    /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+    /** 현재 투영 State — 자리 점유는 아이템 위치 집계로 유도(pure projection). */
     snapshot(): ProjectedState;
 }

package/dist/observed-reducer.js

@@ -16,10 +16,10 @@
  *
  * 두 갈래 이벤트를 함께 접는다:
  *  - EPCIS(epcis.*)      → 재고/위치/조립 (What/Where)
- *  - 운영 델타(task/equipment/order.status) → tasks·movers·orders (EPCIS 로 재구성 불가한 절반)
+ *  - 운영 델타(task/equipment/order.status) → tasks·equipment·orders (EPCIS 로 재구성 불가한 절반)
  * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
  */
-import { OP_EVENT, nodeStatusOf } from "./contract.js";
+import { OP_EVENT, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets } from "./contract.js";
 import { ILMD_ATTR, parseEpc } from "./epcis.js";
 /**
  * 투영이 들고 있는 물품 — **계약(ItemState)을 축소하지 않는다.**
@@ -39,7 +39,7 @@ export class ObservedReducer {
     /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
     pendingParent = new Map(); // 자식 EPC → 부모(물류단위)
     tasks = new Map();
-    movers = new Map();
+    equipment = new Map();
     persons = new Map();
     assets = new Map();
     orders = new Map();
@@ -47,36 +47,36 @@ export class ObservedReducer {
     /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
     corrections = [];
     constructor(board) {
-        for (const n of board.nodes)
+        for (const n of readBoardLocations(board))
             this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: 'master' });
-        // 무버 기준선(마스터) — equipment.status 델타로 갱신됨.
-        for (const m of board.movers)
-            this.movers.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeNode, origin: 'master' });
+        // 설비 기준선(마스터) — equipment.status 델타로 갱신됨.
+        for (const m of readBoardEquipment(board))
+            this.equipment.set(m.id, { id: m.id, kind: m.kind, status: 'idle', location: m.homeLocation, homeLocation: m.homeLocation, ...(m.properties ? { properties: m.properties } : {}), ...(m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}), origin: 'master' });
         // 사람 기준선(마스터) — person.status 델타로 갱신됨.
         for (const p of board.persons ?? [])
-            this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: 'idle' });
-        for (const a of board.assets ?? [])
-            this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: 'idle' });
+            this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: 'idle', ...(p.homeLocation ? { location: p.homeLocation } : {}), ...(p.properties ? { properties: p.properties } : {}), ...(p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}) });
+        for (const a of readBoardAssets(board))
+            this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: 'idle', ...(a.properties ? { properties: a.properties } : {}), ...(a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}) });
     }
     /** 마스터 동기 — 로케이션 추가/변경/제거. */
     applyMaster(u) {
         if (u.op === 'remove') {
-            this.master.delete(u.node.id);
+            this.master.delete(u.location.id);
             return;
         }
-        const cur = this.master.get(u.node.id);
+        const cur = this.master.get(u.location.id);
         /* **모르는 용량을 0 으로 뭉개지 않는다.** 0 은 "자리가 없다" 는 사실 주장이고, 미지정은 "모른다" 다.
-         * 계약(`NodeState.capacity`)이 선택 필드로 둔 이유가 이것이며, 0 으로 채우면 포화 판정이 거짓으로
-         * 성립하고 배정 정책이 그 노드를 영구히 배제한다. 그리고 upsert 가 **구역 소속(parentId)을 지우지
+         * 계약(`LocationState.capacity`)이 선택 필드로 둔 이유가 이것이며, 0 으로 채우면 포화 판정이 거짓으로
+         * 성립하고 배정 정책이 그 자리를 영구히 배제한다. 그리고 upsert 가 **구역 소속(parentId)을 지우지
          * 않는다** — 마스터가 말하지 않은 것은 기존 값을 지키는 것이 upsert 의 뜻이다. */
-        const capacity = u.node.capacity ?? cur?.capacity;
-        const parallelism = u.node.parallelism ?? cur?.parallelism;
-        this.master.set(u.node.id, {
-            id: u.node.id,
-            type: u.node.type ?? cur?.type ?? UNKNOWN_TYPE,
+        const capacity = u.location.capacity ?? cur?.capacity;
+        const parallelism = u.location.parallelism ?? cur?.parallelism;
+        this.master.set(u.location.id, {
+            id: u.location.id,
+            type: u.location.type ?? cur?.type ?? UNKNOWN_TYPE,
             ...(capacity === undefined ? {} : { capacity }),
             ...(parallelism === undefined ? {} : { parallelism }),
-            ...(u.node.parentId ?? cur?.parentId ? { parentId: u.node.parentId ?? cur?.parentId } : {}),
+            ...(u.location.parentId ?? cur?.parentId ? { parentId: u.location.parentId ?? cur?.parentId } : {}),
             /* 마스터가 말한 것은 마스터 출처다 — 관측으로 알게 된 것(origin='observed')을 덮어 승격한다. */
             origin: 'master'
         });
@@ -84,7 +84,7 @@ export class ObservedReducer {
     /**
      * 관측된 로케이션을 구조로 승격 — **이벤트가 가르쳐 준 것을 구조에서 지우지 않는다.**
      *
-     * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `nodes` 에는
+     * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `locations` 에는
      * 나타나지 않았다. 그 결과 그 자리는 스키매틱에 없고, 점유가 집계되지 않고, 병목 주목이 뜰 수
      * 없었다 — **사실은 들어왔는데 구조가 모르는 상태.** 이제 최소 형태로 승격한다:
      * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
@@ -155,13 +155,17 @@ export class ObservedReducer {
             }
             case OP_EVENT.equipment: {
                 const d = e.data;
-                if (this.stale(`mover:${d.moverId}`, e))
+                if (this.stale(`eq:${d.moverId}`, e))
                     return;
                 /* 마스터에 없던 자원도 관측으로 자란다(예전부터 그랬다) — 이제 그 사실을 출처로 표시하고,
                  * 자원이 있다고 말하는 자리도 구조로 승격한다(로케이션만 자라지 않던 비대칭 해소). */
                 this.touchLocation(d.location);
-                const known = this.movers.get(d.moverId);
-                this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? 'observed' });
+                const known = this.equipment.get(d.moverId);
+                /* 소속(homeLocation)은 델타가 말해 주면 그 값, 안 말해 주면 **이미 아는 값을 지킨다** —
+                   마스터로 알던 소속을 관측 델타 하나가 지워 버리면 그 설비가 롤업에서 통째로 빠진다.
+                   소속은 자주 바뀌는 사실이 아니므로 침묵을 "소속 없음" 으로 읽지 않는다. */
+                const homeLocation = d.homeLocation ?? known?.homeLocation;
+                this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...(homeLocation ? { homeLocation } : {}), taskId: d.taskId, motion: d.motion, origin: known?.origin ?? 'observed' });
                 break;
             }
             case OP_EVENT.person: {
@@ -169,11 +173,17 @@ export class ObservedReducer {
                 if (this.stale(`person:${d.personId}`, e))
                     return;
                 /* 사람도 관측으로 자란다(자원과 같은 정책) — 마스터에 없던 사람이 이벤트에 나오면 승격한다. */
+                const known = this.persons.get(d.personId);
+                /* 마스터로 알던 사실(등급·위치·속성)은 델타가 말하지 않으면 **지키지 않고 지우면** 안 된다 —
+                   설비 소속과 같은 규율이다(침묵을 "없어졌다" 로 읽지 않는다). */
                 this.persons.set(d.personId, {
                     id: d.personId,
-                    personnelClass: d.personnelClass ?? this.persons.get(d.personId)?.personnelClass,
+                    personnelClassIds: d.personnelClassIds ?? known?.personnelClassIds,
                     status: d.status,
                     taskId: d.taskId,
+                    ...((d.location ?? known?.location) ? { location: d.location ?? known?.location } : {}),
+                    ...(known?.properties ? { properties: known.properties } : {}),
+                    ...(known?.testSpecificationIds ? { testSpecificationIds: known.testSpecificationIds } : {}),
                     ...(d.offShift ? { offShift: true } : {})
                 });
                 break;
@@ -185,7 +195,7 @@ export class ObservedReducer {
                 const cur = this.assets.get(d.assetId);
                 this.assets.set(d.assetId, {
                     id: d.assetId,
-                    assetClass: d.assetClass ?? cur?.assetClass,
+                    assetClassIds: d.assetClassIds ?? cur?.assetClassIds,
                     location: d.location ?? cur?.location,
                     status: d.status,
                     taskId: d.taskId,
@@ -351,7 +361,7 @@ export class ObservedReducer {
                 this.remove(c);
         }
     }
-    /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+    /** 현재 투영 State — 자리 점유는 아이템 위치 집계로 유도(pure projection). */
     snapshot() {
         const occ = new Map();
         for (const it of this.items.values())
@@ -359,9 +369,9 @@ export class ObservedReducer {
         return {
             revision: this.revision,
             ...(this.corrections.length ? { corrections: this.corrections.map(c => ({ ...c })) } : {}),
-            nodes: [...this.master.values()].map(n => {
+            locations: [...this.master.values()].map(n => {
                 const occupancy = occ.get(n.id) ?? 0;
-                const status = nodeStatusOf({ occupancy, capacity: n.capacity });
+                const status = locationStatusOf({ occupancy, capacity: n.capacity });
                 return {
                     id: n.id, type: n.type, occupancy,
                     ...(status ? { status } : {}),
@@ -377,7 +387,7 @@ export class ObservedReducer {
             persons: [...this.persons.values()].map(p => ({ ...p })),
             assets: [...this.assets.values()].map(a => ({ ...a })),
             tasks: [...this.tasks.values()].map(t => ({ ...t })),
-            movers: [...this.movers.values()].map(m => ({ ...m })),
+            equipment: [...this.equipment.values()].map(m => ({ ...m })),
             orders: [...this.orders.values()].map(o => ({ ...o }))
         };
     }

package/dist/task-fold.d.ts

@@ -15,14 +15,14 @@ export interface TaskDeltaRow {
 }
 /** 작업에 붙어 있는 축의 값 — 어느 전이에서 왔든 모은다. */
 export interface TaskFacets {
-    /** 수행 자원(무버). 설계상 자원을 쓰지 않는 공정(체류)에서는 없는 것이 정상이다. */
+    /** 수행 자원(설비). 설계상 자원을 쓰지 않는 공정(체류)에서는 없는 것이 정상이다. */
     resource?: string;
     /** 작업 종류(커널 어휘 — 사람이 읽는 라벨은 표현 계층의 몫). */
     kind?: string;
     /** 소속 오더. **없으면 없는 것이다** — 다른 식별자로 대체하지 않는다. */
     order?: string;
     /** 가장 최근 도착 지점. 진행에 따라 바뀌므로 마지막 것이 사실이다. */
-    node?: string;
+    location?: string;
 }
 /** 작업 하나의 이정표 — 소비처가 이것으로 구간·지표를 만든다. */
 export interface TaskRecord {

package/dist/task-fold.js

@@ -38,7 +38,7 @@ export function foldTaskRecords(rows) {
             rec = { taskId: id, facets: {} };
             byTask.set(id, rec);
         }
-        /* 축의 값 — 처음 본 것을 남긴다(작업의 종류·오더·자원은 바뀌지 않는다). 노드는 예외로 마지막 것. */
+        /* 축의 값 — 처음 본 것을 남긴다(작업의 종류·오더·자원은 바뀌지 않는다). 자리는 예외로 마지막 것. */
         const f = rec.facets;
         if (f.resource === undefined && d.resourceRef)
             f.resource = d.resourceRef;
@@ -46,9 +46,9 @@ export function foldTaskRecords(rows) {
             f.kind = d.kind;
         if (f.order === undefined && d.orderId)
             f.order = d.orderId;
-        const node = d.toNode ?? d.fromNode;
-        if (node)
-            f.node = node;
+        const loc = d.toNode ?? d.fromNode;
+        if (loc)
+            f.location = loc;
         if (d.status === 'created')
             rec.createdMs = at;
         else if (d.status === 'in-progress')

package/dist/vocabulary.d.ts

@@ -0,0 +1,19 @@
+/** 금지 어휘 — 표준 어휘로 대체된 옛 낱말. 파생 식별자까지 잡도록 부분 일치로 본다. */
+export declare const RETIRED_VOCABULARY: readonly ["mover", "Mover", "MOVER", "node", "Node", "NODE"];
+/**
+ * 예외 — 남아 있는 것이 **정당한** 토큰. 각 항목에 이유가 붙는다.
+ *
+ * 판정은 "이 토큰을 정확히 포함하는가" 다(부분 문자열). 그래서 `moverId` 를 허용하면 `moverIds` 도
+ * 통과한다 — 와이어 필드에서 파생한 변수까지 허용하려는 의도다.
+ */
+export declare const VOCABULARY_EXCEPTIONS: {
+    token: string;
+    why: string;
+}[];
+/**
+ * 한 줄에서 금지 어휘 위반을 찾는다 — 예외에 걸리는 부분은 먼저 지워 놓고 본다.
+ *
+ * 반환은 위반 낱말 목록(중복 제거 전). 비어 있으면 그 줄은 통과.
+ */
+export declare const GUARD_PRAGMA = "vocabulary-guard: allow";
+export declare function retiredVocabularyIn(line: string): string[];