@operato/twin-kernel 0.2.1 → 0.2.2

package/dist/contract.d.ts

@@ -223,6 +223,18 @@ export interface OrderState {
     status: string;
     progress?: number;
     held?: boolean;
+    /**
+     * 요청·이행 수량과 라인 — **진척(progress)으로 압축하지 않는다.**
+     *
+     * 예전에는 상태가 `progress` 하나만 들고 있어서, 미러에서 예측을 세우려면 **저널을 따로 읽어**
+     * 오더 원값을 되찾아야 했다(`buildForecastKernel`). 남은 데맨드(라인별 requested − fulfilled)를
+     * 모르면 "무엇을 얼마나 더 내보내야 하나" 를 재계획할 수 없기 때문이다.
+     *
+     * 진척은 이 둘에서 나오는 파생값이다 — 파생을 남기고 원본을 버린 것이 잘못이었다.
+     */
+    requested?: number;
+    fulfilled?: number;
+    lines?: ObservedOrderLine[];
 }
 export type AttentionSeverity = 'low' | 'medium' | 'high' | 'critical';
 export type AttentionState = 'active' | 'acknowledged' | 'cleared';
@@ -410,6 +422,11 @@ export interface TaskStatusDelta {
     personnel?: string[];
     /** 투입된 물리 자산(팔레트 등). */
     assets?: string[];
+    /**
+     * 투입된 설비 전부 — `resourceRef` 는 그중 **대표**(첫 번째)다.
+     * 대표만 두면 "크레인 + 스프레더" 처럼 함께 잡히는 설비가 상태에서 사라진다.
+     */
+    resources?: string[];
     orderId?: string;
     kind: string;
     status: TaskStatus;

package/dist/domain-definition.d.ts

@@ -126,6 +126,19 @@ export interface OperationDef {
         assetClass?: string;
         quantity: number;
     }[];
+    /**
+     * 필요 설비 — **ISA-95 `OperationsSegment.EquipmentSpecification`**(`EquipmentClassID` + `Quantity`).
+     *
+     * 예전에는 작업 하나에 설비 **한 대**만 붙었다(`resourceType` 하나). 그래서 "크레인 1대 + 스프레더
+     * 1대", "용접 로봇 2대가 함께" 같은 현장을 표현할 수 없었고, 그 동시 점유가 만드는 줄이 예측에서
+     * 사라졌다. 인원·자산과 **같은 규칙**으로 요구한다: 등급 + 대수, 부분 확보 없이 전량 아니면 대기.
+     *
+     * 미지정이면 기존 거동(`resourceType` 한 대, 없으면 아무 유휴 설비).
+     */
+    equipmentSpecification?: {
+        equipmentClass?: string;
+        quantity: number;
+    }[];
 }
 /** 라우트(오퍼레이션 시퀀스) — ISA-95 ProcessSegment 연결. */
 export interface RouteDef {

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { Attention, BoardDef, CanonicalEnvelope, Command, CommandAck, EventHandler, MoverMotion, OeeMetrics, AssetState, GeneratorSpec, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, NodeState, ItemState, MoverState, OrderStatusDelta, TaskState } from './contract.ts';
+import type { Attention, BoardDef, CanonicalEnvelope, Command, CommandAck, EventHandler, MoverMotion, OeeMetrics, AssetState, GeneratorSpec, OrderState, PersonState, ScenarioControl, StateSnapshot, TwinKernel, Unsubscribe, NodeState, ItemState, MoverState, OrderStatusDelta, TaskState } from './contract.ts';
 import type { EpcisEvent, BizTransactionElement } from './epcis.ts';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
@@ -95,6 +95,8 @@ export interface FlowTask {
     personnel?: string[];
     /** 이 작업에 투입된 물리 자산(팔레트 등). */
     assets?: string[];
+    /** 이 작업에 투입된 설비 전부 — `resource` 는 그중 대표(첫 번째). */
+    resources?: string[];
     remainingMs: number;
     durationMs: number;
     orderId?: string;
@@ -255,6 +257,7 @@ export declare abstract class FlowEngine implements TwinKernel {
         persons?: PersonState[];
         assets?: AssetState[];
         tasks?: TaskState[];
+        orders?: OrderState[];
     }, orders?: OrderStatusDelta[]): void;
     /** what-if 구성 변주 — 노드 용량 변경(fork 대상). 존재하면 true. */
     setNodeCapacity(nodeId: string, capacity: number): boolean;
@@ -459,6 +462,7 @@ export declare abstract class FlowEngine implements TwinKernel {
     /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
      *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
     protected emitMover(m: FlowMover, motion?: MoverMotion): void;
+    /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
     protected emitOrder(o: FlowOrder): void;
     /**
      * 자극 간격 — **계약이 선언한 네 분포를 실제로 판정한다.**
@@ -507,6 +511,12 @@ export declare abstract class FlowEngine implements TwinKernel {
      * (반쯤 잡고 실패하면 사람이 아무 일도 못 하면서 묶인다).
      */
     private claimPersonnel;
+    /**
+     * 필요 설비를 고른다 — **인원·자산과 같은 규칙**(등급으로 요구, 부분 확보 없이 전량 아니면 대기).
+     * 명세(`equipmentSpecification`)가 없으면 기존 거동: `resourceType` 한 대(없으면 아무 유휴 설비).
+     * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
+     */
+    private claimEquipment;
     /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
     private assignCrew;
     /** 작업이 끝나면 사람을 놓아 준다 — 설비 해제와 별개 경로. */

package/dist/flow-engine.js

@@ -288,7 +288,14 @@ export class FlowEngine {
                 }
             }
         }
