@operato/twin-kernel 0.7.37 → 0.7.39

package/dist/contract.d.ts

@@ -1245,6 +1245,20 @@ export interface Attention {
 /** 계량 지점의 마지막 관측 — 값이 없으면 **모르는 것이다**(0 이 아니다). */
 export interface MeterPointState {
     id: string;
+    /**
+     * 이 계량 지점이 **모델에 선언된 것인가, 계측이 처음 데려온 것인가** (자리와 같은 어휘).
+     *
+     * ── 왜 표시해야 하나 ───────────────────────────────────────────────────────
+     * 계측은 모르는 `meterId` 를 만나면 **조용히 새 지점을 만든다.** 그 kW 는 그 현장의 수요·피크에
+     * 그대로 더해지므로(그것이 옳다 — 빼면 「계약 안쪽」이라는 더 위험한 거짓이 된다), 표시가 없으면
+     * 커넥터 매핑에서 id 를 한 글자 틀린 것과 정상을 구별할 수 없다. 그때 진짜 계량기는 조용히 멈추고
+     * 유령이 누적되며, **숫자는 그럴듯하고 틀린다.** 요금 판정까지 가는 축이라 자리 오타보다 무겁다.
+     *
+     * `'master'` = 모델(설비 선언)에 있는 계량기. `'observed'` = 계측만 데려온 계량기.
+     * 옛 스냅샷에는 이 칸이 없다(`undefined`) — 「선언되었다」로 읽지 말 것. 선언 여부의 정본은 모델이고,
+     * 커널은 표본이 올 때마다 이 값을 다시 맞춘다.
+     */
+    origin?: 'master' | 'observed';
     kW?: number;
     /** 누적 전력량(원천이 준 적산값) — 우리가 적분한 값이 아니다. */
     kWh?: number;
@@ -1265,6 +1279,18 @@ export interface MeterPointState {
 export interface DemandWindowState {
     startMs: number;
     endMs: number;
+    /**
+     * `maxKW` 가 찍힌 **그 순간**의, **모델이 선언한** 뿌리 계량기들만의 합.
+     *
+     * `maxKW` 는 모르는 계량기까지 포함한 합이다(그것을 빼면 부하가 조용히 작아지고, 작아진 부하는
+     * 「계약 안쪽」이라는 더 위험한 거짓을 만든다). 그러나 그 값 하나만 내면 반대쪽 거짓이 생긴다 —
+     * 오타로 생긴 유령 계량기가 계약 초과를 만들어도 화면은 그것을 진짜 초과로 말한다.
+     *
+     * 그래서 **두 벌을 낸다.** 화면은 「선언된 것으로는 82%, 정체 모를 계량기까지 넣으면 104%」라고
+     * 말할 수 있다 — 빼서 정확한 척하지 않고, 더해서 뭉개지도 않는다. 두 값이 같으면 모든 뿌리가
+     * 선언된 것이고, 그것도 사실이다. 잰 적이 없으면 `undefined` 다(0 이 아니다).
+     */
+    maxDeclaredKW?: number;
     /**
      * 이 구간의 **최대가 찍힌 순간**의 지점별 kW — 요금이 걸린 수는 kW 다.
      *
@@ -1397,6 +1423,19 @@ export interface StateSnapshot {
     tasks: TaskState[];
     orders: OrderState[];
     attentions?: Attention[];
+    /**
+     * **담을 줄 몰라 반영하지 못한 사실** — 종류별 수(관측 구동에서만 나온다).
+     *
+     * 관측 리듀서는 오래전부터 이것을 세어 왔다. 그런데 **스냅샷이 그 값을 떨어뜨렸다** — 그래서
+     * 이미 그것을 읽도록 쓰여 있던 정합성 검사(`twin-unhandled-vocabulary`)는 미러에서 영원히
+     * 조용했다(2026-08-19 실측). 세기만 하고 아무도 못 보는 값은 없는 것과 같다.
+     */
+    unhandled?: {
+        eventType: string;
+        count: number;
+        firstAtMs?: number;
+        lastAtMs?: number;
+    }[];
     /**
      * 확인(ack)해 둔 주목 신호 id — **상태에서 파생되지 않는 유일한 축.**
      *

package/dist/ems-kernel.js

@@ -286,6 +286,20 @@ export class EmsKernel extends FlowEngine {
         this.openWindow(atMs);
         const kW = Number.isFinite(Number(d?.kW)) ? Number(d.kW) : undefined;
         const point = this.points.get(id) ?? { id, samplesInWindow: 0 };
+        /*
+         * ── 이 계량기가 모델에 있는가를 **표시한다** (2026-08-20) ────────────────────
+         *
+         * 모르는 `meterId` 는 여기서 조용히 새 지점이 된다. 그 kW 는 수요·피크에 그대로 더해지는데(그것이
+         * 옳다 — 아래 뿌리 합 주석), 표시가 없으면 커넥터 매핑의 한 글자 오타와 정상을 구별할 수 없다.
+         * 그때 진짜 계량기는 조용히 멈추고 유령이 누적되며, 숫자는 그럴듯하고 틀린다.
+         *
+         * 바로 옆 `applyEquipmentEnergy` 는 같은 상황을 이미 세어 두고 있었다(`unknownEquipmentReports`).
+         * 계량기만 그 규율에서 빠져 있었다 — 요금까지 가는 축이라 오히려 더 무거운 자리다.
+         *
+         * **표본마다 다시 맞춘다**: 선언 여부의 정본은 모델이고, 모델은 채택(adopt)으로 늘어난다. 한 번
+         * 찍고 두면 나중에 선언된 계량기가 영원히 `observed` 로 남는다. 자리(`origin: 'observed'`)와 같은 어휘다.
+         */
+        point.origin = this.equipment.has(id) ? 'master' : 'observed';
         /* 늦게 온 옛 표본이 최신 관측을 덮지 않게 — 상위 커널의 `stale` 판정과 같은 규율. */
         if (point.atMs === undefined || atMs >= point.atMs) {
             point.atMs = atMs;
@@ -324,9 +338,33 @@ export class EmsKernel extends FlowEngine {
              * 조용히 작아지고, 작아진 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다.
              */
             const roots = this.rootMeterIds();
-            const total = [...this.points.values()].reduce((sum, p) => sum + (roots.has(p.id) ? p.kW ?? 0 : 0), 0);
+            /*
+             * ── 합을 **두 벌** 낸다 (2026-08-20) ──────────────────────────────────────
+             *
+             * 전부의 합(`total`)이 요금 판정의 근거다 — 모르는 계량기를 빼면 부하가 조용히 작아지고, 작아진
+             * 부하는 「계약 안쪽」이라는 더 위험한 거짓을 만든다.
+             *
+             * 그런데 그 값 하나만 내면 반대쪽 거짓이 생긴다: 오타로 생긴 유령 계량기가 만든 초과를 화면이
+             * 진짜 초과로 말한다. 그래서 **선언된 뿌리만의 합**도 같은 순간에 잰다. 화면은 두 수를 나란히
+             * 놓고 「선언된 것으로는 82%, 정체 모를 계량기까지 넣으면 104%」라고 말할 수 있다.
+             *
+             * 선언 여부는 **모델에 직접 묻는다**(`this.equipment`). 지점에 찍힌 `origin` 을 쓰지 않는 이유는
+             * 옛 스냅샷에서 이어받은 지점에는 그 칸이 없고, 없는 것을 「선언되었다」로 읽으면 이 값이 조용히
+             * 전부의 합과 같아지기 때문이다.
+             */
+            let total = 0;
+            let declared = 0;
+            for (const p of this.points.values()) {
+                if (!roots.has(p.id))
+                    continue;
+                const v = p.kW ?? 0;
+                total += v;
+                if (this.equipment.has(p.id))
+                    declared += v;
+            }
             if (w.maxKW === undefined || total > w.maxKW) {
                 w.maxKW = total;
+                w.maxDeclaredKW = declared;
                 /*
                  * ── 피크가 갱신된 **그 순간**의 지점별 kW 를 붙잡는다 (2026-08-18) ─────────
                  *

package/dist/flow-engine.js

@@ -1086,6 +1086,11 @@ export class FlowEngine {
             /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
              * 다른 커널을 주입하면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
              * 델타에서 왔으므로 갖고 있었다 — 같은 계약을 두 구동이 다르게 채우던 자리). */
+            /* 관측이 담지 못한 사실을 그대로 내보낸다 — 리듀서가 세고 있어도 여기서 떨어뜨리면 아무도 못 본다. */
+            ...(() => {
+                const u = this.observer?.snapshot?.().unhandled;
+                return u?.length ? { unhandled: u } : {};
+            })(),
             tasks: [...this.tasks.values()].map(t => ({
                 id: t.id, kind: t.kind, status: t.status, itemRefs: [t.itemEpc],
                 fromNode: t.fromNode, toNode: t.toNode, resourceRef: t.resource ?? undefined, orderId: t.orderId,

package/dist/observed-reducer.d.ts

@@ -106,6 +106,23 @@ export interface ReducerCheckpoint {
         child: string;
         parent: string;
     }[];
+    /** 수량으로 담긴 내용 — 채워 넣은 것과, 팔레트를 아직 못 본 채 보류한 것. */
+    qtyAggregation?: {
+        parent: string;
+        quantities: {
+            epcClass?: string;
+            quantity?: number;
+            uom?: string;
+        }[];
+    }[];
+    pendingQuantities?: {
+        parent: string;
+        quantities: {
+            epcClass?: string;
+            quantity?: number;
+            uom?: string;
+        }[];
+    }[];
     tasks: TaskState[];
     equipment: EquipmentState[];
     persons: PersonState[];
@@ -132,6 +149,15 @@ export declare class ObservedReducer {
     private aggregation;
     /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
     private pendingParent;
+    /**
+     * 팔레트가 **담고 있는 것**(클래스 + 수량) — 바코드 없이 수량만 실린 담김.
+     *
+     *  · `qtyAggregation`    — 우리가 그 팔레트 물품에 채워 넣은 내용(풀릴 때 되돌릴 근거).
+     *  · `pendingQuantities` — 담김이 먼저 오고 그 팔레트를 아직 관측하지 못한 경우. 물품을 지어내지
+     *                          않고 보류해 두었다가, 관측되는 순간 붙인다(`pendingParent` 와 같은 규율).
+     */
+    private qtyAggregation;
+    private pendingQuantities;
     private tasks;
     private equipment;
     private persons;
@@ -217,8 +243,21 @@ export declare class ObservedReducer {
     private observedAtMs?;
     /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
     apply(e: CanonicalEnvelope): void;
-    /** 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다. */
+    /**
+     * 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다.
+     *
+     * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
+     * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
+     */
     private noteUnhandled;
+    /**
+     * 팔레트 물품에 **담고 있는 것**을 채운다 — 이미 아는 값을 덮지 않는다.
+     *
+     * 팔레트가 자기 품번·수량을 이미 들고 있으면(관측이 그렇게 말했으면) 담김 선언이 그것을 밀어내지
+     * 않는다. 비어 있던 자리만 채운다 — 「모른다」를 채우는 것이 이 작업의 목적이고, 아는 것을 바꾸는
+     * 것은 아니다.
+     */
+    private withContainedQuantity;
     private applyEpcis;
     /**
      * 물품 한 건 병합 — **아는 것을 잃지 않는다.** 새로 온 값이 우선, 없으면 기존 값 유지.

package/dist/observed-reducer.js

@@ -45,6 +45,15 @@ export class ObservedReducer {
     aggregation = new Map();
     /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
     pendingParent = new Map(); // 자식 EPC → 부모(물류단위)
+    /**
+     * 팔레트가 **담고 있는 것**(클래스 + 수량) — 바코드 없이 수량만 실린 담김.
+     *
+     *  · `qtyAggregation`    — 우리가 그 팔레트 물품에 채워 넣은 내용(풀릴 때 되돌릴 근거).
+     *  · `pendingQuantities` — 담김이 먼저 오고 그 팔레트를 아직 관측하지 못한 경우. 물품을 지어내지
+     *                          않고 보류해 두었다가, 관측되는 순간 붙인다(`pendingParent` 와 같은 규율).
+     */
+    qtyAggregation = new Map();
+    pendingQuantities = new Map();
     tasks = new Map();
     equipment = new Map();
     persons = new Map();
@@ -371,10 +380,16 @@ export class ObservedReducer {
                 this.noteUnhandled(e);
         }
     }
-    /** 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다. */
-    noteUnhandled(e) {
+    /**
+     * 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다.
+     *
+     * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
+     * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
+     */
+    noteUnhandled(e, key) {
         const at = Date.parse(String(e.eventTime ?? ''));
-        const cur = this.unhandled.get(e.eventType) ?? { count: 0 };
+        const name = key ?? e.eventType;
+        const cur = this.unhandled.get(name) ?? { count: 0 };
         cur.count++;
         if (Number.isFinite(at)) {
             if (cur.firstAtMs === undefined || at < cur.firstAtMs)
@@ -382,7 +397,29 @@ export class ObservedReducer {
             if (cur.lastAtMs === undefined || at > cur.lastAtMs)
                 cur.lastAtMs = at;
         }
-        this.unhandled.set(e.eventType, cur);
+        this.unhandled.set(name, cur);
+    }
+    /**
+     * 팔레트 물품에 **담고 있는 것**을 채운다 — 이미 아는 값을 덮지 않는다.
+     *
+     * 팔레트가 자기 품번·수량을 이미 들고 있으면(관측이 그렇게 말했으면) 담김 선언이 그것을 밀어내지
+     * 않는다. 비어 있던 자리만 채운다 — 「모른다」를 채우는 것이 이 작업의 목적이고, 아는 것을 바꾸는
+     * 것은 아니다.
+     */
+    withContainedQuantity(cur, q, all) {
+        const parsed = q.epcClass ? parseEpc(q.epcClass) : undefined;
+        const declared = all.filter(x => typeof x.quantity === 'number');
+        return {
+            ...cur,
+            gtin: cur.gtin ?? q.epcClass,
+            gtinKey: cur.gtinKey ?? parsed?.gtinKey,
+            /* 관측이 준 수량이 있으면 그대로 둔다. 없으면(팔레트 하나로 세어 `1` 이던 자리) 내용의 수량이 답이다. */
+            qty: cur.qty !== undefined && cur.qty !== 1 ? cur.qty : q.quantity,
+            uom: cur.uom ?? q.uom,
+            /* 단위가 여럿일 때만 목록을 든다(하나면 `qty`/`uom` 이 무손실로 들고 있다 — 위 `upsert` 와 같은 규율). */
+            quantities: cur.quantities ?? (declared.length >= 2 ? declared.map(x => ({ value: x.quantity, ...(x.uom ? { uom: x.uom } : {}) })) : undefined),
+            lot: cur.lot ?? parsed?.lot
+        };
     }
     applyEpcis(ev, envelope) {
         /* 정정 선언이 붙은 이벤트는 **새 사실이 아니다** — 앞선 이벤트를 취소·수정하는 선언이다.
@@ -399,6 +436,46 @@ export class ObservedReducer {
             return;
         }
         if (ev.type === 'AggregationEvent') {
+            /*
+             * ── 바코드 없이 **수량만** 실린 담김 (2026-08-19) ────────────────────────
+             * 실제 창고는 박스마다 바코드를 붙이지 않는다. 팔레트 하나에 「이 품번 40개」로 입고하는 것이
+             * 훨씬 흔하고, 표준도 그 자리를 둔다(`childQuantityList`: 클래스 + 수량).
+             *
+             * 그런데 여기는 **낱개 자식만** 반영했다. 그래서 미러는 그 팔레트를 `{epc, location, qty: 1}` 로
+             * 들었다 — 실측: 품번도 없고 40개도 없다. 화면에는 「팔레트 1개」만 보이고 그 안의 40개는 재고
+             * 집계에서 통째로 빠진다. 실 WMS 를 붙이면 바로 부딪히는 자리다.
+             *
+             * **어떻게 담나**: 시뮬 커널이 같은 입고를 다루는 방식과 맞춘다 — 그쪽은 팔레트 물품 자신에
+             * 품번과 수량을 싣는다(`items.set(epc, { epc, gtin, qty … })`). 그래서 여기서도 팔레트 물품에
+             * 채운다. 새 필드를 만들지 않으므로 **기존 재고 집계가 그대로 센다**(필드만 만들고 아무도 읽지
+             * 않는 상태를 이 프로젝트는 결함으로 본다). 두 구동이 같은 모양을 들게 되는 것이 덤이다.
+             *
+             * **못 하는 경우는 밝힌다**: 한 팔레트에 품번이 둘 이상이면 이 모양으로 표현할 수 없다(하나를
+             * 골라 채우면 나머지를 지우는 것이다). 그때는 채우지 않고 `unhandled` 로 센다 — 조용히 버리지
+             * 않는다. 그 어휘를 담으려면 상태에 「담고 있는 것들」이 따로 필요하고, 그것은 별 결정이다.
+             */
+            if (ev.action === 'ADD' && ev.childQuantityList?.length) {
+                const classes = new Set(ev.childQuantityList.map(q => q.epcClass));
+                if (classes.size > 1) {
+                    /* 여러 품번이 한 팔레트에 — 지금 상태로는 표현할 수 없다. 세어서 드러낸다. */
+                    if (envelope)
+                        this.noteUnhandled(envelope, 'aggregation-mixed-classes');
+                }
+                else {
+                    const q = ev.childQuantityList[0];
+                    const cur = this.items.get(ev.parentID);
+                    /*
+                     * **관측하지 못한 팔레트를 지어내지 않는다** — 담김은 *어디 있는지*를 말하지 않는다.
+                     * 그 팔레트가 관측되면(ObjectEvent) 그때 위치와 함께 서고, 담김은 보류해 두었다가 붙인다.
+                     */
+                    if (!cur)
+                        this.pendingQuantities.set(ev.parentID, [...ev.childQuantityList]);
+                    else {
+                        this.items.set(cur.subLotId ?? cur.epc, this.withContainedQuantity(cur, q, ev.childQuantityList));
+                        this.qtyAggregation.set(ev.parentID, [...ev.childQuantityList]);
+                    }
+                }
+            }
             if (ev.action === 'ADD' && ev.childEPCs?.length) {
                 this.aggregation.set(ev.parentID, [...ev.childEPCs]);
                 /* 조립 관계를 물품에도 주입한다 — 예전에는 내부 맵에만 두고 밖으로 내보내지 않아, 3D 가
@@ -424,6 +501,16 @@ export class ObservedReducer {
                     this.pendingParent.delete(child);
                 }
                 this.aggregation.delete(ev.parentID);
+                /* 수량으로 담겼던 것을 풀면 그 팔레트는 **비게 된다** — 우리가 채운 것만 되돌린다(원래
+                   팔레트 자신의 수량이었다면 건드리지 않는다). */
+                if (this.qtyAggregation.delete(ev.parentID)) {
+                    const cur = this.items.get(ev.parentID);
+                    if (cur) {
+                        const { gtin, gtinKey, qty, uom, quantities, lot, ...rest } = cur;
+                        this.items.set(cur.subLotId ?? cur.epc, { ...rest, qty: 1 });
+                    }
+                }
+                this.pendingQuantities.delete(ev.parentID);
             }
             return;
         }
@@ -512,7 +599,9 @@ export class ObservedReducer {
         const parsedSelf = parseEpc(epc);
         /* `gtin` 은 **클래스 URI 원문**이다(오더 매칭이 이 값을 쓴다 — 뜻을 바꾸면 조용히 안 맞는다).
          * 파서로 뜯은 품번 키·로트는 **별도 필드**로 얹는다. */
-        const classUri = q?.epcClass ?? (parsedSelf.instance ? undefined : epc);
+        /* 담김이 먼저 온 팔레트는 그 내용의 클래스가 곧 이 물품의 품번이다(시뮬이 같은 입고를 그렇게 든다). */
+        const pendingQty = this.pendingQuantities.get(epc);
+        const classUri = q?.epcClass ?? pendingQty?.[0]?.epcClass ?? (parsedSelf.instance ? undefined : epc);
         return {
             epc,
             ...(subLotId ? { subLotId } : {}),
@@ -521,8 +610,12 @@ export class ObservedReducer {
             location: patch.location ?? cur?.location ?? '',
             disposition: patch.disposition ?? cur?.disposition,
             parent: cur?.parent ?? this.pendingParent.get(epc),
-            qty: q?.quantity ?? cur?.qty,
-            uom: q?.uom ?? cur?.uom,
+            /*
+             * 관측이 수량을 말하지 않았는데 **담김이 먼저 와 있었다면** 그 내용이 답이다(바코드 없이 수량만
+             * 실린 팔레트). 보류해 둔 것을 여기서 붙인다 — 위 `parent` 와 같은 규율이다.
+             */
+            qty: q?.quantity ?? this.pendingQuantities.get(epc)?.[0]?.quantity ?? cur?.qty,
+            uom: q?.uom ?? this.pendingQuantities.get(epc)?.[0]?.uom ?? cur?.uom,
             /*
              * 선언된 수량 전부 — 값이 없는 항목은 담지 않는다(모름을 0 으로 만들지 않는다).
              *
@@ -656,6 +749,9 @@ export class ObservedReducer {
             items: [...this.items.values()].map(i => ({ ...i })),
             aggregation: [...this.aggregation.entries()].map(([parent, children]) => ({ parent, children: [...children] })),
             pendingParent: [...this.pendingParent.entries()].map(([child, parent]) => ({ child, parent })),
+            /* 수량으로 담긴 것도 이어받는다 — 되풀어 주지 않는 축이다(원천은 담김을 다시 말해 주지 않는다). */
+            qtyAggregation: [...this.qtyAggregation.entries()].map(([parent, quantities]) => ({ parent, quantities })),
+            pendingQuantities: [...this.pendingQuantities.entries()].map(([parent, quantities]) => ({ parent, quantities })),
             tasks: [...this.tasks.values()].map(t => ({ ...t })),
             equipment: [...this.equipment.values()].map(m => ({ ...m })),
             persons: [...this.persons.values()].map(x => ({ ...x })),
@@ -677,6 +773,8 @@ export class ObservedReducer {
         this.items = new Map((cp?.items ?? []).map(i => [i.epc, { ...i }]));
         this.aggregation = new Map((cp?.aggregation ?? []).map(a => [a.parent, [...a.children]]));
         this.pendingParent = new Map((cp?.pendingParent ?? []).map(x => [x.child, x.parent]));
+        this.qtyAggregation = new Map((cp?.qtyAggregation ?? []).map(x => [x.parent, x.quantities]));
+        this.pendingQuantities = new Map((cp?.pendingQuantities ?? []).map(x => [x.parent, x.quantities]));
         this.tasks = new Map((cp?.tasks ?? []).map(t => [t.id, { ...t }]));
         this.equipment = new Map((cp?.equipment ?? []).map(m => [m.id, { ...m }]));
         this.persons = new Map((cp?.persons ?? []).map(x => [x.id, { ...x }]));

package/dist-cjs/index.cjs

@@ -1091,6 +1091,15 @@ var ObservedReducer = class {
   /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
   pendingParent = /* @__PURE__ */ new Map();
   // 자식 EPC → 부모(물류단위)
+  /**
+   * 팔레트가 **담고 있는 것**(클래스 + 수량) — 바코드 없이 수량만 실린 담김.
+   *
+   *  · `qtyAggregation`    — 우리가 그 팔레트 물품에 채워 넣은 내용(풀릴 때 되돌릴 근거).
+   *  · `pendingQuantities` — 담김이 먼저 오고 그 팔레트를 아직 관측하지 못한 경우. 물품을 지어내지
+   *                          않고 보류해 두었다가, 관측되는 순간 붙인다(`pendingParent` 와 같은 규율).
+   */
+  qtyAggregation = /* @__PURE__ */ new Map();
+  pendingQuantities = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   equipment = /* @__PURE__ */ new Map();
   persons = /* @__PURE__ */ new Map();
@@ -1381,16 +1390,44 @@ var ObservedReducer = class {
         this.noteUnhandled(e);
     }
   }
-  /** 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다. */
-  noteUnhandled(e) {
+  /**
+   * 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다.
+   *
+   * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
+   * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
+   */
+  noteUnhandled(e, key) {
     const at = Date.parse(String(e.eventTime ?? ""));
-    const cur = this.unhandled.get(e.eventType) ?? { count: 0 };
+    const name = key ?? e.eventType;
+    const cur = this.unhandled.get(name) ?? { count: 0 };
     cur.count++;
     if (Number.isFinite(at)) {
       if (cur.firstAtMs === void 0 || at < cur.firstAtMs) cur.firstAtMs = at;
       if (cur.lastAtMs === void 0 || at > cur.lastAtMs) cur.lastAtMs = at;
     }
-    this.unhandled.set(e.eventType, cur);
+    this.unhandled.set(name, cur);
+  }
+  /**
+   * 팔레트 물품에 **담고 있는 것**을 채운다 — 이미 아는 값을 덮지 않는다.
+   *
+   * 팔레트가 자기 품번·수량을 이미 들고 있으면(관측이 그렇게 말했으면) 담김 선언이 그것을 밀어내지
+   * 않는다. 비어 있던 자리만 채운다 — 「모른다」를 채우는 것이 이 작업의 목적이고, 아는 것을 바꾸는
+   * 것은 아니다.
+   */
+  withContainedQuantity(cur, q, all) {
+    const parsed = q.epcClass ? parseEpc(q.epcClass) : void 0;
+    const declared = all.filter((x) => typeof x.quantity === "number");
+    return {
+      ...cur,
+      gtin: cur.gtin ?? q.epcClass,
+      gtinKey: cur.gtinKey ?? parsed?.gtinKey,
+      /* 관측이 준 수량이 있으면 그대로 둔다. 없으면(팔레트 하나로 세어 `1` 이던 자리) 내용의 수량이 답이다. */
+      qty: cur.qty !== void 0 && cur.qty !== 1 ? cur.qty : q.quantity,
+      uom: cur.uom ?? q.uom,
+      /* 단위가 여럿일 때만 목록을 든다(하나면 `qty`/`uom` 이 무손실로 들고 있다 — 위 `upsert` 와 같은 규율). */
+      quantities: cur.quantities ?? (declared.length >= 2 ? declared.map((x) => ({ value: x.quantity, ...x.uom ? { uom: x.uom } : {} })) : void 0),
+      lot: cur.lot ?? parsed?.lot
+    };
   }
   applyEpcis(ev, envelope) {
     if (ev.errorDeclaration) {
@@ -1403,6 +1440,20 @@ var ObservedReducer = class {
       return;
     }
     if (ev.type === "AggregationEvent") {
+      if (ev.action === "ADD" && ev.childQuantityList?.length) {
+        const classes = new Set(ev.childQuantityList.map((q2) => q2.epcClass));
+        if (classes.size > 1) {
+          if (envelope) this.noteUnhandled(envelope, "aggregation-mixed-classes");
+        } else {
+          const q2 = ev.childQuantityList[0];
+          const cur = this.items.get(ev.parentID);
+          if (!cur) this.pendingQuantities.set(ev.parentID, [...ev.childQuantityList]);
+          else {
+            this.items.set(cur.subLotId ?? cur.epc, this.withContainedQuantity(cur, q2, ev.childQuantityList));
+            this.qtyAggregation.set(ev.parentID, [...ev.childQuantityList]);
+          }
+        }
+      }
       if (ev.action === "ADD" && ev.childEPCs?.length) {
         this.aggregation.set(ev.parentID, [...ev.childEPCs]);
         for (const child of ev.childEPCs) {
@@ -1420,6 +1471,14 @@ var ObservedReducer = class {
           this.pendingParent.delete(child);
         }
         this.aggregation.delete(ev.parentID);
+        if (this.qtyAggregation.delete(ev.parentID)) {
+          const cur = this.items.get(ev.parentID);
+          if (cur) {
+            const { gtin, gtinKey, qty, uom, quantities, lot, ...rest } = cur;
+            this.items.set(cur.subLotId ?? cur.epc, { ...rest, qty: 1 });
+          }
+        }
+        this.pendingQuantities.delete(ev.parentID);
       }
       return;
     }
@@ -1477,7 +1536,8 @@ var ObservedReducer = class {
     const cur = this.items.get(subLotId ?? epc);
     const parsedClass = q?.epcClass ? parseEpc(q.epcClass) : void 0;
     const parsedSelf = parseEpc(epc);
-    const classUri = q?.epcClass ?? (parsedSelf.instance ? void 0 : epc);
+    const pendingQty = this.pendingQuantities.get(epc);
+    const classUri = q?.epcClass ?? pendingQty?.[0]?.epcClass ?? (parsedSelf.instance ? void 0 : epc);
     return {
       epc,
       ...subLotId ? { subLotId } : {},
@@ -1486,8 +1546,12 @@ var ObservedReducer = class {
       location: patch.location ?? cur?.location ?? "",
       disposition: patch.disposition ?? cur?.disposition,
       parent: cur?.parent ?? this.pendingParent.get(epc),
-      qty: q?.quantity ?? cur?.qty,
-      uom: q?.uom ?? cur?.uom,
+      /*
+       * 관측이 수량을 말하지 않았는데 **담김이 먼저 와 있었다면** 그 내용이 답이다(바코드 없이 수량만
+       * 실린 팔레트). 보류해 둔 것을 여기서 붙인다 — 위 `parent` 와 같은 규율이다.
+       */
+      qty: q?.quantity ?? this.pendingQuantities.get(epc)?.[0]?.quantity ?? cur?.qty,
+      uom: q?.uom ?? this.pendingQuantities.get(epc)?.[0]?.uom ?? cur?.uom,
       /*
        * 선언된 수량 전부 — 값이 없는 항목은 담지 않는다(모름을 0 으로 만들지 않는다).
        *
@@ -1615,6 +1679,9 @@ var ObservedReducer = class {
       items: [...this.items.values()].map((i) => ({ ...i })),
       aggregation: [...this.aggregation.entries()].map(([parent, children]) => ({ parent, children: [...children] })),
       pendingParent: [...this.pendingParent.entries()].map(([child, parent]) => ({ child, parent })),
+      /* 수량으로 담긴 것도 이어받는다 — 되풀어 주지 않는 축이다(원천은 담김을 다시 말해 주지 않는다). */
+      qtyAggregation: [...this.qtyAggregation.entries()].map(([parent, quantities]) => ({ parent, quantities })),
+      pendingQuantities: [...this.pendingQuantities.entries()].map(([parent, quantities]) => ({ parent, quantities })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
       equipment: [...this.equipment.values()].map((m) => ({ ...m })),
       persons: [...this.persons.values()].map((x) => ({ ...x })),
@@ -1636,6 +1703,8 @@ var ObservedReducer = class {
     this.items = new Map((cp?.items ?? []).map((i) => [i.epc, { ...i }]));
     this.aggregation = new Map((cp?.aggregation ?? []).map((a) => [a.parent, [...a.children]]));
     this.pendingParent = new Map((cp?.pendingParent ?? []).map((x) => [x.child, x.parent]));
+    this.qtyAggregation = new Map((cp?.qtyAggregation ?? []).map((x) => [x.parent, x.quantities]));
+    this.pendingQuantities = new Map((cp?.pendingQuantities ?? []).map((x) => [x.parent, x.quantities]));
     this.tasks = new Map((cp?.tasks ?? []).map((t) => [t.id, { ...t }]));
     this.equipment = new Map((cp?.equipment ?? []).map((m) => [m.id, { ...m }]));
     this.persons = new Map((cp?.persons ?? []).map((x) => [x.id, { ...x }]));
@@ -3916,6 +3985,11 @@ var FlowEngine = class {
       /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
        * 다른 커널을 주입하면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
        * 델타에서 왔으므로 갖고 있었다 — 같은 계약을 두 구동이 다르게 채우던 자리). */
+      /* 관측이 담지 못한 사실을 그대로 내보낸다 — 리듀서가 세고 있어도 여기서 떨어뜨리면 아무도 못 본다. */
+      ...(() => {
+        const u = this.observer?.snapshot?.().unhandled;
+        return u?.length ? { unhandled: u } : {};
+      })(),
       tasks: [...this.tasks.values()].map((t) => ({
         id: t.id,
         kind: t.kind,
@@ -6606,6 +6680,7 @@ var EmsKernel = class extends FlowEngine {
     this.openWindow(atMs);
     const kW = Number.isFinite(Number(d?.kW)) ? Number(d.kW) : void 0;
     const point = this.points.get(id) ?? { id, samplesInWindow: 0 };
+    point.origin = this.equipment.has(id) ? "master" : "observed";
     if (point.atMs === void 0 || atMs >= point.atMs) {
       point.atMs = atMs;
       if (kW !== void 0) point.kW = kW;
@@ -6618,9 +6693,17 @@ var EmsKernel = class extends FlowEngine {
     const w = this.open;
     if (kW !== void 0) {
       const roots = this.rootMeterIds();
-      const total = [...this.points.values()].reduce((sum, p) => sum + (roots.has(p.id) ? p.kW ?? 0 : 0), 0);
+      let total = 0;
+      let declared = 0;
+      for (const p of this.points.values()) {
+        if (!roots.has(p.id)) continue;
+        const v = p.kW ?? 0;
+        total += v;
+        if (this.equipment.has(p.id)) declared += v;
+      }
       if (w.maxKW === void 0 || total > w.maxKW) {
         w.maxKW = total;
+        w.maxDeclaredKW = declared;
         w.pointsAtPeak = [...this.points.values()].filter((p) => Number.isFinite(Number(p.kW))).map((p) => ({ id: p.id, kW: Number(p.kW) }));
       }
       w.samples++;

package/package.json

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