@operato/twin-kernel 0.7.40 → 0.7.42

package/dist/contract.d.ts

@@ -1531,11 +1531,11 @@ export interface CommandAck {
     error?: string;
 }
 /**
- * 호스트-facing 커맨드 채널(비동기) — 씬 컴포넌트 등 클라이언트가 트윈 호스트에 커맨드를 던지는 계약.
+ * 호스트-facing 커맨드 채널(비동기) — 씬 컴포넌트 등 클라이언트가 트윈 호스트에 커맨드를 보내는 계약.
  * 커널 in-process `dispatch`(동기)와 달리 원격 호스트(GraphQL/HTTP/…) 전송을 추상화.
  * 씬 컨트롤 컴포넌트는 이 인터페이스에만 의존(커널 레벨) — concrete 전송은 각 호스트(things-factory 등)가 주입.
  * → 컴포넌트가 특정 호스트 구현(things-factory)에 갇히지 않고, 어디서든 개발/재사용 가능.
- * 컴포넌트는 tenantId 등을 모르는 부분 커맨드를 던지고, 호스트가 보강한다(commandId/type/args 만 제공).
+ * 컴포넌트는 tenantId 등을 모르는 부분 커맨드를 보내고, 호스트가 보강한다(commandId/type/args 만 제공).
  */
 export interface TwinCommandChannel {
     dispatch(command: Pick<Command, 'commandId' | 'type' | 'args'>): Promise<CommandAck>;

package/dist/contract.js

@@ -150,7 +150,7 @@ export function testPassedAt(r, at) {
         return false;
     if (!r.expiresAt || !at)
         return r.result === 'pass';
-    return Date.parse(at) <= Date.parse(r.expiresAt);
+    return parsedMs(at) <= parsedMs(r.expiresAt);
 }
 /**
  * 이 개체가 **요구된 시험들을 만족하나** — 등급이 요구하고 개체가 기록을 든다.
@@ -293,8 +293,8 @@ export function priorityRank(p) {
 export function dueStatusOf(x, nowIso) {
     if (!x.endTime || !nowIso)
         return undefined;
-    const due = Date.parse(x.endTime);
-    const now = Date.parse(nowIso);
+    const due = parsedMs(x.endTime);
+    const now = parsedMs(nowIso);
     if (!Number.isFinite(due) || !Number.isFinite(now))
         return undefined;
     return now > due ? 'late' : 'on-time';
@@ -663,7 +663,7 @@ export function capabilityOf(r, ctx) {
     if (r.status === 'down')
         return { available: false, reason: 'down' };
     if (at) {
-        const ms = Date.parse(at);
+        const ms = parsedMs(at);
         if (Number.isFinite(ms)) {
             const why = offCalendarReasonAt(r, ms, ctx?.utcOffsetMinutes);
             if (why === 'non-working')

package/dist/domain-catalog.d.ts

@@ -225,7 +225,7 @@ export declare const propertiesOf: (axis: string) => TwinPropertyInfo[];
  */
 export declare const axisSource: (axis: string) => "document" | "state" | "journal";
 /**
- * 문서에서 이 축을 찾을 자리 — **문서 축이 아니면 던진다.**
+ * 문서에서 이 축을 찾을 자리 — **문서 축이 아니면 오류를 낸다.**
  *
  * 상태·저널 축에는 board 안의 자리가 없다. 그런데 옛 소비처는 `info.path` 를 무조건 읽었으므로,
  * 그 자리가 `undefined` 면 board 루트를 읽고 **오류 없이 0 을 답한다**(이 프로젝트가 겪은 실패 모양).

package/dist/domain-catalog.js

@@ -202,7 +202,7 @@ export const propertiesOf = (axis) => TWIN_PROPERTIES.filter(p => p.axis === axi
  */
 export const axisSource = (axis) => TWIN_AXES.find(a => a.axis === axis)?.source ?? 'document';
 /**
- * 문서에서 이 축을 찾을 자리 — **문서 축이 아니면 던진다.**
+ * 문서에서 이 축을 찾을 자리 — **문서 축이 아니면 오류를 낸다.**
  *
  * 상태·저널 축에는 board 안의 자리가 없다. 그런데 옛 소비처는 `info.path` 를 무조건 읽었으므로,
  * 그 자리가 `undefined` 면 board 루트를 읽고 **오류 없이 0 을 답한다**(이 프로젝트가 겪은 실패 모양).

package/dist/ems-kernel.js

@@ -621,7 +621,7 @@ export class EmsKernel extends FlowEngine {
      * **아무 일도 하지 않는다** — 그런데 조용히 넘기지 않는다: 이 커널이 그런 요청을 받았다는 것은
      * **배선이 잘못됐다는 사실**이고(EMS 트윈에 물류 명령을 보낸 것), 조용히 넘기면 그 사실이 사라진다.
      *
-     * 던지지도 않는다: 저널 재생 중이라면 트윈 전체가 멈춘다. 그래서 커널이 담을 줄 모르는 사건을
+     * 오류를 내지도 않는다: 저널 재생 중이라면 트윈 전체가 멈춘다. 그래서 커널이 담을 줄 모르는 사건을
      * 세는 자리(`ObservedReducer.unhandled`)와 같은 규율으로, **개수를 세어 상태로 낸다.**
      */
     flowRequests = new Map();

package/dist/face2-adapter.d.ts

@@ -59,7 +59,37 @@ export interface AggregationEventMapping {
     readPoint?: MapValue;
     bizLocation?: MapValue;
 }
-export type EventMapping = ObjectEventMapping | AggregationEventMapping;
+/**
+ * **변환의 사실** — 무엇이 들어가 무엇이 나왔나(EPCIS `TransformationEvent`).
+ *
+ * ── 왜 이 갈래가 필요한가 (2026-08-21) ─────────────────────────────────────
+ * 정규 레코드 계약이 `ObjectEvent`·`AggregationEvent` 둘만 다뤄서, 원본이 「이 로트를 소비해 이 제품을
+ * 만들었다」고 말해도 실을 자리가 없었다. 그 사실이 문 앞에서 사라진다.
+ *
+ * **HACCP 회수 범위 판정이 정확히 이 자리를 요구한다** — 「이 로트가 어느 제품에 들어갔나」다. 로트를
+ * 개체로 식별할 수 없는 현장(연속량·분할 로트)에서는 소비를 `inputQuantityList` 의 **LGTIN 클래스**
+ * (`urn:epc:class:lgtin:<프리픽스>.<품번>.<로트>`)로 말한다 — 표준이 로트 단위 클래스를 그렇게 정한다.
+ *
+ * `action` 이 없다: 표준이 `TransformationEvent` 에 `action` 을 두지 않는다(들어감과 나옴이 곧 뜻이다).
+ */
+export interface TransformationEventMapping {
+    type: 'TransformationEvent';
+    bizStep: MapValue;
+    disposition?: MapValue;
+    /** 소비된 개체들("$.inputEPCList") — 문자열 배열. */
+    inputEPCList?: MapValue;
+    /** 소비된 클래스+수량("$.inputQuantityList") — 로트 단위 소비가 이 자리다. */
+    inputQuantityList?: MapValue;
+    /** 산출된 개체들("$.outputEPCList"). */
+    outputEPCList?: MapValue;
+    /** 산출된 클래스+수량("$.outputQuantityList"). */
+    outputQuantityList?: MapValue;
+    /** 여러 이벤트를 한 변환으로 잇는 식별자("$.transformationID") — 한 오더의 여러 단계가 이것으로 묶인다. */
+    transformationID?: MapValue;
+    readPoint?: MapValue;
+    bizLocation?: MapValue;
+}
+export type EventMapping = ObjectEventMapping | AggregationEventMapping | TransformationEventMapping;
 /**
  * 이 품목 레코드가 **담김의 사실**인가 — 라우팅 판정을 한 곳에 둔다(소비처가 각자 짐작하지 않게).
  *
@@ -67,6 +97,16 @@ export type EventMapping = ObjectEventMapping | AggregationEventMapping;
  * 있으면 담김으로 본다 — 둘 다 있으면 커넥터가 무엇을 말하려는지 알 수 없으므로 담김으로 받지 않는다.
  */
 export declare function isAggregationRecord(record: unknown): boolean;
+/**
+ * 이 레코드가 **변환의 사실**인가 — 라우팅 판정을 한 곳에 둔다(소비처가 각자 짐작하지 않게).
+ *
+ * 변환은 **들어간 것과 나온 것**으로 말한다. 개체 하나의 관측(`epc`)이나 담김(`parentID`)과 섞이지
+ * 않게, 그 둘이 없고 입력·출력 중 하나라도 있으면 변환으로 본다.
+ *
+ * 한쪽만 있는 것도 변환이다 — 표준이 소실(N→0)과 생성(0→N)을 같은 이벤트로 표현한다. 둘 다 없으면
+ * 변환이 아니다(무엇이 바뀌었는지 말하지 않은 것이다).
+ */
+export declare function isTransformationRecord(record: unknown): boolean;
 /** 룰: 소스 레코드의 판별자(sourceType)로 매핑을 고른다. */
 export interface AdapterRule {
     sourceType: string;

package/dist/face2-adapter.js

@@ -8,7 +8,7 @@
  * 매핑 엔진은 walking-skeleton 범위에서 무의존 declarative spec 사용.
  * (jsonata/템플릿 엔진 최종 선택은 열린 결정 — face2-adapters.md. 커널 zero-dep 유지 위해 여기선 미도입.)
  */
-import { aggregationEvent, objectEvent, validateEpcisEvent } from "./epcis.js";
+import { aggregationEvent, objectEvent, transformationEvent, validateEpcisEvent } from "./epcis.js";
 /**
  * 이 품목 레코드가 **담김의 사실**인가 — 라우팅 판정을 한 곳에 둔다(소비처가 각자 짐작하지 않게).
  *
@@ -21,6 +21,24 @@ export function isAggregationRecord(record) {
     const r = record;
     return typeof r.parentID === 'string' && r.parentID.trim().length > 0 && r.epc === undefined;
 }
+/**
+ * 이 레코드가 **변환의 사실**인가 — 라우팅 판정을 한 곳에 둔다(소비처가 각자 짐작하지 않게).
+ *
+ * 변환은 **들어간 것과 나온 것**으로 말한다. 개체 하나의 관측(`epc`)이나 담김(`parentID`)과 섞이지
+ * 않게, 그 둘이 없고 입력·출력 중 하나라도 있으면 변환으로 본다.
+ *
+ * 한쪽만 있는 것도 변환이다 — 표준이 소실(N→0)과 생성(0→N)을 같은 이벤트로 표현한다. 둘 다 없으면
+ * 변환이 아니다(무엇이 바뀌었는지 말하지 않은 것이다).
+ */
+export function isTransformationRecord(record) {
+    if (!record || typeof record !== 'object')
+        return false;
+    const r = record;
+    if (r.epc !== undefined || r.parentID !== undefined)
+        return false;
+    const has = (k) => Array.isArray(r[k]) && r[k].length > 0;
+    return has('inputEPCList') || has('inputQuantityList') || has('outputEPCList') || has('outputQuantityList');
+}
 function get(obj, path) {
     return path.split('.').reduce((o, k) => (o == null ? o : o[k]), obj);
 }
@@ -83,12 +101,38 @@ function resolveQuantityList(v, record, field, errors) {
 /** 단일 레코드 → 정규 EPCIS 이벤트 + 매핑에서 드러난 문제(검증은 `ingest` 가 이어서 한다). */
 export function mapRecordChecked(record, mapping, eventTime) {
     const errors = [];
-    const action = (resolve(mapping.action, record, 'action', errors) ?? '');
     const bizStep = resolve(mapping.bizStep, record, 'bizStep', errors) ?? '';
     const disposition = resolve(mapping.disposition, record, 'disposition', errors);
     const readPoint = resolve(mapping.readPoint, record, 'readPoint', errors);
     const bizLocation = resolve(mapping.bizLocation, record, 'bizLocation', errors);
+    if (mapping.type === 'TransformationEvent') {
+        const inputEPCList = resolveList(mapping.inputEPCList, record, 'inputEPCList', errors);
+        const inputQuantityList = resolveQuantityList(mapping.inputQuantityList, record, 'inputQuantityList', errors);
+        const outputEPCList = resolveList(mapping.outputEPCList, record, 'outputEPCList', errors);
+        const outputQuantityList = resolveQuantityList(mapping.outputQuantityList, record, 'outputQuantityList', errors);
+        const transformationID = resolve(mapping.transformationID, record, 'transformationID', errors);
+        /* 들어간 것도 나온 것도 없으면 무엇이 바뀌었는지 말하지 않은 것이다 — 검증에 넘기기 전에 여기서
+           말해 준다(검증 메시지는 이벤트를 가리키고, 이 메시지는 **매핑**을 가리킨다). */
+        if (!inputEPCList.length && !inputQuantityList.length && !outputEPCList.length && !outputQuantityList.length) {
+            errors.push('입력과 출력이 모두 비었다 — 변환은 들어간 것이나 나온 것 중 하나는 말해야 한다');
+        }
+        return {
+            event: transformationEvent({
+                eventTime, bizStep, disposition,
+                /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「없다」고 말하는 것이 된다.
+                   소실(N→0)과 생성(0→N)은 표준이 인정하는 변환이고, 그때 한쪽이 아예 없는 것이 사실이다. */
+                ...(inputEPCList.length ? { inputEPCList } : {}),
+                ...(inputQuantityList.length ? { inputQuantityList } : {}),
+                ...(outputEPCList.length ? { outputEPCList } : {}),
+                ...(outputQuantityList.length ? { outputQuantityList } : {}),
+                ...(transformationID ? { transformationID } : {}),
+                readPoint, bizLocation
+            }),
+            errors
+        };
+    }
     if (mapping.type === 'AggregationEvent') {
+        const action = (resolve(mapping.action, record, 'action', errors) ?? '');
         const parentID = resolve(mapping.parentID, record, 'parentID', errors) ?? '';
         const childEPCs = resolveList(mapping.childEPCs, record, 'childEPCs', errors);
         const childQuantityList = resolveQuantityList(mapping.childQuantityList, record, 'childQuantityList', errors);
@@ -103,6 +147,7 @@ export function mapRecordChecked(record, mapping, eventTime) {
             errors
         };
     }
+    const action = (resolve(mapping.action, record, 'action', errors) ?? '');
     const epc = resolve(mapping.epc, record, 'epc', errors);
     const quantityList = resolveQuantityList(mapping.quantityList, record, 'quantityList', errors);
     /* 개체도 수량도 없으면 무엇을 관측했는지 말하지 않은 것이다 — 검증에 넘기기 전에 여기서 말해 준다

package/dist/flow-engine.js

@@ -2084,6 +2084,13 @@ export class FlowEngine {
          * 시뮬레이션에서 이것은 **우리 계산의 결함**이다(우리가 없는 물건을 소비하라고 요구했다). 그래서
          * 멈춘다. 미러는 처방이 다르다 — 원본이 진실이므로 받아들이고 어긋난 횟수를 남긴다.
          *
+         * ── 자리 규칙은 **여기서 확인하지 않는다** (2026-08-21에 호출부를 확인한 결과) ────
+         * 「자재는 작업이 일어나는 자리에 있어야 소비된다」는 규칙이 있고, 그 확인은 **소비 경로**
+         * (`claimMaterials`)가 이미 한다(그 자리에 있는 것만 선택한다). 이 원시에 같은 확인을 추가하면
+         * 정상 경로를 막는다: MES 선언 경로는 자재를 **라인사이드 보관 자리**에서 선택하고 변환은
+         * **공정 자리**에서 일어난다(`mes-kernel` 의 라우트 단계 — 두 자리가 다른 것이 그 경로의 설계다).
+         * 추가하려면 먼저 그 경로가 물건을 공정 자리로 이동시키게 만들어야 하고, 그것은 별개의 결정이다.
+         *
          * ── 미러를 멈추면 안 되는 이유 (2026-08-20, 시험으로 확인) ─────────────────
          * 씨앗으로 세운 커널은 그대로 `tick` 한다(§`hydrateObserved`). 원본이 확보분 하나를 누락한
          * 스냅샷을 주면 — 실 연동에서 흔한 빈틈이다 — 그 커널은 **첫 틱에 멈춘다.** 원본의 한 건이

package/dist/kernel.d.ts

@@ -16,7 +16,7 @@ export declare class WmsKernel extends FlowEngine {
      *
      * 여기서 이름을 여는 것이 답이 아니다 — 이 경로는 부품·라우트가 내장 상수인 레거시 시나리오라,
      * 이름만 열면 **지원하는 척**이 된다(MES 가 같은 이유로 같은 결론을 냈다). 답은 요구를 분명히 말하는
-     * 것이고, 던지면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
+     * 것이고, 오류를 내면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
      * 조용한 정지는 그 사실조차 남기지 않는다.
      */
     private builtInLocation;

package/dist/kernel.js

@@ -43,7 +43,7 @@ export class WmsKernel extends FlowEngine {
      *
      * 여기서 이름을 여는 것이 답이 아니다 — 이 경로는 부품·라우트가 내장 상수인 레거시 시나리오라,
      * 이름만 열면 **지원하는 척**이 된다(MES 가 같은 이유로 같은 결론을 냈다). 답은 요구를 분명히 말하는
-     * 것이고, 던지면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
+     * 것이고, 오류를 내면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
      * 조용한 정지는 그 사실조차 남기지 않는다.
      */
     builtInLocation(type, what) {

package/dist/mes-kernel.js

@@ -417,13 +417,34 @@ export class MesKernel extends FlowEngine {
         }
         const rc = this.recipeDef(o);
         const picks = [];
+        /*
+         * ── 자리별 색인을 사용한다 (2026-08-21) ────────────────────────────────────
+         * 예전에는 투입 줄마다 `[...this.items.values()].filter(...)` 로 **물품 전체를 순회**했다. 오더 하나에
+         * 투입 줄이 셋이면 세 번이다. 규모 기준선이 그것을 보여 주었다 — 물품이 4배 늘 때 주문당 비용이
+         * 3.3~3.5배가 됐다(거의 선형). 목표 규모는 물품 10만이고, 그때 이 순회는 틱을 밀어 낸다.
+         *
+         * 필터 조건이 `gtin` + `disposition` + **자리 타입**이므로, 자리 타입에 해당하는 자리들만 찾아
+         * `items.at(자리)` 색인을 사용하면 그 자리에 있는 것만 본다. 자리 수는 물품 수와 무관하게 작다.
+         */
+        const locsOfType = new Map();
+        for (const n of this.locations.values()) {
+            const bin = locsOfType.get(n.type);
+            if (bin)
+                bin.push(n);
+            else
+                locsOfType.set(n.type, [n]);
+        }
         for (const line of rc.inputs) {
             const g = this.classOf(line.material);
-            /* 자리 필터는 남는다 — 완제품도 `sellable` 이라, 반제품→완제품 체인에서 이것이 없으면 산출물을 자재로 집어먹는다. */
+            /* 자리 필터는 남는다 — 완제품도 `sellable` 이라, 반제품→완제품 체인에서 이것이 없으면 산출물을 자재로 소비한다. */
             const fromType = this.locationTypeOfMaterial(line.material);
-            const available = [...this.items.values()]
-                .filter(i => i.gtin === g && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === fromType)
-                .map(i => ({ epc: i.epc, location: i.location, qty: 1 }));
+            const available = [];
+            for (const n of locsOfType.get(fromType) ?? []) {
+                for (const i of this.items.at(n.id)) {
+                    if (i.gtin === g && i.disposition === DISP.sellable)
+                        available.push({ 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; // 자재 부족 → 대기

package/dist/observed-reducer.d.ts

@@ -55,7 +55,7 @@ export interface ProjectedState {
      * 아무것도 담기지 않는다. 그것을 조용히 두면 트윈은 「정상인데 빈」 모습이 된다.
      *
      * 비어 있지 않으면 뜻은 하나다: **이 트윈에 맞지 않는 어휘가 들어오고 있다**(커넥터 배선 오류이거나
-     * 커널이 낡았다). 세는 것에 그치고 판단은 소비처가 한다 — 여기서 던지면 저널 재생이 멈춘다.
+     * 커널이 낡았다). 세는 것에 그치고 판단은 소비처가 한다 — 여기서 오류를 내면 저널 재생이 멈춘다.
      */
     unhandled?: {
         eventType: string;

package/dist-cjs/index.cjs

@@ -125,6 +125,7 @@ __export(index_exports, {
   isEnergyRecord: () => isEnergyRecord,
   isEquipmentLevel: () => isEquipmentLevel,
   isOperationalRecord: () => isOperationalRecord,
+  isTransformationRecord: () => isTransformationRecord,
   isoDurationHours: () => isoDurationHours,
   itemKeyOf: () => itemKeyOf,
   levelOfLocationType: () => levelOfLocationType,
@@ -263,7 +264,7 @@ function hierarchyOf(s, levelOfType) {
 function testPassedAt(r, at) {
   if (r.result !== "pass") return false;
   if (!r.expiresAt || !at) return r.result === "pass";
-  return Date.parse(at) <= Date.parse(r.expiresAt);
+  return parsedMs(at) <= parsedMs(r.expiresAt);
 }
 function meetsTests(required, results, at) {
   if (!required.length) return true;
@@ -326,8 +327,8 @@ function priorityRank(p) {
 }
 function dueStatusOf(x, nowIso) {
   if (!x.endTime || !nowIso) return void 0;
-  const due = Date.parse(x.endTime);
-  const now = Date.parse(nowIso);
+  const due = parsedMs(x.endTime);
+  const now = parsedMs(nowIso);
   if (!Number.isFinite(due) || !Number.isFinite(now)) return void 0;
   return now > due ? "late" : "on-time";
 }
@@ -495,7 +496,7 @@ function capabilityOf(r, ctx) {
   if (r.held) return { available: false, reason: "held" };
   if (r.status === "down") return { available: false, reason: "down" };
   if (at) {
-    const ms2 = Date.parse(at);
+    const ms2 = parsedMs(at);
     if (Number.isFinite(ms2)) {
       const why = offCalendarReasonAt(r, ms2, ctx?.utcOffsetMinutes);
       if (why === "non-working") return { available: false, reason: "resting" };
@@ -2807,6 +2808,13 @@ function isAggregationRecord(record) {
   const r = record;
   return typeof r.parentID === "string" && r.parentID.trim().length > 0 && r.epc === void 0;
 }
+function isTransformationRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  if (r.epc !== void 0 || r.parentID !== void 0) return false;
+  const has = (k) => Array.isArray(r[k]) && r[k].length > 0;
+  return has("inputEPCList") || has("inputQuantityList") || has("outputEPCList") || has("outputQuantityList");
+}
 function get(obj, path) {
   return path.split(".").reduce((o, k) => o == null ? o : o[k], obj);
 }
@@ -2843,19 +2851,46 @@ function resolveQuantityList(v, record, field, errors) {
 }
 function mapRecordChecked(record, mapping, eventTime) {
   const errors = [];
-  const action = resolve(mapping.action, record, "action", errors) ?? "";
   const bizStep = resolve(mapping.bizStep, record, "bizStep", errors) ?? "";
   const disposition = resolve(mapping.disposition, record, "disposition", errors);
   const readPoint = resolve(mapping.readPoint, record, "readPoint", errors);
   const bizLocation = resolve(mapping.bizLocation, record, "bizLocation", errors);
+  if (mapping.type === "TransformationEvent") {
+    const inputEPCList = resolveList(mapping.inputEPCList, record, "inputEPCList", errors);
+    const inputQuantityList = resolveQuantityList(mapping.inputQuantityList, record, "inputQuantityList", errors);
+    const outputEPCList = resolveList(mapping.outputEPCList, record, "outputEPCList", errors);
+    const outputQuantityList = resolveQuantityList(mapping.outputQuantityList, record, "outputQuantityList", errors);
+    const transformationID = resolve(mapping.transformationID, record, "transformationID", errors);
+    if (!inputEPCList.length && !inputQuantityList.length && !outputEPCList.length && !outputQuantityList.length) {
+      errors.push("\uC785\uB825\uACFC \uCD9C\uB825\uC774 \uBAA8\uB450 \uBE44\uC5C8\uB2E4 \u2014 \uBCC0\uD658\uC740 \uB4E4\uC5B4\uAC04 \uAC83\uC774\uB098 \uB098\uC628 \uAC83 \uC911 \uD558\uB098\uB294 \uB9D0\uD574\uC57C \uD55C\uB2E4");
+    }
+    return {
+      event: transformationEvent({
+        eventTime,
+        bizStep,
+        disposition,
+        /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「없다」고 말하는 것이 된다.
+           소실(N→0)과 생성(0→N)은 표준이 인정하는 변환이고, 그때 한쪽이 아예 없는 것이 사실이다. */
+        ...inputEPCList.length ? { inputEPCList } : {},
+        ...inputQuantityList.length ? { inputQuantityList } : {},
+        ...outputEPCList.length ? { outputEPCList } : {},
+        ...outputQuantityList.length ? { outputQuantityList } : {},
+        ...transformationID ? { transformationID } : {},
+        readPoint,
+        bizLocation
+      }),
+      errors
+    };
+  }
   if (mapping.type === "AggregationEvent") {
+    const action2 = resolve(mapping.action, record, "action", errors) ?? "";
     const parentID = resolve(mapping.parentID, record, "parentID", errors) ?? "";
     const childEPCs = resolveList(mapping.childEPCs, record, "childEPCs", errors);
     const childQuantityList = resolveQuantityList(mapping.childQuantityList, record, "childQuantityList", errors);
     return {
       event: aggregationEvent({
         eventTime,
-        action,
+        action: action2,
         bizStep,
         disposition,
         parentID,
@@ -2868,6 +2903,7 @@ function mapRecordChecked(record, mapping, eventTime) {
       errors
     };
   }
+  const action = resolve(mapping.action, record, "action", errors) ?? "";
   const epc = resolve(mapping.epc, record, "epc", errors);
   const quantityList = resolveQuantityList(mapping.quantityList, record, "quantityList", errors);
   if (!epc && !quantityList.length) {
@@ -5995,7 +6031,7 @@ var WmsKernel = class extends FlowEngine {
    *
    * 여기서 이름을 여는 것이 답이 아니다 — 이 경로는 부품·라우트가 내장 상수인 레거시 시나리오라,
    * 이름만 열면 **지원하는 척**이 된다(MES 가 같은 이유로 같은 결론을 냈다). 답은 요구를 분명히 말하는
-   * 것이고, 던지면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
+   * 것이고, 오류를 내면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
    * 조용한 정지는 그 사실조차 남기지 않는다.
    */
   builtInLocation(type, what) {
@@ -6826,10 +6862,21 @@ var MesKernel = class extends FlowEngine {
     }
     const rc = this.recipeDef(o);
     const picks = [];
+    const locsOfType = /* @__PURE__ */ new Map();
+    for (const n of this.locations.values()) {
+      const bin = locsOfType.get(n.type);
+      if (bin) bin.push(n);
+      else locsOfType.set(n.type, [n]);
+    }
     for (const line of rc.inputs) {
       const g = this.classOf(line.material);
       const fromType = this.locationTypeOfMaterial(line.material);
-      const available = [...this.items.values()].filter((i) => i.gtin === g && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === fromType).map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
+      const available = [];
+      for (const n of locsOfType.get(fromType) ?? []) {
+        for (const i of this.items.at(n.id)) {
+          if (i.gtin === g && i.disposition === DISP.sellable) available.push({ 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);
@@ -7361,7 +7408,7 @@ var EmsKernel = class extends FlowEngine {
    * **아무 일도 하지 않는다** — 그런데 조용히 넘기지 않는다: 이 커널이 그런 요청을 받았다는 것은
    * **배선이 잘못됐다는 사실**이고(EMS 트윈에 물류 명령을 보낸 것), 조용히 넘기면 그 사실이 사라진다.
    *
-   * 던지지도 않는다: 저널 재생 중이라면 트윈 전체가 멈춘다. 그래서 커널이 담을 줄 모르는 사건을
+   * 오류를 내지도 않는다: 저널 재생 중이라면 트윈 전체가 멈춘다. 그래서 커널이 담을 줄 모르는 사건을
    * 세는 자리(`ObservedReducer.unhandled`)와 같은 규율으로, **개수를 세어 상태로 낸다.**
    */
   flowRequests = /* @__PURE__ */ new Map();
@@ -8356,6 +8403,7 @@ function retiredVocabularyIn(line) {
   isEnergyRecord,
   isEquipmentLevel,
   isOperationalRecord,
+  isTransformationRecord,
   isoDurationHours,
   itemKeyOf,
   levelOfLocationType,

package/package.json

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