-        for (const o of orders) {
+        /* 오더 원값은 이제 **스냅샷에 있다** — 따로 넘겨받은 것이 없으면 스냅샷에서 읽는다.
+         * (예전에는 상태가 progress 로 압축돼 호출부가 저널을 뒤져 원값을 넘겨야 했다.) */
+        const observedOrders = orders.length
+            ? orders
+            : (snap.orders ?? [])
+                .filter(o => o.requested !== undefined)
+                .map(o => ({ orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled ?? 0, held: o.held, lines: o.lines }));
+        for (const o of observedOrders) {
             const lines = (o.lines ?? []).map(l => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter(l => l.requested > 0);
             const remaining = lines.reduce((s, l) => s + l.requested, 0);
             if (remaining <= 0)
@@ -491,9 +498,16 @@ export class FlowEngine {
                 ...(t.durationMs ? { durationMs: t.durationMs } : {}),
                 ...(t.status === 'in-progress' ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: this.progressOf(t) } : {}),
                 ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
-                ...(t.assets?.length ? { assets: t.assets.slice() } : {})
+                ...(t.assets?.length ? { assets: t.assets.slice() } : {}),
+                ...(t.resources?.length ? { resources: t.resources.slice() } : {})
+            })),
+            orders: [...this.orders.values()].map(o => ({
+                id: o.id, kind: o.kind, status: o.status,
+                progress: o.requested ? o.fulfilled / o.requested : 0,
+                requested: o.requested, fulfilled: o.fulfilled,
+                ...(o.lines?.length ? { lines: o.lines.map(l => ({ gtin: l.gtin, requested: l.requested })) } : {}),
+                held: o.held
             })),
-            orders: [...this.orders.values()].map(o => ({ id: o.id, kind: o.kind, status: o.status, progress: o.requested ? o.fulfilled / o.requested : 0, held: o.held })),
             attentions: this.computeAttentions()
         };
     }
@@ -932,6 +946,7 @@ export class FlowEngine {
             intent: t.intent,
             ...(t.personnel?.length ? { personnel: t.personnel.slice() } : {}),
             ...(t.assets?.length ? { assets: t.assets.slice() } : {}),
+            ...(t.resources?.length ? { resources: t.resources.slice() } : {}),
             ...(t.durationMs ? { durationMs: t.durationMs } : {}),
             ...(inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : undefined } : {})
         });
@@ -948,7 +963,13 @@ export class FlowEngine {
     emitMover(m, motion) {
         this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? undefined, motion });
     }
