@operato/twin-kernel 0.7.42 → 0.7.44

package/dist/allocation-policy.d.ts

@@ -23,7 +23,18 @@ export interface PlacementContext {
 export interface StockRequest {
     gtin: string;
     qty: number;
-    available: readonly StockView[];
+    /**
+     * 후보 재고 — **한 번만 순회할 수 있는 것으로 본다.**
+     *
+     * ── 왜 배열이 아닌가 (2026-08-21 프로파일) ────────────────────────────────
+     * 예전에는 배열이었다. 그래서 호출부가 자리의 물품 전체를 배열로 만들어 넘겼고, 그것이 틱 시간의
+     * 25.1% 였다(물품 16,000 규모). 오더 하나가 요구하는 수는 보통 한 자리인데 후보 전체를 실물로
+     * 만들어 낸 것이다.
+     *
+     * 지연 순회로 바꾸면 기본 정책은 만들지 않고 고를 수 있다. 전체가 필요한 정책(FEFO 는 만료 순으로
+     * 정렬해야 한다)은 `[...available]` 로 펼치면 된다 — 그 비용은 그 정책이 실제로 필요해서 치르는 것이다.
+     */
+    available: Iterable<StockView>;
 }
 export interface AllocationPolicy {
     /** 배치 목적지 슬롯 id. 수용 불가면 null(도크 대기 → 다음 tick 재시도). */

package/dist/allocation-policy.js

@@ -5,15 +5,55 @@
  * 결정은 정책에 위임한다. 고객은 FIFO/FEFO/nearest/zone·부분할당 등을 정책 교체로만
  * 확장 — 코어 수정 없이. (설계 gap #5 "할당 정책 플러그")
  */
+/*
+ * ── 식별자 비교에 `localeCompare` 를 쓰지 않는다 (2026-08-21 프로파일) ───────
+ *
+ * 정렬 비용이 틱 시간의 17.2% 였다(`sortByEpc` 와 그 비교 함수 합). 원인이 둘이다.
+ *
+ * ① `localeCompare` 는 **로케일 대조**다. 사람이 읽는 목록을 그 언어의 관행대로 늘어놓기 위한 것이고,
+ *    그래서 비교 한 번이 문자열 비교보다 훨씬 비싸다. 그런데 여기서 비교하는 것은 **식별자**다 —
+ *    사람에게 보이지 않고, 필요한 것은 「언제 물어도 같은 순서」뿐이다. 부호 순서로 충분하다.
+ *
+ * ② 전량을 정렬한 뒤 앞의 `qty` 개만 취했다. 오더 하나가 요구하는 수는 보통 한 자리인데 재고는
+ *    수만 개가 될 수 있다 — 목표 규모는 물품 10만이다. **가장 작은 k 개**만 찾으면 된다.
+ *
+ * 결과는 바뀌지 않는다: 같은 순서에서 가장 작은 k 개는 정렬한 뒤 앞의 k 개와 같은 것들이고 순서도 같다.
+ */
+const byId = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 function freeBinsFirstFit(slots) {
-    const sorted = [...slots].sort((a, b) => a.id.localeCompare(b.id));
-    for (const b of sorted)
-        if (b.occupancy + b.reserved < b.capacity)
-            return b.id;
-    return null;
+    /* 정렬하지 않는다 — 가장 작은 id 하나만 찾으면 되므로 한 번 순회로 답한다. */
+    let best;
+    for (const b of slots) {
+        if (b.occupancy + b.reserved >= b.capacity)
+            continue;
+        if (!best || byId(b.id, best.id) < 0)
+            best = b;
+    }
+    return best?.id ?? null;
 }
-function sortByEpc(available) {
-    return [...available].sort((a, b) => a.epc.localeCompare(b.epc));
+/**
+ * `epc` 가 가장 작은 **k 개** — 전량 정렬 없이.
+ *
+ * 작은 정렬 버퍼를 들고 한 번 순회한다. k 가 작을 때(오더가 요구하는 수는 보통 한 자리다) 전량 정렬보다
+ * 훨씬 싸고, 결과는 정렬한 뒤 앞의 k 개와 **같다**.
+ */
+function smallestByEpc(available, k) {
+    if (k <= 0)
+        return { picked: [], total: 0 };
+    const out = [];
+    let total = 0;
+    for (const s of available) {
+        total++;
+        if (out.length === k && byId(s.epc, out[out.length - 1].epc) >= 0)
+            continue;
+        let i = out.length;
+        while (i > 0 && byId(out[i - 1].epc, s.epc) > 0)
+            i--;
+        out.splice(i, 0, s);
+        if (out.length > k)
+            out.pop();
+    }
+    return { picked: out, total };
 }
 /**
  * 기본 정책 — first-fit slot + all-or-nothing 오더 할당.
@@ -22,9 +62,11 @@ function sortByEpc(available) {
 export const firstFitPolicy = {
     selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
     selectStock: ({ qty, available }) => {
-        if (available.length < qty)
+        /* 고르는 것과 세는 것을 **한 번의 순회**로 한다 — 전량 확보 판정에 개수가 필요하다. */
+        const { picked, total } = smallestByEpc(available, qty);
+        if (total < qty)
             return []; // 전량 확보 전엔 대기
-        return sortByEpc(available).slice(0, qty).map(s => s.epc);
+        return picked.map(s => s.epc);
     }
 };
 /**
@@ -33,7 +75,7 @@ export const firstFitPolicy = {
  */
 export const partialFitPolicy = {
     selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
-    selectStock: ({ qty, available }) => sortByEpc(available).slice(0, qty).map(s => s.epc)
+    selectStock: ({ qty, available }) => smallestByEpc(available, qty).picked.map(s => s.epc)
 };
 /**
  * FEFO 정책 — First-Expired-First-Out. 만료 임박 로트를 먼저 출고(신선/제약 도메인).
@@ -42,9 +84,11 @@ export const partialFitPolicy = {
 export const fefoPolicy = {
     selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
     selectStock: ({ qty, available }) => {
-        if (available.length < qty)
+        /* 만료 순이 필요하므로 전체를 펼친다 — 이 정책이 실제로 필요해서 치르는 비용이다. */
+        const all = [...available];
+        if (all.length < qty)
             return []; // 전량 확보 전엔 대기
-        const byExpiry = [...available].sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || a.epc.localeCompare(b.epc));
+        const byExpiry = all.sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || byId(a.epc, b.epc));
         return byExpiry.slice(0, qty).map(s => s.epc);
     }
 };

package/dist/contract.d.ts

