@operato/twin-kernel 0.9.0 → 0.10.1

package/dist/observed-reducer.d.ts

@@ -1,4 +1,4 @@
-import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift } from '@operato/ops-contract';
+import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift, DispositionFact } from '@operato/ops-contract';
 import { type VocabularyElement } from '@operato/ops-contract';
 interface ProjItem {
     epc: string;
@@ -8,7 +8,10 @@ interface ProjItem {
     gtinKey?: string;
     lot?: string;
     location: string;
+    /** EPCIS 의 처지(`urn:epcglobal:cbv:disp:…`). 아래 `nonconformance` 와 다른 뜻이다. */
     disposition?: string;
+    /** ISA-95 의 부적합 처분 — 사람이 정한 결정. 로트 전체의 사실이라 부분마다 같은 값이 앉는다. */
+    nonconformance?: DispositionFact;
     parent?: string;
     qty?: number;
     uom?: string;
@@ -152,6 +155,23 @@ export interface ReducerCheckpoint {
         firstAtMs?: number;
         lastAtMs?: number;
     }[];
+    /**
+     * 설비마다 쌓은 OEE 계수기 — 산출은 `quality`, 시간은 `equipment-period` 에서 온다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장해야 한다. 저장하지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+     * 사라지고 가동률이 그 순간부터 다시 세어진다.
+     */
+    oeeCounters?: {
+        id: string;
+        metricsSinceMs?: number;
+        metricsUntilMs?: number;
+        runMs: number;
+        setupMs: number;
+        downMs: number;
+        holdMs: number;
+        goodCount: number;
+        scrapCount: number;
+    }[];
     /** 자리별 · 속성별 마지막 관측 — 이어 계산가 이 축을 0부터 다시 만들지 않게. */
     observations?: {
         id: string;
@@ -237,6 +257,13 @@ export declare class ObservedReducer {
     private corrections;
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     private unhandled;
+    /**
+     * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+     * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+     */
+    private oeeCounters;
     /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     private testSpecs;
     /**
@@ -341,6 +368,19 @@ export declare class ObservedReducer {
      * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
      * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
      */
+    /**
+     * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+     *
+     * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+     * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+     * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+     *
+     * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+     * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+     *
+     * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+     */
+    private oeePart;
     private noteUnhandled;
     /**
      * 팔레트 물품에 **담고 있는 것**을 채운다 — 이미 아는 값을 덮지 않는다.

package/dist/observed-reducer.js

@@ -19,6 +19,7 @@
  *  - 운영 델타(task/equipment/order.status) → tasks·equipment·orders (EPCIS 로 재구성 불가한 절반)
  * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
  */
+import { computeOee } from '@operato/ops-contract';
 import { OP_EVENT, capabilityOf, itemKeyOf, judgeAgainstSpec, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from '@operato/ops-contract';
 import { ILMD_ATTR, parseEpc } from '@operato/ops-contract';
 import { expiryFromAttributes, lotFromAttributes } from '@operato/ops-contract';
@@ -41,6 +42,9 @@ function effectiveOf(r) {
         ...(r?.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {})
     };
 }
+function emptyOeeCounters() {
+    return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+}
 export class ObservedReducer {
     /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
     master = new Map();
@@ -89,6 +93,13 @@ export class ObservedReducer {
     corrections = [];
     /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
     unhandled = new Map();
+    /**
+     * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+     *
+     * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+     * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+     */
+    oeeCounters = new Map();
     /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
     testSpecs = new Map();
     /**
@@ -447,6 +458,96 @@ export class ObservedReducer {
                 this.touchLocation(d.location);
                 break;
             }
+            case OP_EVENT.quality: {
+                /*
+                 * **산출 누적** — 설비가 지금까지 몇 개를 냈나. OEE 의 양품률이 이 값에서만 나온다.
+                 *
+                 * 예전에는 이 사건을 관측이 읽지 않았다. 유입 문도 있고 저널에도 남는데 **상태에 앉는 자리가
+                 * 없어서**, 미러 트윈의 양품률이 영영 비어 있었다. 시뮬레이션 커널만 자기 계수기를 채웠다.
+                 *
+                 * 값은 **절대 누적**이다(계약이 그렇게 정의한다). 그래서 더하지 않고 그대로 놓는다 — 더하면
+                 * 재전송 한 번에 두 배가 된다.
+                 */
+                const d = e.data;
+                if (!d?.moverId)
+                    break;
+                if (this.stale(`quality:${d.moverId}`, e))
+                    return;
+                const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+                c.goodCount = d.goodCount;
+                c.scrapCount = d.scrapCount;
+                this.oeeCounters.set(d.moverId, c);
+                this.markHeard(d.moverId, e);
+                break;
+            }
+            case OP_EVENT.equipmentPeriod: {
+                /*
+                 * **마감된 상태 구간** — 그 설비가 그 구간 동안 그 상태였다. 시간을 종류별로 쌓는다.
+                 *
+                 * `stale` 을 지나지 않는다. 구간 하나하나가 **자기 사실**이지 상태를 덮는 것이 아니어서,
+                 * 시각으로 앞뒤를 가리면 늦게 적힌 어제의 정지가 버려진다. 되돌아가 적는 것이 이 어휘의 존재
+                 * 이유다. 같은 구간이 두 번 오는 것은 유입 경계가 거른다.
+                 *
+                 * **지금 상태를 바꾸지 않는다.** 어제의 구간이 오늘의 상태가 되면 안 된다.
+                 */
+                const d = e.data;
+                if (!d?.moverId || !d?.from || !d?.to)
+                    break;
+                const from = Date.parse(d.from);
+                const to = Date.parse(d.to);
+                if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from)
+                    break;
+                const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+                const ms = to - from;
+                /* 어디에도 넣을 수 없는 상태는 세지 않는다 — 아무 칸에나 넣으면 가동률이 조용히 틀린다. */
+                if (d.status === 'busy')
+                    c.runMs += ms;
+                else if (d.status === 'setup')
+                    c.setupMs += ms;
+                else if (d.status === 'down')
+                    c.downMs += ms;
+                else if (d.status === 'planned-stop')
+                    c.holdMs += ms;
+                else if (d.status !== 'idle')
+                    break;
+                /* 대기(`idle`)는 따로 쌓지 않는다 — 조업 시간에서 나머지로 나온다(ISO 22400 의 ADOT). */
+                c.metricsSinceMs = c.metricsSinceMs === undefined ? from : Math.min(c.metricsSinceMs, from);
+                c.metricsUntilMs = c.metricsUntilMs === undefined ? to : Math.max(c.metricsUntilMs, to);
+                this.oeeCounters.set(d.moverId, c);
+                this.markHeard(d.moverId, e);
+                break;
+            }
+            case OP_EVENT.disposition: {
+                /*
+                 * **부적합 처분** — 이 로트를 어떻게 하기로 정했나. 대상을 가리켜 들어오고 그 개체 안에 앉는다
+                 * (§`OP_EVENT.test` 와 같은 좁힘).
+                 *
+                 * **물품을 지어내지 않는다.** 모르는 대상의 처분은 `unhandled` 로 세어서 낸다 — 없는 재고를
+                 * 만드는 것은 사실을 잃는 것보다 나쁘다.
+                 */
+                const d = e.data;
+                if (!d?.subjectId || !d?.decision)
+                    break;
+                if (this.stale(`disposition:${d.subjectId}`, e))
+                    return;
+                /*
+                 * **로트를 이름으로 찾는다.** 상태의 열쇠는 로트 하나가 아니다 — 같은 로트가 두 자리에 나뉘어
+                 * 놓이면 부분마다 한 줄이고(§`ItemState` 의 `MaterialSubLot`), 처분은 **로트 전체의 사실**이다.
+                 * 그래서 그 이름을 가진 부분 모두에 앉힌다.
+                 *
+                 * 부분마다 같은 사실이 앉으므로 **부분을 가로질러 수량을 합하면 안 된다.** 자리마다 다르게
+                 * 처분하는 일이 생기면 그것은 이 사실이 아니라 자리를 가리키는 다른 사실이다.
+                 */
+                const parts = [...this.items.values()].filter(i => i.epc === d.subjectId);
+                if (!parts.length) {
+                    this.noteUnhandled(e, `${OP_EVENT.disposition}:unknown-subject`);
+                    break;
+                }
+                /* `disposition` 은 EPCIS 의 이름이라 쓸 수 없다 — 같은 낱말을 두 표준이 다른 뜻으로 쓴다. */
+                for (const part of parts)
+                    part.nonconformance = { ...d };
+                break;
+            }
             case OP_EVENT.observation: {
                 /*
                  * **자리의 물리 관측** — 속성마다 마지막 값 하나만 든다(§`LocationState.observations`).
@@ -594,6 +695,24 @@ export class ObservedReducer {
      * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
      * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
      */
+    /**
+     * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+     *
+     * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+     * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+     * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+     *
+     * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+     * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+     *
+     * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+     */
+    oeePart(id) {
+        const c = this.oeeCounters.get(id);
+        if (!c)
+            return {};
+        return { oee: computeOee(c, c.metricsUntilMs ?? 0) };
+    }
     noteUnhandled(e, key) {
         const at = Date.parse(String(e.eventTime ?? ''));
         const name = key ?? e.eventType;
@@ -1122,6 +1241,11 @@ export class ObservedReducer {
             unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
             /* 마지막으로 들은 시각 — 이어받지 않으면 재기동 뒤에 아무 말이 없던 길이를 말할 수 없다. */
             heard: [...this.heard.entries()].map(([id, v]) => ({ id, ...v })),
+            /*
+             * OEE 계수기 — **원천이 되풀어 주지 않는 축**이다. 담지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+             * 사라지고 가동률이 그 순간부터 다시 세어진다.
+             */
+            oeeCounters: [...this.oeeCounters.entries()].map(([id, c]) => ({ id, ...c })),
             /*
              * 마스터데이터도 담는다 — 지난 기록에 없는 값이므로, 담지 않으면 되세울 때 유통기한이 빈다.
              * 변하지 않는 값이라 어느 시점의 저장본에서 꺼내도 같은 답이다.
@@ -1147,6 +1271,7 @@ export class ObservedReducer {
         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.oeeCounters = new Map((cp?.oeeCounters ?? []).map((c) => [String(c.id), { ...emptyOeeCounters(), ...c, id: undefined }]));
         this.persons = new Map((cp?.persons ?? []).map(x => [x.id, { ...x }]));
         this.assets = new Map((cp?.assets ?? []).map(x => [x.id, { ...x }]));
         this.orders = new Map((cp?.orders ?? []).map(o => [o.id, { ...o }]));
@@ -1197,7 +1322,7 @@ export class ObservedReducer {
             persons: [...this.persons.values()].map(p => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
             assets: [...this.assets.values()].map(a => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
             tasks: [...this.tasks.values()].map(t => ({ ...t })),
-            equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
+            equipment: [...this.equipment.values()].map(m => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
             orders: [...this.orders.values()].map(o => ({ ...o })),
             acked: [...this.acked]
         };

package/dist-cjs/index.cjs

@@ -1676,6 +1676,8 @@ var ASSET_STATUS = ["idle", "in-use"];
 var SPECS = {
   task: {
     eventType: OP_EVENT.task,
+    match: ["taskId"],
+    matchOrder: 50,
     identity: "taskId",
     /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
     required: ["taskId", "kind", "status"],
@@ -1712,6 +1714,8 @@ var SPECS = {
   },
   equipment: {
     eventType: OP_EVENT.equipment,
+    match: ["moverId"],
+    matchOrder: 20,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
     required: ["moverId", "kind", "status"],
@@ -1738,6 +1742,8 @@ var SPECS = {
   },
   person: {
     eventType: OP_EVENT.person,
+    match: ["personId"],
+    matchOrder: 30,
     identity: "personId",
     required: ["personId", "status"],
     fields: {
@@ -1755,6 +1761,8 @@ var SPECS = {
   },
   asset: {
     eventType: OP_EVENT.asset,
+    match: ["assetId"],
+    matchOrder: 40,
     identity: "assetId",
     required: ["assetId", "status"],
     fields: {
@@ -1772,6 +1780,8 @@ var SPECS = {
   },
   order: {
     eventType: OP_EVENT.order,
+    match: ["orderId"],
+    matchOrder: 60,
     identity: "orderId",
     /*
      * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
@@ -1801,12 +1811,23 @@ var SPECS = {
   },
   quality: {
     eventType: OP_EVENT.quality,
+    match: ["moverId", "good"],
+    matchOrder: 15,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드
     /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
     required: ["moverId", "good", "goodCount", "scrapCount"],
     // vocabulary-guard: allow
-    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", recordTime: "string" }
+    /*
+     * `taskId` 는 **귀속**이다 — 이 산출이 어느 작업의 것인가. 수량의 뜻은 바뀌지 않는다(설비 누적).
+     *
+     * 왜 필요한가: 작업자가 올리는 실적은 작업 단위인데 이 갈래의 정체는 설비뿐이라, 두 사실이 만나는
+     * 자리가 없었다. 귀속이 없으면 「이 작업에서 몇 개 나왔나」를 저널에서 되짚을 방법이 없다.
+     *
+     * 정체를 `taskId` 로 바꾸지 않는 이유는 OEE 가 설비 단위여서다. 정체를 옮기면 설비 누적을 셀 수
+     * 없어진다.
+     */
+    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", taskId: "string", recordTime: "string" }
     // vocabulary-guard: allow
   },
   /*
@@ -1845,6 +1866,8 @@ var SPECS = {
    */
   "equipment-period": {
     eventType: OP_EVENT.equipmentPeriod,
+    match: ["moverId", "status", "from", "to"],
+    matchOrder: 10,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드 — 전이와 같은 이름을 쓴다
     required: ["moverId", "status", "from", "to"],
@@ -1879,6 +1902,8 @@ var SPECS = {
    */
   disposition: {
     eventType: OP_EVENT.disposition,
+    match: ["subjectId", "decision"],
+    matchOrder: 80,
     identity: "subjectId",
     /* 무엇을 어떻게 하기로 했나 — 둘 중 하나가 없으면 그 결정은 아무 데도 붙지 못한다. */
     required: ["subjectId", "decision"],
@@ -1897,6 +1922,8 @@ var SPECS = {
   },
   test: {
     eventType: OP_EVENT.test,
+    match: ["testableObjectId"],
+    matchOrder: 70,
     identity: "testableObjectId",
     /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
     required: ["testableObjectId", "specId"],
@@ -1930,12 +1957,16 @@ var SPECS = {
    */
   complete: {
     eventType: OP_EVENT.complete,
+    match: ["completeAxis"],
+    matchOrder: 100,
     identity: "completeAxis",
     required: ["completeAxis", "since"],
     fields: { completeAxis: "string", since: "string", recordTime: "string" }
   },
   observation: {
     eventType: OP_EVENT.observation,
+    match: ["locationId", "propertyId"],
+    matchOrder: 90,
     identity: "locationId",
     /* 자리와 속성 — 둘 중 하나가 없으면 그 관측은 아무 데도 붙지 못한다. */
     required: ["locationId", "propertyId"],
@@ -1953,6 +1984,7 @@ var SPECS = {
     }
   }
 };
+var MATCH_ORDER = Object.keys(SPECS).sort((a, b) => (SPECS[a].matchOrder ?? 1e3) - (SPECS[b].matchOrder ?? 1e3));
 
 // ../ops-contract/dist/operations-capability.js
 function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
@@ -2293,6 +2325,9 @@ function effectiveOf(r) {
     ...r?.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {}
   };
 }
+function emptyOeeCounters() {
+  return { runMs: 0, setupMs: 0, downMs: 0, holdMs: 0, goodCount: 0, scrapCount: 0 };
+}
 var ObservedReducer = class {
   /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
   master = /* @__PURE__ */ new Map();
@@ -2342,6 +2377,13 @@ var ObservedReducer = class {
   corrections = [];
   /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
   unhandled = /* @__PURE__ */ new Map();
+  /**
+   * **설비마다 쌓는 OEE 계수기** — 상태가 아니라 누적이다.
+   *
+   * 원천이 되풀어 주지 않는 축이라 저장본에 함께 담는다(§`serialize`). 담지 않으면 재기동 뒤에 어제까지
+   * 쌓은 시간이 사라지고, 가동률이 그 순간부터 다시 세어진다.
+   */
+  oeeCounters = /* @__PURE__ */ new Map();
   /** 선언된 판정 기준(트윈 모델에서 한 번 읽는다) — 판정은 선언한 것에만 걸린다. */
   testSpecs = /* @__PURE__ */ new Map();
   /**
@@ -2633,6 +2675,48 @@ var ObservedReducer = class {
         this.touchLocation(d.location);
         break;
       }
+      case OP_EVENT.quality: {
+        const d = e.data;
+        if (!d?.moverId) break;
+        if (this.stale(`quality:${d.moverId}`, e)) return;
+        const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+        c.goodCount = d.goodCount;
+        c.scrapCount = d.scrapCount;
+        this.oeeCounters.set(d.moverId, c);
+        this.markHeard(d.moverId, e);
+        break;
+      }
+      case OP_EVENT.equipmentPeriod: {
+        const d = e.data;
+        if (!d?.moverId || !d?.from || !d?.to) break;
+        const from = Date.parse(d.from);
+        const to = Date.parse(d.to);
+        if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) break;
+        const c = this.oeeCounters.get(d.moverId) ?? emptyOeeCounters();
+        const ms2 = to - from;
+        if (d.status === "busy") c.runMs += ms2;
+        else if (d.status === "setup") c.setupMs += ms2;
+        else if (d.status === "down") c.downMs += ms2;
+        else if (d.status === "planned-stop") c.holdMs += ms2;
+        else if (d.status !== "idle") break;
+        c.metricsSinceMs = c.metricsSinceMs === void 0 ? from : Math.min(c.metricsSinceMs, from);
+        c.metricsUntilMs = c.metricsUntilMs === void 0 ? to : Math.max(c.metricsUntilMs, to);
+        this.oeeCounters.set(d.moverId, c);
+        this.markHeard(d.moverId, e);
+        break;
+      }
+      case OP_EVENT.disposition: {
+        const d = e.data;
+        if (!d?.subjectId || !d?.decision) break;
+        if (this.stale(`disposition:${d.subjectId}`, e)) return;
+        const parts = [...this.items.values()].filter((i) => i.epc === d.subjectId);
+        if (!parts.length) {
+          this.noteUnhandled(e, `${OP_EVENT.disposition}:unknown-subject`);
+          break;
+        }
+        for (const part of parts) part.nonconformance = { ...d };
+        break;
+      }
       case OP_EVENT.observation: {
         const d = e.data;
         if (!d?.locationId || !d?.propertyId) break;
@@ -2718,6 +2802,23 @@ var ObservedReducer = class {
    * `key` 를 주면 그 이름으로 센다: 종류 전체를 못 다룬 것과 **그 종류의 어떤 모양만** 못 다룬 것은
    * 다른 사실이다(예: 담김은 반영하는데 품번이 섞인 팔레트만 못 담는다).
    */
+  /**
+   * 그 설비의 OEE — **원천이 말해 준 구간까지만 센다.**
+   *
+   * 조업 시간의 끝을 시계에서 가져오지 않는다. 시계를 쓰면 원천이 말을 멈춘 동안에도 조업 시간만 자라
+   * 가동률이 계속 떨어지는데, 그것은 설비의 사실이 아니라 연결의 사실이다. 미러가 아는 것은
+   * **구간으로 들은 시간**뿐이고, 그 밖의 시간에 그 설비가 무엇을 했는지는 모른다.
+   *
+   * 그래서 창은 `[가장 이른 from, 가장 늦은 to]` 다. 구간을 하나도 못 들었으면 조업 시간이 없고,
+   * `computeOee` 가 가동률 대신 `missing` 을 낸다.
+   *
+   * 잰 것이 없으면 아무것도 내지 않는다. 빈 계수기로 0% 를 그리면 「재지 않았다」가 「안 돌았다」가 된다.
+   */
+  oeePart(id) {
+    const c = this.oeeCounters.get(id);
+    if (!c) return {};
+    return { oee: computeOee(c, c.metricsUntilMs ?? 0) };
+  }
   noteUnhandled(e, key) {
     const at = Date.parse(String(e.eventTime ?? ""));
     const name = key ?? e.eventType;
@@ -3093,6 +3194,11 @@ var ObservedReducer = class {
       unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })),
       /* 마지막으로 들은 시각 — 이어받지 않으면 재기동 뒤에 아무 말이 없던 길이를 말할 수 없다. */
       heard: [...this.heard.entries()].map(([id, v]) => ({ id, ...v })),
+      /*
+       * OEE 계수기 — **원천이 되풀어 주지 않는 축**이다. 담지 않으면 재기동 뒤에 어제까지 쌓은 시간이
+       * 사라지고 가동률이 그 순간부터 다시 세어진다.
+       */
+      oeeCounters: [...this.oeeCounters.entries()].map(([id, c]) => ({ id, ...c })),
       /*
        * 마스터데이터도 담는다 — 지난 기록에 없는 값이므로, 담지 않으면 되세울 때 유통기한이 빈다.
        * 변하지 않는 값이라 어느 시점의 저장본에서 꺼내도 같은 답이다.
@@ -3120,6 +3226,9 @@ var ObservedReducer = class {
     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.oeeCounters = new Map(
+      (cp?.oeeCounters ?? []).map((c) => [String(c.id), { ...emptyOeeCounters(), ...c, id: void 0 }])
+    );
     this.persons = new Map((cp?.persons ?? []).map((x) => [x.id, { ...x }]));
     this.assets = new Map((cp?.assets ?? []).map((x) => [x.id, { ...x }]));
     this.orders = new Map((cp?.orders ?? []).map((o) => [o.id, { ...o }]));
@@ -3169,7 +3278,7 @@ var ObservedReducer = class {
       persons: [...this.persons.values()].map((p) => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`), ...this.capabilityPart(p, `person:${p.id}`, p.personnelClassIds, this.classDefs.personnel) })),
       assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a), ...this.capabilityPart(a, `asset:${a.id}`, a.assetClassIds, this.classDefs.asset) })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
-      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
+      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.oeePart(m.id), ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`), ...this.capabilityPart(m, `eq:${m.id}`, m.kind ? [m.kind] : [], this.classDefs.equipment) })),
       orders: [...this.orders.values()].map((o) => ({ ...o })),
       acked: [...this.acked]
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {
@@ -28,6 +28,6 @@
     "test": "node --test test/*.test.ts"
   },
   "dependencies": {
-    "@operato/ops-contract": "^0.5.0"
+    "@operato/ops-contract": "^0.8.0"
   }
 }