-    emitOrder(o) { this.emitOp(OP_EVENT.order, { orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held }); }
+    /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
+    emitOrder(o) {
+        this.emitOp(OP_EVENT.order, {
+            orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held,
+            ...(o.lines?.length ? { lines: o.lines.map(l => ({ gtin: l.gtin, requested: l.requested })) } : {})
+        });
+    }
     // ── 내부 mechanics ─────────────────────────────────────────────────────────
     /**
      * 자극 간격 — **계약이 선언한 네 분포를 실제로 판정한다.**
@@ -1097,6 +1118,31 @@ export class FlowEngine {
         }
         return picked;
     }
+    /**
+     * 필요 설비를 고른다 — **인원·자산과 같은 규칙**(등급으로 요구, 부분 확보 없이 전량 아니면 대기).
+     * 명세(`equipmentSpecification`)가 없으면 기존 거동: `resourceType` 한 대(없으면 아무 유휴 설비).
+     * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
+     */
+    claimEquipment(t) {
+        const free = (kind, picked = []) => [...this.movers.values()].filter(m => m.status === 'idle' && !m.held && !this.offShift(m) && !picked.includes(m.id) && (kind === undefined || m.kind === kind));
+        const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
+        if (!need?.length) {
+            const one = free(t.resourceType)[0];
+            return one ? [one.id] : null;
+        }
+        const picked = [];
+        for (const req of need) {
+            const want = Math.max(0, Math.floor(req.quantity ?? 0));
+            if (!want)
+                continue;
+            const avail = free(req.equipmentClass, picked);
+            if (avail.length < want)
+                return null; // 한 등급이라도 모자라면 시작하지 않는다
+            for (let i = 0; i < want; i++)
+                picked.push(avail[i].id);
+        }
+        return picked.length ? picked : null;
+    }
     /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
     assignCrew(t, crew) {
         if (!crew.length)
@@ -1305,10 +1351,12 @@ export class FlowEngine {
              * 이 제약이 없으면 대기가 생기지 않아 병목이 사라지고 예측이 낙관 쪽으로 치우친다. */
             if (this.stationFull(t.toNode))
                 continue;
-            // resourceType 있으면 그 kind 무버만; 없으면 아무 유휴 무버. 교대 밖 자원은 배정하지 않는다.
-            const mover = [...this.movers.values()].find(m => m.status === 'idle' && !m.held && !this.offShift(m) && (t.resourceType === undefined || m.kind === t.resourceType));
-            if (!mover)
-                continue; // 맞는 유휴 자원 없음 → 다음 task(break 아님: 다른 타입은 가용할 수 있음)
+            /* 필요 설비 — 명세가 있으면 등급별 대수만큼(부분 확보 없이), 없으면 기존대로 한 대.
+             * 확보 실패는 `null` — 다음 작업으로 넘어간다(다른 타입은 가용할 수 있다). */
+            const rigs = this.claimEquipment(t);
+            if (!rigs)
+                continue;
+            const mover = this.movers.get(rigs[0]);
             // 체인지오버: task 의 changeoverKey 가 무버 직전 키와 다르면 셋업 부착(첫 작업은 셋업 없음).
             if (t.setupMs && t.changeoverKey !== undefined && mover.lastChangeoverKey !== undefined && mover.lastChangeoverKey !== t.changeoverKey) {
                 t.appliedSetupMs = t.setupMs;
@@ -1316,12 +1364,17 @@ export class FlowEngine {
             }
             if (t.changeoverKey !== undefined)
                 mover.lastChangeoverKey = t.changeoverKey;
-            mover.status = 'busy';
-            mover.taskId = t.id;
+            for (const id of rigs) {
+                const m = this.movers.get(id);
+                m.status = 'busy';
+                m.taskId = t.id;
+            }
             t.status = 'in-progress';
             t.resource = mover.id;
             t.remainingMs = t.durationMs;
             t.startedAtSimMs = this.clockMs;
+            if (rigs.length > 1)
+                t.resources = rigs.slice(); // 대표만으로는 함께 잡힌 설비가 사라진다
             this.assignCrew(t, crew);
             this.assignAssets(t, gear);
             this.emitTask(t);
@@ -1359,6 +1412,21 @@ export class FlowEngine {
             mover.taskId = null;
             if (t.intent !== 'process')
                 mover.location = t.toNode; // 운반만 위치 이동; process 는 제자리
+            /* 함께 잡힌 설비도 같은 규칙으로 놓아 준다 — 대표만 풀면 나머지가 영원히 묶인다. */
+            for (const id of t.resources ?? []) {
+                if (id === mover.id)
+                    continue;
+                const m = this.movers.get(id);
+                if (!m)
+                    continue;
+                m.setupMs += setup;
+                m.runMs += t.durationMs - setup;
+                m.status = 'idle';
+                m.taskId = null;
+                if (t.intent !== 'process')
+                    m.location = t.toNode;
+                this.emitMover(m);
+            }
             this.emitTask(t);
             this.emitMover(mover);
         }

package/dist/observed-reducer.js

@@ -148,7 +148,8 @@ export class ObservedReducer {
                     intent: d.intent, progress: d.progress, remainingMs: d.remainingMs, durationMs: d.durationMs,
                     startedAtSimMs: d.startedAtSimMs,
                     ...(d.personnel?.length ? { personnel: d.personnel.slice() } : {}),
-                    ...(d.assets?.length ? { assets: d.assets.slice() } : {})
+                    ...(d.assets?.length ? { assets: d.assets.slice() } : {}),
+                    ...(d.resources?.length ? { resources: d.resources.slice() } : {})
                 });
                 break;
             }
@@ -197,7 +198,16 @@ export class ObservedReducer {
                 const d = e.data;
                 if (this.stale(`order:${d.orderId}`, e))
                     return;
-                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 });
+                /* **진척으로 압축하지 않는다.** 예전에는 progress 만 남겨서, 미러에서 예측을 세우려면 저널을
+                 * 따로 읽어 오더 원값을 되찾아야 했다. 진척은 요청·이행에서 나오는 파생이다 — 파생을 남기고
+                 * 원본을 버리면 남은 데맨드를 재계획할 수 없다. */
+                this.orders.set(d.orderId, {
+                    id: d.orderId, kind: d.kind, status: d.status,
+                    progress: d.requested ? d.fulfilled / d.requested : 0,
+                    requested: d.requested, fulfilled: d.fulfilled,
+                    ...(d.lines?.length ? { lines: d.lines.map(l => ({ ...l })) } : {}),
+                    held: d.held
+                });
                 break;
             }
             // 알 수 없는 eventType 은 무시(전방 호환).