@@ -1163,6 +1163,18 @@ export interface OrderState {
     recipeKey?: string;
     /** 씨앗이 이 오더의 확보분을 다 심지 못했다 — 이 오더의 답은 부족한 씨앗 위에 있다. */
     seedIncomplete?: boolean;
+    /**
+     * **이 오더가 왜 대기하는가** — 모자란 투입 줄(자재 키 · 필요 · 확보 가능).
+     *
+     * 확보는 전량 아니면 대기다. 그 거동은 옳은데 이유를 말하지 않으면 화면은 「running」만 보여 주고,
+     * 사람은 영구히 대기하는 오더를 정상으로 읽는다. 모자란 줄을 **전부** 싣는다 — 하나만 알려 주면
+     * 채운 뒤 다음 줄에서 또 막히고 같은 진단을 반복하게 된다.
+     */
+    shortage?: {
+        material: string;
+        need: number;
+        have: number;
+    }[];
     progress?: number;
     held?: boolean;
     /**
@@ -2003,6 +2015,19 @@ export declare function readBoardEquipment(def: TwinModelDef | Record<string, un
 /** 저장된 보드의 반복사용 자산 — 설비와 같은 정규화를 거친다. */
 export declare function readBoardAssets(def: TwinModelDef | Record<string, unknown>): NonNullable<TwinModelDef['assets']>;
 export interface TwinModelDef {
+    /**
+     * **이 트윈의 정체성 선언** — 팔레트·트레일러·문서의 식별자가 어디서 오나.
+     *
+     * ── 왜 모델에 있나 (2026-08-21) ──────────────────────────────────────────
+     * 처음에는 `ProductionSpec.identity` 하나였다. 그때 선언 모드가 있는 커널이 MES 뿐이었기 때문이다.
+     * 그런데 **정체성은 생산과 무관하다**: 창고는 팔레트(SSCC)를, 야드는 트레일러(GRAI)를 식별하는데
+     * 그 둘은 아무것도 생산하지 않는다. 생산 선언에 두면 생산하지 않는 트윈이 정체성을 선언할 자리가 없고,
+     * 실제로 그래서 두 커널이 프리픽스를 코드에 두고 있었다.
+     *
+     * 읽는 곳은 하나다(§`FlowEngine.identityDeclaration`). `ProductionSpec.identity` 는 **먼저 생긴
+     * 자리**이고, 픽스처·호스트가 이 자리로 옮기면 사라진다.
+     */
+    identity?: IdentityDeclaration;
     /** parallelism = 동시 처리 수(LocationState.parallelism 참조). capacity 는 저장 용량. */
     locations: {
         id: string;

package/dist/domain-catalog.d.ts

@@ -61,6 +61,17 @@ export interface TwinAxisInfo {
      * (저장·계약의 이름과 어긋나면 그 순간 방언이 생긴다).
      */
     axis: string;
+    /**
+     * **무엇이 이 축의 항목을 가리키나** — 없으면 소비처가 `id` 를 쓴다.
+     *
+     * 대부분의 축은 항목마다 `id` 가 있다. 그렇지 않은 축이 있고, 그것이 결함은 아니다 — 수요 구간의
+     * 정체성은 **구간이 언제 시작했나**다(요금의 알갱이가 그 시각으로 정해진다).
+     *
+     * 이 칸이 없던 동안 소비처는 `id`·`key`·`gtin` 을 **짐작**했고, 그래서 화면이 실재하는 항목을
+     * 「식별자 없음 — 참조할 수 없는 항목」으로 보였다. 값은 있는데 가리킬 수 없다고 말한 것이다.
+     * 짐작을 없애고 선언이 답한다 — 축이 사는 자리(`path`)를 선언하는 것과 같은 이유다.
+     */
+    idField?: string;
     /**
      * 이 축을 **어디서 읽나.**
      *

package/dist/domain-catalog.js

@@ -115,7 +115,17 @@ export const TWIN_AXES = [
      * 아직 세우지 않은 것: **요금 구간**(TariffPeriod)과 **원단위**(EnPI). 둘 다 아직 아무도 만들지
      * 않는다 — 선언만 하면 개념 지도가 언제나 0 을 보여 주고, 그것은 결손처럼 읽힌다(§10 7단계의 일).
      */
-    { axis: 'demandWindows', path: 'energy.closed', label: 'twin.axis.demandWindows', kind: 'instance',
+    /*
+     * **무엇이 이 항목을 가리키나** — `idField` 가 말한다.
+     *
+     * 수요 구간에는 `id` 가 없다. 그것이 결함은 아니다: 구간의 정체성은 **그 구간이 언제 시작했나**이고
+     * (요금의 알갱이가 그 시각으로 정해진다) 커널도 그것으로 키를 만든다(`contract-projected-over:<startMs>`).
+     *
+     * 그런데 소비처가 `id`·`key`·`gtin` 을 **짐작**하고 있어서, 화면이 여섯 구간 모두를 「식별자 없음 —
+     * 참조할 수 없는 항목」으로 보였다. 값은 실재하는데 가리킬 수 없다고 말한 것이다. 짐작을 없애고
+     * 선언이 답하게 한다 — 축이 사는 자리(`path`)를 선언하는 것과 같은 이유다.
+     */
+    { axis: 'demandWindows', path: 'energy.closed', idField: 'startMs', label: 'twin.axis.demandWindows', kind: 'instance',
         source: 'state', historical: true, standardClass: {}, systems: ['ems'] }
 ];
 /** 관계 전체 — 지도의 선과 항목의 이웃이 여기서 나온다(화면은 이 목록을 갖지 않는다). */

package/dist/epcis.d.ts

@@ -271,6 +271,20 @@ export declare function gdtiUri(companyPrefix: string, docType: string, serial:
  * 이름공간의 모양으로 URL 형태와 URN 형태를 가른다. 판정할 수 없는 모양이면 **답하지 않는다**(지어내지
  * 않는다) — 호출부가 다른 길을 고르게 한다.
  */
+/**
+ * **선언된 이름공간 아래의 개체 식별자** — SSCC·GRAI 를 쓰지 않는 길.
+ *
+ * 팔레트(SSCC)·트레일러(GRAI)는 개체 식별자이고, 그 조립에는 GS1 회사 프리픽스가 필요하다. 프리픽스가
+ * 없는 현장은 그 길로 갈 수 없다 — 그런데 커널이 프리픽스를 지어내면 저널에 남의 번호가 영구히 남는다.
+ *
+ * 표준이 다른 길을 정해 두었다.
+ *  · CBV 2.0 §8.2.4 `http(s)://[Subdomain.]Domain/⁎⁎/obj/Objid` — 그 도메인 소유자가 배정
+ *  · CBV 2.0 §8.2.3 `urn:URNNamespace:⁎⁎:obj:Objid` — URN 이름공간 소유자가 배정
+ *
+ * `obj` 표지가 필수다(클래스의 `class`·거래문서의 `bt` 와 같은 구조다). 다만 표준은 EPC URI 나 Digital
+ * Link 를 **권한다**(SHOULD) — 이 길은 프리픽스가 없을 때의 정합 경로다.
+ */
+export declare function objectUri(namespace: string, objId: string | number): string | undefined;
 export declare function bizTransactionUri(namespace: string, transId: string | number): string | undefined;
 /** 모든 빌더가 공통으로 받는 표준 헤더 옵션(선택) — 방출부가 필요할 때 채운다. */
 export interface EpcisHeaderOptions {

package/dist/epcis.js

@@ -132,25 +132,50 @@ export function gdtiUri(companyPrefix, docType, serial) {
  * 이름공간의 모양으로 URL 형태와 URN 형태를 가른다. 판정할 수 없는 모양이면 **답하지 않는다**(지어내지
  * 않는다) — 호출부가 다른 길을 고르게 한다.
  */
+/**
+ * **선언된 이름공간 아래의 개체 식별자** — SSCC·GRAI 를 쓰지 않는 길.
+ *
+ * 팔레트(SSCC)·트레일러(GRAI)는 개체 식별자이고, 그 조립에는 GS1 회사 프리픽스가 필요하다. 프리픽스가
+ * 없는 현장은 그 길로 갈 수 없다 — 그런데 커널이 프리픽스를 지어내면 저널에 남의 번호가 영구히 남는다.
+ *
+ * 표준이 다른 길을 정해 두었다.
+ *  · CBV 2.0 §8.2.4 `http(s)://[Subdomain.]Domain/⁎⁎/obj/Objid` — 그 도메인 소유자가 배정
+ *  · CBV 2.0 §8.2.3 `urn:URNNamespace:⁎⁎:obj:Objid` — URN 이름공간 소유자가 배정
+ *
+ * `obj` 표지가 필수다(클래스의 `class`·거래문서의 `bt` 와 같은 구조다). 다만 표준은 EPC URI 나 Digital
+ * Link 를 **권한다**(SHOULD) — 이 길은 프리픽스가 없을 때의 정합 경로다.
+ */
+export function objectUri(namespace, objId) {
+    return underNamespace(namespace, 'obj', objId);
+}
 export function bizTransactionUri(namespace, transId) {
+    return underNamespace(namespace, 'bt', transId);
+}
+/**
+ * 선언된 이름공간 아래에 표지를 붙여 식별자를 만든다 — 표지만 다르고 규칙은 같다.
+ *
+ * `obj`(개체 §8.2.3·§8.2.4) · `class`(클래스 §8.3.3·§8.3.4) · `bt`(거래문서 §8.5.4·§8.5.5) 가 같은
+ * 모양이다. 규칙을 세 곳에 적으면 한 곳만 고쳐지는 날이 온다.
+ */
+function underNamespace(namespace, marker, id) {
     const ns = namespace?.trim();
     if (!ns)
         return undefined;
-    const id = String(transId);
-    /* `transID` 에 구분자가 들어가면 표준이 요구하는 「성분 하나」가 깨진다. */
-    if (!id || id.includes('/') || id.includes(':'))
+    const v = String(id);
+    /* 표준이 요구하는 「성분 하나」가 깨진다 — 구분자가 든 값은 만들지 않는다. */
+    if (!v || v.includes('/') || v.includes(':'))
         return undefined;
     if (/^https?:\/\/[^/\s]+/.test(ns))
-        return `${ns.replace(/\/+$/, '')}/bt/${id}`;
+        return `${ns.replace(/\/+$/, '')}/${marker}/${v}`;
     /*
-     * **GS1 이 소유한 URN 공간에는 우리가 `:bt:` 를 만들 수 없다.** `urn:epc:`·`urn:epcglobal:` 의
-     * 소유 권한자는 GS1 이고(EPCIS §6.4), 그 안의 형태는 표준이 정해 둔 것만 유효하다. 그 공간을
-     * 이름공간으로 선언한 현장은 GDTI 문서 타입을 선언하는 쪽으로 가야 한다.
+     * **GS1 이 소유한 URN 공간에는 우리가 표지를 만들 수 없다.** `urn:epc:`·`urn:epcglobal:` 의 소유
+     * 권한자는 GS1 이고(EPCIS §6.4), 그 안의 형태는 표준이 정해 둔 것만 유효하다. 그 공간을 이름공간으로
+     * 선언한 현장은 GS1 키(SSCC·GRAI·GDTI)를 쓰는 쪽으로 가야 한다.
      */
     if (/^urn:epc(global)?:/.test(ns))
         return undefined;
     if (/^urn:[^:\s]+/.test(ns))
-        return `${ns.replace(/:+$/, '')}:bt:${id}`;
+        return `${ns.replace(/:+$/, '')}:${marker}:${v}`;
     return undefined;
 }
 function header(type, eventTime, bizStep, opts) {

package/dist/face2-adapter.d.ts

@@ -103,8 +103,9 @@ export declare function isAggregationRecord(record: unknown): boolean;
  * 변환은 **들어간 것과 나온 것**으로 말한다. 개체 하나의 관측(`epc`)이나 담김(`parentID`)과 섞이지
  * 않게, 그 둘이 없고 입력·출력 중 하나라도 있으면 변환으로 본다.
  *
- * 한쪽만 있는 것도 변환이다 — 표준이 소실(N→0)과 생성(0→N)을 같은 이벤트로 표현한다. 둘 다 없으면
- * 변환이 아니다(무엇이 바뀌었는지 말하지 않은 것이다).
+ * 한쪽이라도 있으면 **변환하려는 레코드로 본다.** 양쪽이 다 있어야 유효한 이벤트가 되지만(아래),
+ * 판정은 「무엇을 말하려는 레코드인가」이므로 한쪽만 있어도 이 갈래로 보내야 한다 — 그러지 않으면
+ * 반쪽만 온 레코드가 개체 관측으로 잘못 흘러가고, 무엇이 빠졌는지 아무도 말해 주지 않는다.
  */
 export declare function isTransformationRecord(record: unknown): boolean;
 /** 룰: 소스 레코드의 판별자(sourceType)로 매핑을 고른다. */

package/dist/face2-adapter.js

@@ -27,8 +27,9 @@ export function isAggregationRecord(record) {
  * 변환은 **들어간 것과 나온 것**으로 말한다. 개체 하나의 관측(`epc`)이나 담김(`parentID`)과 섞이지
  * 않게, 그 둘이 없고 입력·출력 중 하나라도 있으면 변환으로 본다.
  *
- * 한쪽만 있는 것도 변환이다 — 표준이 소실(N→0)과 생성(0→N)을 같은 이벤트로 표현한다. 둘 다 없으면
- * 변환이 아니다(무엇이 바뀌었는지 말하지 않은 것이다).
+ * 한쪽이라도 있으면 **변환하려는 레코드로 본다.** 양쪽이 다 있어야 유효한 이벤트가 되지만(아래),
+ * 판정은 「무엇을 말하려는 레코드인가」이므로 한쪽만 있어도 이 갈래로 보내야 한다 — 그러지 않으면
+ * 반쪽만 온 레코드가 개체 관측으로 잘못 흘러가고, 무엇이 빠졌는지 아무도 말해 주지 않는다.
  */
 export function isTransformationRecord(record) {
     if (!record || typeof record !== 'object')
@@ -111,16 +112,25 @@ export function mapRecordChecked(record, mapping, eventTime) {
         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('입력과 출력이 모두 비었다 — 변환은 들어간 것이나 나온 것 중 하나는 말해야 한다');
+        /*
+         * **양쪽이 다 있어야 한다** — EPCIS 2.0 §7.4.5 의 정의다: 「objects … are fully or partially
+         * consumed as inputs **and** one or more objects … are produced as outputs」. 네 목록 필드가
+         * 각각 선택인 것은 개체로 말하든 수량으로 말하든 되기 때문이고, 한쪽을 빼도 된다는 뜻이 아니다.
+         *
+         * 검증기도 같은 것을 본다. 여기서 함께 말하는 이유는 **가리키는 곳이 다르기** 때문이다 — 검증
+         * 메시지는 이벤트를 가리키고 이 메시지는 매핑을 가리킨다. 커넥터가 고칠 자리가 다르다.
+         */
+        if (!inputEPCList.length && !inputQuantityList.length) {
+            errors.push('입력이 비었다 — 변환은 무엇이 들어갔는지 말해야 한다(EPCIS 2.0 §7.4.5)');
+        }
+        if (!outputEPCList.length && !outputQuantityList.length) {
+            errors.push('출력이 비었다 — 변환은 무엇이 나왔는지 말해야 한다(EPCIS 2.0 §7.4.5)');
         }
         return {
             event: transformationEvent({
                 eventTime, bizStep, disposition,
                 /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「없다」고 말하는 것이 된다.
-                   소실(N→0)과 생성(0→N)은 표준이 인정하는 변환이고, 그때 한쪽이 아예 없는 것이 사실이다. */
+                   개체로 말한 쪽과 수량으로 말한 쪽 중 하나만 쓰는 것이 정상이다. */
                 ...(inputEPCList.length ? { inputEPCList } : {}),
                 ...(inputQuantityList.length ? { inputQuantityList } : {}),
                 ...(outputEPCList.length ? { outputEPCList } : {}),

package/dist/flow-engine.d.ts

@@ -1,4 +1,4 @@
-import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, StructureShift, IdentityGroundingView } from './contract.ts';
+import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, StructureShift, IdentityGroundingView, IdentityDeclaration } 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';
@@ -233,6 +233,20 @@ export interface FlowOrder {
      * 말한다.** 이 표시가 없으면 그 상황과 「우리 계산의 결함」을 구별할 수 없다.
      */
     seedIncomplete?: boolean;
+    /**
+     * **이 오더가 왜 대기하는가** — 마지막 확보 시도에서 모자랐던 투입 줄들.
+     *
+     * 확보는 전량 아니면 대기다(부분 투입을 하면 재고가 거짓이 된다). 그 거동은 옳은데 **조용했다**:
+     * 실측에서 투입 18줄 중 6줄이 입고되지 않아 오더 다섯이 영구히 대기했고 화면에는 「running」이라
+     * 적혔다. 어느 자리도 이유를 말하지 않았다.
+     *
+     * 매 틱 새로 쓰인다(확보를 다시 시도하므로). 채워지면 지운다 — 남겨 두면 해결된 것을 계속 말한다.
+     */
+    shortage?: {
+        material: string;
+        need: number;
+        have: number;
+    }[];
     /** 우선순위 — 표준 `OperationsRequest.Priority`(작은 값이 급하다). 할당 순서를 정한다. */
     priority?: number;
     /** 예정 창 — 표준 `StartTime`/`EndTime`. 납기가 있어야 "늦었나" 를 물을 수 있다. */
@@ -1239,6 +1253,26 @@ export declare abstract class FlowEngine implements TwinKernel {
      * 코어는 여기서 **정체성의 값을 정하지 않는다**: 「어디서 왔나」만 묻는다.
      */
     protected identityGroundingView(): IdentityGroundingView;
+    /**
+     * **이 트윈의 정체성 선언을 읽는 한 곳.**
+     *
+     * 모델이 갖는다(§`TwinModelDef.identity`) — 정체성은 생산과 무관하고, 생산하지 않는 트윈도 팔레트·
+     * 트레일러를 식별한다. 선언을 든 커널이 자기 것을 먼저 쓰도록 override 할 수 있다(MES 가 그렇게 한다:
+     * `ProductionSpec.identity` 가 먼저 생긴 자리다).
+     *
+     * 규칙을 두 곳에 적지 않기 위해 조립하는 쪽은 전부 이 함수를 지난다.
+     */
+    protected identityDeclaration(): IdentityDeclaration | undefined;
+    /**
+     * 선언된 이름공간 아래의 **개체 식별자** — 없으면 답하지 않는다.
+     *
+     * 팔레트·트레일러는 개체 식별자이고 GS1 키(SSCC·GRAI)에는 회사 프리픽스가 필요하다. 프리픽스가 없는
+     * 현장은 CBV §8.2.3·§8.2.4 의 길로 간다. 선언이 없으면 **지어내지 않고 `undefined` 를 답한다** —
+     * 호출부가 무엇을 할지 정한다(레거시 경로는 아직 상수를 쓴다).
+     */
+    protected declaredObjectId(id: string | number): string | undefined;
+    /** 선언된 이름공간 아래의 **거래 문서 식별자**(발주·주문·어포인트먼트) — 없으면 답하지 않는다. */
+    protected declaredBizTransactionId(id: string | number): string | undefined;
     private produceMaterials;
     /**
      * 이 작업이 **딛고 선 것**이 아직 있나 — 없으면 무엇이 없는지 답한다.

package/dist/flow-engine.js

@@ -11,7 +11,7 @@
  */
 import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf } from "./contract.js";
 import { ObservedReducer } from "./observed-reducer.js";
-import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP } from "./epcis.js";
+import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri } from "./epcis.js";
 import { OP_PARAM } from "./domain-definition.js";
 import { parseIsoDuration } from "./iso-duration.js";
 import { analyzeCapacity } from "./capacity.js";
@@ -373,6 +373,11 @@ export class ItemStore {
             out.set(k, structuredClone(it));
         return out;
     }
+    /*
+     * 지연 순회(`*iterAt`)를 만들어 배열을 없애 보았으나 **더 느렸다** — 물품 16,000 규모에서 틱 합계가
+     * 1562ms 에서 2723ms 로 늘었다. 항목마다 생성기 규약을 지나는 비용이 배열 하나를 만드는 비용보다
+     * 크다. 측정이 그렇게 답했으므로 배열을 유지한다.
+     */
     /** 그 자리에 있는 물품들 — 색인이 답한다(전체 순회가 아니다). */
     at(location) {
         const keys = this.byLocation.get(location);
@@ -1325,6 +1330,8 @@ export class FlowEngine {
                 ...(o.recipeKey ? { recipeKey: o.recipeKey } : {}),
                 /* 씨앗이 다 심지 못했다는 사실 — 조용히 자르지 않는다(그 오더의 답은 부족한 씨앗 위에 있다). */
                 ...(o.seedIncomplete ? { seedIncomplete: true } : {}),
+                /* 왜 대기하는지 — 없으면 화면은 「running」만 보여 주고 사람은 원인을 찾을 자리가 없다. */
+                ...(o.shortage?.length ? { shortage: o.shortage.map(x => ({ ...x })) } : {}),
                 ...(o.lines?.length ? { lines: o.lines.map(l => ({ gtin: l.gtin, requested: l.requested })) } : {}),
                 ...(o.priority !== undefined ? { priority: o.priority } : {}),
                 ...(o.startTime ? { startTime: o.startTime } : {}),
@@ -2571,6 +2578,42 @@ export class FlowEngine {
     identityGroundingView() {
         return identityGroundingOf(undefined);
     }
+    /**
+     * **이 트윈의 정체성 선언을 읽는 한 곳.**
+     *
+     * 모델이 갖는다(§`TwinModelDef.identity`) — 정체성은 생산과 무관하고, 생산하지 않는 트윈도 팔레트·
+     * 트레일러를 식별한다. 선언을 든 커널이 자기 것을 먼저 쓰도록 override 할 수 있다(MES 가 그렇게 한다:
+     * `ProductionSpec.identity` 가 먼저 생긴 자리다).
+     *
+     * 규칙을 두 곳에 적지 않기 위해 조립하는 쪽은 전부 이 함수를 지난다.
+     */
+    identityDeclaration() {
+        return this.boardDef?.identity;
+    }
+    /**
+     * 선언된 이름공간 아래의 **개체 식별자** — 없으면 답하지 않는다.
+     *
+     * 팔레트·트레일러는 개체 식별자이고 GS1 키(SSCC·GRAI)에는 회사 프리픽스가 필요하다. 프리픽스가 없는
+     * 현장은 CBV §8.2.3·§8.2.4 의 길로 간다. 선언이 없으면 **지어내지 않고 `undefined` 를 답한다** —
+     * 호출부가 무엇을 할지 정한다(레거시 경로는 아직 상수를 쓴다).
+     */
+    declaredObjectId(id) {
+        for (const ns of this.identityDeclaration()?.namespaces ?? []) {
+            const uri = objectUri(ns, id);
+            if (uri)
+                return uri;
+        }
+        return undefined;
+    }
+    /** 선언된 이름공간 아래의 **거래 문서 식별자**(발주·주문·어포인트먼트) — 없으면 답하지 않는다. */
+    declaredBizTransactionId(id) {
+        for (const ns of this.identityDeclaration()?.namespaces ?? []) {
+            const uri = bizTransactionUri(ns, id);
+            if (uri)
+                return uri;
+        }
+        return undefined;
+    }
     produceMaterials(t) {
         /* 도메인이 소유를 주장하면 코어는 비켜선다 — 둘이 만들면 재고가 두 배가 된다. */
         if (this.producesOwnOutputs(t.kind))

package/dist/kernel.js

@@ -57,13 +57,17 @@ export class WmsKernel extends FlowEngine {
     /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
     onArrival(spec) {
         const dock = this.builtInLocation('dock', 'inbound pallets land here');
-        const epc = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq); // 팔레트 SSCC
+        /* 선언이 있으면 선언에서(CBV §8.2.4) — 없으면 레거시 상수. 가드가 그 상수를 계속 센다. */
+        const seq = ++this.epcSeq;
+        const epc = this.declaredObjectId(`PAL-${seq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, seq); // 팔레트
         const gtin = this.pickGtin(spec.content.skuMix); // SGTIN idpat = epcClass
         /* 품목 구성이 비어 있으면 **도착을 만들지 않는다** — 무엇이 왔는지 말할 수 없는 입고는 사실이 아니다. */
         if (!gtin)
             return;
         const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max); // 케이스 수(비직렬)
-        const po = gdtiUri(LEGACY_COMPANY_PREFIX, '401', ++this.poSeq);
+        const poSeq = ++this.poSeq;
+        /* 발주 문서 식별자 — 선언된 이름공간 아래(CBV §8.5.5) 또는 선언된 GDTI 문서 타입. */
+        const po = this.declaredBizTransactionId(`PO-${poSeq}`) ?? gdtiUri(LEGACY_COMPANY_PREFIX, this.identityDeclaration()?.documentTypes?.purchaseorder ?? '401', poSeq);
         const eventTime = this.now();
         const qtyList = [{ epcClass: gtin, quantity: qty }];
         const poTxn = [{ type: BTT.po, bizTransaction: po }];
@@ -137,7 +141,8 @@ export class WmsKernel extends FlowEngine {
     /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
     createSalesOrder(lines, spec) {
         const id = `order-${++this.orderSeq}`;
-        const so = gdtiUri(LEGACY_COMPANY_PREFIX, '402', ++this.soSeq);
+        const soSeq = ++this.soSeq;
+        const so = this.declaredBizTransactionId(`SO-${soSeq}`) ?? gdtiUri(LEGACY_COMPANY_PREFIX, this.identityDeclaration()?.documentTypes?.salesorder ?? '402', soSeq);
         const requested = lines.reduce((s, l) => s + l.qty, 0);
         const order = {
             id, kind: 'outbound', status: 'created', requested, fulfilled: 0, bizTransaction: so,
@@ -349,7 +354,8 @@ export class WmsKernel extends FlowEngine {
                 continue;
             /* 클래스 줄을 팔레트로 바꾼다 — 자리 점유는 줄 하나에서 줄 하나로(늘지 않는다). */
             this.items.delete(key);
-            const pallet = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
+            const palSeq = ++this.epcSeq;
+            const pallet = this.declaredObjectId(`PAL-${palSeq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, palSeq);
             const qtyList = [{ epcClass: m.definitionId, quantity: qty }];
             this.items.set(pallet, { epc: pallet, gtin: m.definitionId, qty, location: at, disposition: DISP.in_progress });
             const eventTime = this.now();
@@ -366,7 +372,8 @@ export class WmsKernel extends FlowEngine {
            창고의 모양이다(도크 단계가 없는 현장이 있다). 그 사실은 화물의 출발 자리로 저널에 남는다. */
         const shipDock = this.locationByType('dock-ship') ?? staging;
         const eventTime = this.now();
-        const shipment = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
+        const shpSeq = ++this.epcSeq;
+        const shipment = this.declaredObjectId(`SHP-${shpSeq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, shpSeq);
         order.shipmentEpc = shipment;
         const soTxn = [{ type: BTT.so, bizTransaction: order.bizTransaction }];
         // 패킹: 화물(shipment) ← 팔레트 조립(merge). 팔레트는 출하 DELETE 까지 독립 유지 → consume 없음.

package/dist/mes-kernel.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorSpec, Command, CommandAck, ProductionSpec, TwinModelDef, IdentityGroundingView } from './contract.ts';
+import type { GeneratorSpec, Command, CommandAck, ProductionSpec, TwinModelDef, IdentityGroundingView, Attention } from './contract.ts';
 import type { AllocationPolicy } from './allocation-policy.ts';
 import { FlowEngine } from './flow-engine.ts';
 import type { FlowOrder, FlowTask } from './flow-engine.ts';
@@ -37,6 +37,13 @@ export declare class MesKernel extends FlowEngine {
      * 아니다). 선언이 없는 MES 트윈은 이제 만들 수 없으므로(`loadTwinModel` 이 거절한다) `fabricated` 로
      * 판정될 일이 없다.
      */
+    /**
+     * MES 는 **생산 선언의 정체성을 먼저** 쓴다 — `ProductionSpec.identity` 가 먼저 생긴 자리다.
+     *
+     * 모델 자리(§`TwinModelDef.identity`)로 옮기면 이 override 는 사라진다. 두 자리를 동시에 읽는 것이
+     * 아니라 **하나를 고르는** 것이므로 규칙이 갈리지 않는다.
+     */
+    protected identityDeclaration(): import("./contract.ts").IdentityDeclaration | undefined;
     protected identityGroundingView(): IdentityGroundingView;
     /**
      * 선언이 말하는 자리 타입이 **이 트윈에 있나** — 로드 시점에 한 번, 모아서 말한다 (2026-08-20).
@@ -60,6 +67,20 @@ export declare class MesKernel extends FlowEngine {
      * 이미 그 제품이면 no-op, 아니면 셋업(기본값, OEE 가용성 손실) + lastChangeoverKey 각인
      * (이후 그 제품 task 는 자동 셋업 생략). command → 변이 → State 델타(폐루프).
      */
+    /**
+     * **왜 대기하는지 화면에 말한다** — 자재가 모자라 확보가 미뤄진 오더.
+     *
+     * ── 왜 필요한가 (2026-08-21 실측) ─────────────────────────────────────────
+     * 확보는 전량 아니면 대기다(부분 투입을 하면 재고가 거짓이 된다). 그 거동은 옳다. 그런데 조용해서,
+     * 투입 18줄 중 6줄이 한 번도 입고되지 않은 공장에서 **오더 다섯이 영구히 대기하는 동안 화면에는
+     * 「running」이라 적혔다.** 아무 자리도 이유를 말하지 않았다.
+     *
+     * 판단만 여기서 한다 — 확인(ack)·처음 성립한 시각·사라진 조건 정리는 `computeAttentions` 가
+     * 한 곳에서 맡는다(확장점 규약).
+     *
+     * 사람이 읽는 문장은 만들지 않는다. `kind` 와 언어 중립 `params` 만 내고 문장은 표현계층이 만든다.
+     */
+    protected collectAttentions(): Attention[];
     protected handleCommand(cmd: Command): CommandAck;
     /** 부품 수령 — 도착한 품목이 선언된 입력 자재면 그 자재가 선언한 자리에 생성. */
     protected onArrival(spec: GeneratorSpec): void;

package/dist/mes-kernel.js

@@ -99,6 +99,15 @@ export class MesKernel extends FlowEngine {
      * 아니다). 선언이 없는 MES 트윈은 이제 만들 수 없으므로(`loadTwinModel` 이 거절한다) `fabricated` 로
      * 판정될 일이 없다.
      */
+    /**
+     * MES 는 **생산 선언의 정체성을 먼저** 쓴다 — `ProductionSpec.identity` 가 먼저 생긴 자리다.
+     *
+     * 모델 자리(§`TwinModelDef.identity`)로 옮기면 이 override 는 사라진다. 두 자리를 동시에 읽는 것이
+     * 아니라 **하나를 고르는** 것이므로 규칙이 갈리지 않는다.
+     */
+    identityDeclaration() {
+        return this.productionSpec?.identity ?? super.identityDeclaration();
+    }
     identityGroundingView() {
         return identityGroundingOf(this.productionSpec);
     }
@@ -149,6 +158,43 @@ export class MesKernel extends FlowEngine {
      * 이미 그 제품이면 no-op, 아니면 셋업(기본값, OEE 가용성 손실) + lastChangeoverKey 각인
      * (이후 그 제품 task 는 자동 셋업 생략). command → 변이 → State 델타(폐루프).
      */
+    /**
+     * **왜 대기하는지 화면에 말한다** — 자재가 모자라 확보가 미뤄진 오더.
+     *
+     * ── 왜 필요한가 (2026-08-21 실측) ─────────────────────────────────────────
+     * 확보는 전량 아니면 대기다(부분 투입을 하면 재고가 거짓이 된다). 그 거동은 옳다. 그런데 조용해서,
+     * 투입 18줄 중 6줄이 한 번도 입고되지 않은 공장에서 **오더 다섯이 영구히 대기하는 동안 화면에는
+     * 「running」이라 적혔다.** 아무 자리도 이유를 말하지 않았다.
+     *
+     * 판단만 여기서 한다 — 확인(ack)·처음 성립한 시각·사라진 조건 정리는 `computeAttentions` 가
+     * 한 곳에서 맡는다(확장점 규약).
+     *
+     * 사람이 읽는 문장은 만들지 않는다. `kind` 와 언어 중립 `params` 만 내고 문장은 표현계층이 만든다.
+     */
+    collectAttentions() {
+        const out = super.collectAttentions();
+        for (const o of this.orders.values()) {
+            const short = o.shortage;
+            if (!short?.length)
+                continue;
+            out.push({
+                id: `material-short:${o.id}`,
+                kind: 'material-short',
+                /* 한 줄이 모자란 것과 여러 줄이 모자란 것은 할 일이 다르다 — 여럿이면 자재 공급 자체가 문제다. */
+                severity: short.length > 1 ? 'high' : 'medium',
+                anchor: { orderId: o.id },
+                params: {
+                    /* 모자란 줄 수와 투입 줄 수 — 「6/18」이 「하나 모자람」과 다른 상황임을 한눈에 말한다. */
+                    shortLines: short.length,
+                    /* 자재 키를 그대로 낸다. 커널이 사람이 읽는 이름을 만들지 않는다 — 이름은 모델이 갖는다. */
+                    materials: short.map(x => x.material).join(', '),
+                    need: short.reduce((n, x) => n + x.need, 0),
+                    have: short.reduce((n, x) => n + x.have, 0)
+                }
+            });
+        }
+        return out;
+    }
     handleCommand(cmd) {
         if (cmd.type === MES_CMD.changeover) {
             const a = cmd.args;
@@ -417,6 +463,7 @@ export class MesKernel extends FlowEngine {
         }
         const rc = this.recipeDef(o);
         const picks = [];
+        const short = [];
         /*
          * ── 자리별 색인을 사용한다 (2026-08-21) ────────────────────────────────────
          * 예전에는 투입 줄마다 `[...this.items.values()].filter(...)` 로 **물품 전체를 순회**했다. 오더 하나에
@@ -438,6 +485,11 @@ export class MesKernel extends FlowEngine {
             const g = this.classOf(line.material);
             /* 자리 필터는 남는다 — 완제품도 `sellable` 이라, 반제품→완제품 체인에서 이것이 없으면 산출물을 자재로 소비한다. */
             const fromType = this.locationTypeOfMaterial(line.material);
+            /*
+             * 후보를 배열로 모은다. 지연 순회(생성기)로 바꿔 보았으나 **더 느렸다** — 물품 16,000 규모에서
+             * 1562ms → 2723ms 였다. 항목마다 생성기 규약을 지나는 비용이 배열을 만드는 비용보다 크다.
+             * 측정이 그렇게 답했으므로 배열을 유지한다(§StockRequest.available 은 지연도 받는다).
+             */
             const available = [];
             for (const n of locsOfType.get(fromType) ?? []) {
                 for (const i of this.items.at(n.id)) {
@@ -446,10 +498,31 @@ export class MesKernel extends FlowEngine {
                 }
             }
             const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
-            if (chosen.length < line.qty)
-                return; // 자재 부족 → 대기
+            if (chosen.length < line.qty) {
+                /*
+                 * **왜 대기하는지 남긴다** (2026-08-21).
+                 *
+                 * 예전에는 첫 부족한 줄에서 그대로 반환했다. 거동은 옳다(전량 확보 전에는 만들지 않는다) —
+                 * 문제는 **조용한 것**이었다. 실측: Rosarito MES 는 투입 18줄 중 6줄이 한 번도 입고되지 않아
+                 * 오더 다섯이 영구히 대기했고, 화면에는 「running」이라 적혔다. 어느 자리도 이유를 말하지 않았다.
+                 *
+                 * 첫 줄에서 멈추지 않고 **모자란 줄을 다 센다.** 하나만 알려 주면 그것을 채운 뒤 다음 줄에서
+                 * 또 막히고, 사람은 같은 진단을 여섯 번 반복한다.
+                 */
+                short.push({ material: line.material, need: line.qty, have: chosen.length });
+                continue;
+            }
             picks.push(...chosen);
         }
+        if (short.length) {
+            /* 확보는 하지 않는다 — 사실만 남기고 다음 틱에 다시 본다(값은 매 틱 새로 쓰인다). */
+            o.shortage = short;
+            this.emitOrder(o);
+            return;
+        }
+        /* 채워졌으면 표시를 지운다 — 남겨 두면 화면이 이미 해결된 것을 계속 말한다. */
+        if (o.shortage)
+            delete o.shortage;
         for (const epc of picks)
             o.allocated.push(epc);
         this.reserve(picks, MES_BIZSTEP.producing);

package/dist/yms-kernel.js

@@ -64,19 +64,25 @@ export class YmsKernel extends FlowEngine {
         if (!gate || doors.length === 0)
             return;
         const inbound = kind === 'appointment';
-        const epc = graiUri(LEGACY_CP, '10', ++this.epcSeq);
+        const trSeq = ++this.epcSeq;
+        /* 선언이 있으면 선언에서(CBV §8.2.4) — 없으면 레거시 상수. */
+        const epc = this.declaredObjectId(`TRL-${trSeq}`) ?? graiUri(LEGACY_CP, this.identityDeclaration()?.documentTypes?.trailer ?? '10', trSeq);
         this.items.set(epc, { epc, location: gate.id, disposition: DISP.in_progress });
         gate.occupancy++;
         this.emit(objectEvent({ eventTime: this.now(), action: 'ADD', bizStep: YARD_BIZSTEP.arriving, disposition: DISP.in_progress, epcList: [epc], readPoint: gate.id, bizLocation: gate.id }));
         // 인바운드: 화물 적재된 채 도착 → 조립(트레일러←화물) 기록. 아웃바운드: 빈 트레일러(화물은 도크에서 적재).
         if (inbound) {
-            const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => ssccUri(LEGACY_CP, ++this.cargoSeq));
+            const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => {
+                const c = ++this.cargoSeq;
+                return this.declaredObjectId(`CGO-${c}`) ?? ssccUri(LEGACY_CP, c);
+            });
             this.trailerCargo.set(epc, cargo);
             this.aggregate(epc, cargo, { bizStep: YARD_BIZSTEP.arriving, readPoint: gate.id }); // 적재된 채 도착(자식 opaque, 미materialize)
         }
         const door = doors[this.doorRR++ % doors.length];
         const id = `order-${++this.orderSeq}`;
-        const appt = gdtiUri(LEGACY_CP, '404', ++this.soSeq);
+        const apSeq = ++this.soSeq;
+        const appt = this.declaredBizTransactionId(`APPT-${apSeq}`) ?? gdtiUri(LEGACY_CP, this.identityDeclaration()?.documentTypes?.appointment ?? '404', apSeq);
         const order = { id, kind, status: 'created', requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [epc], picked: [], dockDoor: door.id,
             /* 내부 스케줄 게이트(시뮬 ms) — 표준 `EarliestStartTime` 과 같은 개념의 우리 단위. */
             windowStartMs: this.clockMs + WINDOW_DELAY_MS,

package/dist-cjs/index.cjs

@@ -138,6 +138,7 @@ __export(index_exports, {
   monteCarloForecast: () => monteCarloForecast,
   monteCarloForecastAsync: () => monteCarloForecastAsync,
   objectEvent: () => objectEvent,
+  objectUri: () => objectUri,
   offCalendarAt: () => offCalendarAt,
   offCalendarReasonAt: () => offCalendarReasonAt,
   operationalKindOf: () => operationalKindOf,
@@ -307,14 +308,14 @@ function classIndex(defs) {
 }
 var EMPTY_CLASS_INDEX = /* @__PURE__ */ new Map();
 function classClosure(directIds, defs, at) {
-  const byId = classIndex(defs);
+  const byId2 = classIndex(defs);
   const inWindow = (d) => !d || effectivityAt(d, at) === void 0;
   const out = /* @__PURE__ */ new Set();
   const stack = [...directIds ?? []];
   while (stack.length) {
     const id = stack.pop();
     if (out.has(id)) continue;
-    const def = byId.get(id);
+    const def = byId2.get(id);
     if (!inWindow(def)) continue;
     out.add(id);
     for (const b of def?.baseIds ?? []) if (!out.has(b)) stack.push(b);
@@ -947,14 +948,20 @@ function parseEpc(uri) {
 function gdtiUri(companyPrefix, docType, serial) {
   return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
 }
+function objectUri(namespace, objId) {
+  return underNamespace(namespace, "obj", objId);
+}
 function bizTransactionUri(namespace, transId) {
+  return underNamespace(namespace, "bt", transId);
+}
+function underNamespace(namespace, marker, id) {
   const ns = namespace?.trim();
   if (!ns) return void 0;
-  const id = String(transId);
-  if (!id || id.includes("/") || id.includes(":")) return void 0;
-  if (/^https?:\/\/[^/\s]+/.test(ns)) return `${ns.replace(/\/+$/, "")}/bt/${id}`;
+  const v = String(id);
+  if (!v || v.includes("/") || v.includes(":")) return void 0;
+  if (/^https?:\/\/[^/\s]+/.test(ns)) return `${ns.replace(/\/+$/, "")}/${marker}/${v}`;
   if (/^urn:epc(global)?:/.test(ns)) return void 0;
-  if (/^urn:[^:\s]+/.test(ns)) return `${ns.replace(/:+$/, "")}:bt:${id}`;
+  if (/^urn:[^:\s]+/.test(ns)) return `${ns.replace(/:+$/, "")}:${marker}:${v}`;
   return void 0;
 }
 function header(type, eventTime, bizStep, opts) {
@@ -2122,11 +2129,11 @@ var EMS_TYPES = [
   }
 ];
 function electricalUpstreamOf(locations, id) {
-  const byId = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
-  const self = byId.get(String(id));
+  const byId2 = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
+  const self = byId2.get(String(id));
   if (!self) return void 0;
   if (self.upstreamId) return String(self.upstreamId);
-  const parent = self.parentId ? byId.get(String(self.parentId)) : void 0;
+  const parent = self.parentId ? byId2.get(String(self.parentId)) : void 0;
   if (!parent) return void 0;
   return isElectricalLocationType(String(parent.type ?? "")) ? String(parent.id) : void 0;
 }
@@ -2526,9 +2533,20 @@ var TWIN_AXES = [
    * 아직 세우지 않은 것: **요금 구간**(TariffPeriod)과 **원단위**(EnPI). 둘 다 아직 아무도 만들지
    * 않는다 — 선언만 하면 개념 지도가 언제나 0 을 보여 주고, 그것은 결손처럼 읽힌다(§10 7단계의 일).
    */
+  /*
+   * **무엇이 이 항목을 가리키나** — `idField` 가 말한다.
+   *
+   * 수요 구간에는 `id` 가 없다. 그것이 결함은 아니다: 구간의 정체성은 **그 구간이 언제 시작했나**이고
+   * (요금의 알갱이가 그 시각으로 정해진다) 커널도 그것으로 키를 만든다(`contract-projected-over:<startMs>`).
+   *
+   * 그런데 소비처가 `id`·`key`·`gtin` 을 **짐작**하고 있어서, 화면이 여섯 구간 모두를 「식별자 없음 —
+   * 참조할 수 없는 항목」으로 보였다. 값은 실재하는데 가리킬 수 없다고 말한 것이다. 짐작을 없애고
+   * 선언이 답하게 한다 — 축이 사는 자리(`path`)를 선언하는 것과 같은 이유다.
+   */
   {
     axis: "demandWindows",
     path: "energy.closed",
+    idField: "startMs",
     label: "twin.axis.demandWindows",
     kind: "instance",
     source: "state",
@@ -2671,30 +2689,47 @@ function capabilitiesForType(system, typeKey) {
 }
 
 // src/allocation-policy.ts
+var byId = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 function freeBinsFirstFit(slots) {
-  const sorted = [...slots].sort((a, b) => a.id.localeCompare(b.id));
-  for (const b of sorted) if (b.occupancy + b.reserved < b.capacity) return b.id;
-  return null;
+  let best;
+  for (const b of slots) {
+    if (b.occupancy + b.reserved >= b.capacity) continue;
+    if (!best || byId(b.id, best.id) < 0) best = b;
+  }
+  return best?.id ?? null;
 }
-function sortByEpc(available) {
-  return [...available].sort((a, b) => a.epc.localeCompare(b.epc));
+function smallestByEpc(available, k) {
+  if (k <= 0) return { picked: [], total: 0 };
+  const out = [];
+  let total = 0;
+  for (const s of available) {
+    total++;
+    if (out.length === k && byId(s.epc, out[out.length - 1].epc) >= 0) continue;
+    let i = out.length;
+    while (i > 0 && byId(out[i - 1].epc, s.epc) > 0) i--;
+    out.splice(i, 0, s);
+    if (out.length > k) out.pop();
+  }
+  return { picked: out, total };
 }
 var firstFitPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
   selectStock: ({ qty, available }) => {
-    if (available.length < qty) return [];
-    return sortByEpc(available).slice(0, qty).map((s) => s.epc);
+    const { picked, total } = smallestByEpc(available, qty);
+    if (total < qty) return [];
+    return picked.map((s) => s.epc);
   }
 };
 var partialFitPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
-  selectStock: ({ qty, available }) => sortByEpc(available).slice(0, qty).map((s) => s.epc)
+  selectStock: ({ qty, available }) => smallestByEpc(available, qty).picked.map((s) => s.epc)
 };
 var fefoPolicy = {
   selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
   selectStock: ({ qty, available }) => {
-    if (available.length < qty) return [];
-    const byExpiry = [...available].sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || a.epc.localeCompare(b.epc));
+    const all = [...available];
+    if (all.length < qty) return [];
+    const byExpiry = all.sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || byId(a.epc, b.epc));
     return byExpiry.slice(0, qty).map((s) => s.epc);
   }
 };
@@ -2861,8 +2896,11 @@ function mapRecordChecked(record, mapping, eventTime) {
     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");
+    if (!inputEPCList.length && !inputQuantityList.length) {
+      errors.push("\uC785\uB825\uC774 \uBE44\uC5C8\uB2E4 \u2014 \uBCC0\uD658\uC740 \uBB34\uC5C7\uC774 \uB4E4\uC5B4\uAC14\uB294\uC9C0 \uB9D0\uD574\uC57C \uD55C\uB2E4(EPCIS 2.0 \xA77.4.5)");
+    }
+    if (!outputEPCList.length && !outputQuantityList.length) {
+      errors.push("\uCD9C\uB825\uC774 \uBE44\uC5C8\uB2E4 \u2014 \uBCC0\uD658\uC740 \uBB34\uC5C7\uC774 \uB098\uC654\uB294\uC9C0 \uB9D0\uD574\uC57C \uD55C\uB2E4(EPCIS 2.0 \xA77.4.5)");
     }
     return {
       event: transformationEvent({
@@ -2870,7 +2908,7 @@ function mapRecordChecked(record, mapping, eventTime) {
         bizStep,
         disposition,
         /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「없다」고 말하는 것이 된다.
-           소실(N→0)과 생성(0→N)은 표준이 인정하는 변환이고, 그때 한쪽이 아예 없는 것이 사실이다. */
+           개체로 말한 쪽과 수량으로 말한 쪽 중 하나만 쓰는 것이 정상이다. */
         ...inputEPCList.length ? { inputEPCList } : {},
         ...inputQuantityList.length ? { inputQuantityList } : {},
         ...outputEPCList.length ? { outputEPCList } : {},
@@ -3429,6 +3467,11 @@ var ItemStore = class _ItemStore {
     for (const [k, it] of this.map) out.set(k, structuredClone(it));
     return out;
   }
+  /*
+   * 지연 순회(`*iterAt`)를 만들어 배열을 없애 보았으나 **더 느렸다** — 물품 16,000 규모에서 틱 합계가
+   * 1562ms 에서 2723ms 로 늘었다. 항목마다 생성기 규약을 지나는 비용이 배열 하나를 만드는 비용보다
+   * 크다. 측정이 그렇게 답했으므로 배열을 유지한다.
+   */
   /** 그 자리에 있는 물품들 — 색인이 답한다(전체 순회가 아니다). */
   at(location) {
     const keys = this.byLocation.get(location);
@@ -4286,6 +4329,8 @@ var FlowEngine = class {
         ...o.recipeKey ? { recipeKey: o.recipeKey } : {},
         /* 씨앗이 다 심지 못했다는 사실 — 조용히 자르지 않는다(그 오더의 답은 부족한 씨앗 위에 있다). */
         ...o.seedIncomplete ? { seedIncomplete: true } : {},
+        /* 왜 대기하는지 — 없으면 화면은 「running」만 보여 주고 사람은 원인을 찾을 자리가 없다. */
+        ...o.shortage?.length ? { shortage: o.shortage.map((x) => ({ ...x })) } : {},
         ...o.lines?.length ? { lines: o.lines.map((l) => ({ gtin: l.gtin, requested: l.requested })) } : {},
         ...o.priority !== void 0 ? { priority: o.priority } : {},
         ...o.startTime ? { startTime: o.startTime } : {},
@@ -5403,6 +5448,40 @@ var FlowEngine = class {
   identityGroundingView() {
     return identityGroundingOf(void 0);
   }
+  /**
+   * **이 트윈의 정체성 선언을 읽는 한 곳.**
+   *
+   * 모델이 갖는다(§`TwinModelDef.identity`) — 정체성은 생산과 무관하고, 생산하지 않는 트윈도 팔레트·
+   * 트레일러를 식별한다. 선언을 든 커널이 자기 것을 먼저 쓰도록 override 할 수 있다(MES 가 그렇게 한다:
+   * `ProductionSpec.identity` 가 먼저 생긴 자리다).
+   *
+   * 규칙을 두 곳에 적지 않기 위해 조립하는 쪽은 전부 이 함수를 지난다.
+   */
+  identityDeclaration() {
+    return this.boardDef?.identity;
+  }
+  /**
+   * 선언된 이름공간 아래의 **개체 식별자** — 없으면 답하지 않는다.
+   *
+   * 팔레트·트레일러는 개체 식별자이고 GS1 키(SSCC·GRAI)에는 회사 프리픽스가 필요하다. 프리픽스가 없는
+   * 현장은 CBV §8.2.3·§8.2.4 의 길로 간다. 선언이 없으면 **지어내지 않고 `undefined` 를 답한다** —
+   * 호출부가 무엇을 할지 정한다(레거시 경로는 아직 상수를 쓴다).
+   */
+  declaredObjectId(id) {
+    for (const ns of this.identityDeclaration()?.namespaces ?? []) {
+      const uri = objectUri(ns, id);
+      if (uri) return uri;
+    }
+    return void 0;
+  }
+  /** 선언된 이름공간 아래의 **거래 문서 식별자**(발주·주문·어포인트먼트) — 없으면 답하지 않는다. */
+  declaredBizTransactionId(id) {
+    for (const ns of this.identityDeclaration()?.namespaces ?? []) {
+      const uri = bizTransactionUri(ns, id);
+      if (uri) return uri;
+    }
+    return void 0;
+  }
   produceMaterials(t) {
     if (this.producesOwnOutputs(t.kind)) return;
     const made = (this.operationSpecs.get(t.kind)?.materialSpecification ?? []).filter((m) => m.use === "produced");
@@ -6046,11 +6125,13 @@ var WmsKernel = class extends FlowEngine {
   /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
   onArrival(spec) {
     const dock = this.builtInLocation("dock", "inbound pallets land here");
-    const epc = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
+    const seq = ++this.epcSeq;
+    const epc = this.declaredObjectId(`PAL-${seq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, seq);
     const gtin = this.pickGtin(spec.content.skuMix);
     if (!gtin) return;
     const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max);
-    const po = gdtiUri(LEGACY_COMPANY_PREFIX, "401", ++this.poSeq);
+    const poSeq = ++this.poSeq;
+    const po = this.declaredBizTransactionId(`PO-${poSeq}`) ?? gdtiUri(LEGACY_COMPANY_PREFIX, this.identityDeclaration()?.documentTypes?.purchaseorder ?? "401", poSeq);
     const eventTime = this.now();
     const qtyList = [{ epcClass: gtin, quantity: qty }];
     const poTxn = [{ type: BTT.po, bizTransaction: po }];
@@ -6121,7 +6202,8 @@ var WmsKernel = class extends FlowEngine {
   /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
   createSalesOrder(lines, spec) {
     const id = `order-${++this.orderSeq}`;
-    const so = gdtiUri(LEGACY_COMPANY_PREFIX, "402", ++this.soSeq);
+    const soSeq = ++this.soSeq;
+    const so = this.declaredBizTransactionId(`SO-${soSeq}`) ?? gdtiUri(LEGACY_COMPANY_PREFIX, this.identityDeclaration()?.documentTypes?.salesorder ?? "402", soSeq);
     const requested = lines.reduce((s, l) => s + l.qty, 0);
     const order = {
       id,
@@ -6294,7 +6376,8 @@ var WmsKernel = class extends FlowEngine {
       const qty = row.qty ?? 0;
       if (qty <= 0) continue;
       this.items.delete(key);
-      const pallet = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
+      const palSeq = ++this.epcSeq;
+      const pallet = this.declaredObjectId(`PAL-${palSeq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, palSeq);
       const qtyList = [{ epcClass: m.definitionId, quantity: qty }];
       this.items.set(pallet, { epc: pallet, gtin: m.definitionId, qty, location: at, disposition: DISP.in_progress });
       const eventTime = this.now();
@@ -6308,7 +6391,8 @@ var WmsKernel = class extends FlowEngine {
   finalizeOrder(order, staging) {
     const shipDock = this.locationByType("dock-ship") ?? staging;
     const eventTime = this.now();
-    const shipment = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
+    const shpSeq = ++this.epcSeq;
+    const shipment = this.declaredObjectId(`SHP-${shpSeq}`) ?? ssccUri(LEGACY_COMPANY_PREFIX, shpSeq);
     order.shipmentEpc = shipment;
     const soTxn = [{ type: BTT.so, bizTransaction: order.bizTransaction }];
     this.aggregate(shipment, order.picked.slice(), { bizStep: BIZSTEP.packing, readPoint: staging.id, bizLocation: staging.id });
@@ -6371,18 +6455,23 @@ var YmsKernel = class extends FlowEngine {
     const doors = [...this.locations.values()].filter((n) => n.type === "dock-door").sort((a, b) => a.id.localeCompare(b.id));
     if (!gate || doors.length === 0) return;
     const inbound = kind === "appointment";
-    const epc = graiUri(LEGACY_CP, "10", ++this.epcSeq);
+    const trSeq = ++this.epcSeq;
+    const epc = this.declaredObjectId(`TRL-${trSeq}`) ?? graiUri(LEGACY_CP, this.identityDeclaration()?.documentTypes?.trailer ?? "10", trSeq);
     this.items.set(epc, { epc, location: gate.id, disposition: DISP.in_progress });
     gate.occupancy++;
     this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: YARD_BIZSTEP.arriving, disposition: DISP.in_progress, epcList: [epc], readPoint: gate.id, bizLocation: gate.id }));
     if (inbound) {
-      const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => ssccUri(LEGACY_CP, ++this.cargoSeq));
+      const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => {
+        const c = ++this.cargoSeq;
+        return this.declaredObjectId(`CGO-${c}`) ?? ssccUri(LEGACY_CP, c);
+      });
       this.trailerCargo.set(epc, cargo);
       this.aggregate(epc, cargo, { bizStep: YARD_BIZSTEP.arriving, readPoint: gate.id });
     }
     const door = doors[this.doorRR++ % doors.length];
     const id = `order-${++this.orderSeq}`;
-    const appt = gdtiUri(LEGACY_CP, "404", ++this.soSeq);
+    const apSeq = ++this.soSeq;
+    const appt = this.declaredBizTransactionId(`APPT-${apSeq}`) ?? gdtiUri(LEGACY_CP, this.identityDeclaration()?.documentTypes?.appointment ?? "404", apSeq);
     const order = {
       id,
       kind,
@@ -6575,6 +6664,15 @@ var MesKernel = class extends FlowEngine {
    * 아니다). 선언이 없는 MES 트윈은 이제 만들 수 없으므로(`loadTwinModel` 이 거절한다) `fabricated` 로
    * 판정될 일이 없다.
    */
+  /**
+   * MES 는 **생산 선언의 정체성을 먼저** 쓴다 — `ProductionSpec.identity` 가 먼저 생긴 자리다.
+   *
+   * 모델 자리(§`TwinModelDef.identity`)로 옮기면 이 override 는 사라진다. 두 자리를 동시에 읽는 것이
+   * 아니라 **하나를 고르는** 것이므로 규칙이 갈리지 않는다.
+   */
+  identityDeclaration() {
+    return this.productionSpec?.identity ?? super.identityDeclaration();
+  }
   identityGroundingView() {
     return identityGroundingOf(this.productionSpec);
   }
@@ -6620,6 +6718,42 @@ var MesKernel = class extends FlowEngine {
    * 이미 그 제품이면 no-op, 아니면 셋업(기본값, OEE 가용성 손실) + lastChangeoverKey 각인
    * (이후 그 제품 task 는 자동 셋업 생략). command → 변이 → State 델타(폐루프).
    */
+  /**
+   * **왜 대기하는지 화면에 말한다** — 자재가 모자라 확보가 미뤄진 오더.
+   *
+   * ── 왜 필요한가 (2026-08-21 실측) ─────────────────────────────────────────
+   * 확보는 전량 아니면 대기다(부분 투입을 하면 재고가 거짓이 된다). 그 거동은 옳다. 그런데 조용해서,
+   * 투입 18줄 중 6줄이 한 번도 입고되지 않은 공장에서 **오더 다섯이 영구히 대기하는 동안 화면에는
+   * 「running」이라 적혔다.** 아무 자리도 이유를 말하지 않았다.
+   *
+   * 판단만 여기서 한다 — 확인(ack)·처음 성립한 시각·사라진 조건 정리는 `computeAttentions` 가
+   * 한 곳에서 맡는다(확장점 규약).
+   *
+   * 사람이 읽는 문장은 만들지 않는다. `kind` 와 언어 중립 `params` 만 내고 문장은 표현계층이 만든다.
+   */
+  collectAttentions() {
+    const out = super.collectAttentions();
+    for (const o of this.orders.values()) {
+      const short = o.shortage;
+      if (!short?.length) continue;
+      out.push({
+        id: `material-short:${o.id}`,
+        kind: "material-short",
+        /* 한 줄이 모자란 것과 여러 줄이 모자란 것은 할 일이 다르다 — 여럿이면 자재 공급 자체가 문제다. */
+        severity: short.length > 1 ? "high" : "medium",
+        anchor: { orderId: o.id },
+        params: {
+          /* 모자란 줄 수와 투입 줄 수 — 「6/18」이 「하나 모자람」과 다른 상황임을 한눈에 말한다. */
+          shortLines: short.length,
+          /* 자재 키를 그대로 낸다. 커널이 사람이 읽는 이름을 만들지 않는다 — 이름은 모델이 갖는다. */
+          materials: short.map((x) => x.material).join(", "),
+          need: short.reduce((n, x) => n + x.need, 0),
+          have: short.reduce((n, x) => n + x.have, 0)
+        }
+      });
+    }
+    return out;
+  }
   handleCommand(cmd) {
     if (cmd.type === MES_CMD.changeover) {
       const a = cmd.args;
@@ -6862,6 +6996,7 @@ var MesKernel = class extends FlowEngine {
     }
     const rc = this.recipeDef(o);
     const picks = [];
+    const short = [];
     const locsOfType = /* @__PURE__ */ new Map();
     for (const n of this.locations.values()) {
       const bin = locsOfType.get(n.type);
@@ -6878,9 +7013,18 @@ var MesKernel = class extends FlowEngine {
         }
       }
       const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
-      if (chosen.length < line.qty) return;
+      if (chosen.length < line.qty) {
+        short.push({ material: line.material, need: line.qty, have: chosen.length });
+        continue;
+      }
       picks.push(...chosen);
     }
+    if (short.length) {
+      o.shortage = short;
+      this.emitOrder(o);
+      return;
+    }
+    if (o.shortage) delete o.shortage;
     for (const epc of picks) o.allocated.push(epc);
     this.reserve(picks, MES_BIZSTEP.producing);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
@@ -8073,7 +8217,7 @@ function ingestOperationalRecords(records, opts) {
 // src/energy-attribution.ts
 var near = (a, b, eps = 1e-9) => Math.abs(a - b) <= eps;
 function attributeEnergy(opts) {
-  const byId = new Map(opts.consumers.map((c) => [c.id, c]));
+  const byId2 = new Map(opts.consumers.map((c) => [c.id, c]));
   const dedicated = /* @__PURE__ */ new Map();
   for (const c of opts.consumers) if (c.meterId) dedicated.set(c.meterId, c);
   const shares = [];
@@ -8090,7 +8234,7 @@ function attributeEnergy(opts) {
     }
     if (pool.overhead) {
       const alloc = opts.overheadAllocation;
-      const targets = (alloc?.processConsumerIds ?? []).map((id) => byId.get(id)).filter((c) => !!c);
+      const targets = (alloc?.processConsumerIds ?? []).map((id) => byId2.get(id)).filter((c) => !!c);
       const wOf = (c) => alloc?.weightKind === "equal" ? 1 : Number.isFinite(Number(c.weight)) && Number(c.weight) > 0 ? Number(c.weight) : 0;
       const sharing2 = alloc?.weightKind === "equal" ? targets : targets.filter((c) => wOf(c) > 0);
       const ws = sharing2.map(wOf);
@@ -8116,7 +8260,7 @@ function attributeEnergy(opts) {
       });
       continue;
     }
-    const covered = (pool.consumerIds ?? []).map((id) => byId.get(id)).filter((c) => !!c);
+    const covered = (pool.consumerIds ?? []).map((id) => byId2.get(id)).filter((c) => !!c);
     if (!covered.length) {
       unattributed.push({ poolMeterId: pool.meterId, kWh, reason: pool.remainder ? "not-submetered" : "no-consumers" });
       continue;
@@ -8416,6 +8560,7 @@ function retiredVocabularyIn(line) {
   monteCarloForecast,
   monteCarloForecastAsync,
   objectEvent,
+  objectUri,
   offCalendarAt,
   offCalendarReasonAt,
   operationalKindOf,

package/package.json

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