package/dist-cjs/index.cjs

@@ -639,7 +639,8 @@ var ObservedReducer = class {
           durationMs: d.durationMs,
           startedAtSimMs: d.startedAtSimMs,
           ...d.personnel?.length ? { personnel: d.personnel.slice() } : {},
-          ...d.assets?.length ? { assets: d.assets.slice() } : {}
+          ...d.assets?.length ? { assets: d.assets.slice() } : {},
+          ...d.resources?.length ? { resources: d.resources.slice() } : {}
         });
         break;
       }
@@ -681,7 +682,16 @@ var ObservedReducer = class {
       case OP_EVENT.order: {
         const d = e.data;
         if (this.stale(`order:${d.orderId}`, e)) return;
-        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 });
+        this.orders.set(d.orderId, {
+          id: d.orderId,
+          kind: d.kind,
+          status: d.status,
+          progress: d.requested ? d.fulfilled / d.requested : 0,
+          requested: d.requested,
+          fulfilled: d.fulfilled,
+          ...d.lines?.length ? { lines: d.lines.map((l) => ({ ...l })) } : {},
+          held: d.held
+        });
         break;
       }
     }
@@ -1448,7 +1458,8 @@ var FlowEngine = class {
         }
       }
     }
-    for (const o of orders) {
+    const observedOrders = orders.length ? orders : (snap.orders ?? []).filter((o) => o.requested !== void 0).map((o) => ({ orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled ?? 0, held: o.held, lines: o.lines }));
+    for (const o of observedOrders) {
       const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
       const remaining = lines.reduce((s, l) => s + l.requested, 0);
       if (remaining <= 0) continue;
@@ -1644,9 +1655,19 @@ var FlowEngine = class {
         ...t.durationMs ? { durationMs: t.durationMs } : {},
         ...t.status === "in-progress" ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: this.progressOf(t) } : {},
         ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
-        ...t.assets?.length ? { assets: t.assets.slice() } : {}
+        ...t.assets?.length ? { assets: t.assets.slice() } : {},
+        ...t.resources?.length ? { resources: t.resources.slice() } : {}
+      })),
+      orders: [...this.orders.values()].map((o) => ({
+        id: o.id,
+        kind: o.kind,
+        status: o.status,
+        progress: o.requested ? o.fulfilled / o.requested : 0,
+        requested: o.requested,
+        fulfilled: o.fulfilled,
+        ...o.lines?.length ? { lines: o.lines.map((l) => ({ gtin: l.gtin, requested: l.requested })) } : {},
+        held: o.held
       })),
-      orders: [...this.orders.values()].map((o) => ({ id: o.id, kind: o.kind, status: o.status, progress: o.requested ? o.fulfilled / o.requested : 0, held: o.held })),
       attentions: this.computeAttentions()
     };
   }
@@ -2040,6 +2061,7 @@ var FlowEngine = class {
       intent: t.intent,
       ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
       ...t.assets?.length ? { assets: t.assets.slice() } : {},
+      ...t.resources?.length ? { resources: t.resources.slice() } : {},
       ...t.durationMs ? { durationMs: t.durationMs } : {},
       ...inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : void 0 } : {}
     });
@@ -2056,8 +2078,17 @@ var FlowEngine = class {
   emitMover(m, motion) {
     this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? void 0, motion });
   }
+  /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
-    this.emitOp(OP_EVENT.order, { orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held });
+    this.emitOp(OP_EVENT.order, {
+      orderId: o.id,
+      kind: o.kind,
+      status: o.status,
+      requested: o.requested,
+      fulfilled: o.fulfilled,
+      held: o.held,
+      ...o.lines?.length ? { lines: o.lines.map((l) => ({ gtin: l.gtin, requested: l.requested })) } : {}
+    });
   }
   // ── 내부 mechanics ─────────────────────────────────────────────────────────
   /**
@@ -2189,6 +2220,30 @@ var FlowEngine = class {
     }
     return picked;
   }
+  /**
+   * 필요 설비를 고른다 — **인원·자산과 같은 규칙**(등급으로 요구, 부분 확보 없이 전량 아니면 대기).
+   * 명세(`equipmentSpecification`)가 없으면 기존 거동: `resourceType` 한 대(없으면 아무 유휴 설비).
+   * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
+   */
+  claimEquipment(t) {
+    const free = (kind, picked2 = []) => [...this.movers.values()].filter(
+      (m) => m.status === "idle" && !m.held && !this.offShift(m) && !picked2.includes(m.id) && (kind === void 0 || m.kind === kind)
+    );
+    const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
+    if (!need?.length) {
+      const one = free(t.resourceType)[0];
+      return one ? [one.id] : null;
+    }
+    const picked = [];
+    for (const req of need) {
+      const want = Math.max(0, Math.floor(req.quantity ?? 0));
+      if (!want) continue;
+      const avail = free(req.equipmentClass, picked);
+      if (avail.length < want) return null;
+      for (let i = 0; i < want; i++) picked.push(avail[i].id);
+    }
+    return picked.length ? picked : null;
+  }
   /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
   assignCrew(t, crew) {
     if (!crew.length) return;
@@ -2365,21 +2420,24 @@ var FlowEngine = class {
         continue;
       }
       if (this.stationFull(t.toNode)) continue;
-      const mover = [...this.movers.values()].find(
-        (m) => m.status === "idle" && !m.held && !this.offShift(m) && (t.resourceType === void 0 || m.kind === t.resourceType)
-      );
-      if (!mover) continue;
+      const rigs = this.claimEquipment(t);
+      if (!rigs) continue;
+      const mover = this.movers.get(rigs[0]);
       if (t.setupMs && t.changeoverKey !== void 0 && mover.lastChangeoverKey !== void 0 && mover.lastChangeoverKey !== t.changeoverKey) {
         t.appliedSetupMs = t.setupMs;
         t.durationMs += t.setupMs;
       }
       if (t.changeoverKey !== void 0) mover.lastChangeoverKey = t.changeoverKey;
-      mover.status = "busy";
-      mover.taskId = t.id;
+      for (const id of rigs) {
+        const m = this.movers.get(id);
+        m.status = "busy";
+        m.taskId = t.id;
+      }
       t.status = "in-progress";
       t.resource = mover.id;
       t.remainingMs = t.durationMs;
       t.startedAtSimMs = this.clockMs;
+      if (rigs.length > 1) t.resources = rigs.slice();
       this.assignCrew(t, crew);
       this.assignAssets(t, gear);
       this.emitTask(t);
@@ -2409,6 +2467,17 @@ var FlowEngine = class {
       mover.status = "idle";
       mover.taskId = null;
       if (t.intent !== "process") mover.location = t.toNode;
+      for (const id of t.resources ?? []) {
+        if (id === mover.id) continue;
+        const m = this.movers.get(id);
+        if (!m) continue;
+        m.setupMs += setup;
+        m.runMs += t.durationMs - setup;
+        m.status = "idle";
+        m.taskId = null;
+        if (t.intent !== "process") m.location = t.toNode;
+        this.emitMover(m);
+      }
       this.emitTask(t);
       this.emitMover(mover);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {