@operato/ops-contract 0.4.0 → 0.6.0

package/dist/contract.d.ts

@@ -1379,17 +1379,43 @@ export interface EquipmentMotion {
  * → OEE=(run/planned)×quality. 세 인자가 손실 위치(셋업·기아·불량)를 분해해 드러낸다.
  */
 export interface OeeMetrics {
-    availability: number;
-    performance: number;
-    quality: number;
-    overall: number;
+    /**
+     * ── 세 비율은 **없을 수 있다** (2026-08-30) ──────────────────────────────
+     *
+     * 예전에는 근거가 없을 때 `1` 을 냈다. 잰 구간이 없는데 「가동률 100%」가 되고, 만든 것이 하나도
+     * 없는데 「양품률 100%」가 된다. **없는 근거로 좋은 숫자를 만드는 것**이고, 사용자는 그것으로
+     * 판단한다.
+     *
+     * 없으면 답하지 않는다. 무엇이 없어서인지는 `missing` 이 말한다.
+     */
+    availability?: number;
+    performance?: number;
+    quality?: number;
+    overall?: number;
+    /** 값이 없는 이유 — 비면 셋 다 나왔다는 뜻이다. */
+    missing?: OeeMissing[];
     runMs: number;
     setupMs: number;
     downMs: number;
-    idleMs: number;
+    delayMs: number;
     goodCount: number;
     scrapCount: number;
 }
+/**
+ * OEE 값이 없는 이유.
+ *
+ * 「모름」과 「0」은 다르다. 계획 조업 시간을 모르면 가동률을 낼 수 없고, 그때 0 을 내면 설비가
+ * 놀고 있는 것처럼 보이고 1 을 내면 완벽한 것처럼 보인다. 둘 다 거짓이다.
+ */
+export type OeeMissing = 
+/** 계획 조업 시간(PBT)을 모른다 — 아직 아무것도 재지 않았거나 근무 캘린더가 없다. */
+'planned-busy-time'
+/** 품목당 표준 시간(PRI)이 선언되지 않았다 — 성능률의 분자를 만들 수 없다. */
+ | 'planned-run-time-per-item'
+/** 만든 것이 없다 — 양품률을 낼 대상이 없다. */
+ | 'produced-quantity'
+/** 실 생산 시간이 0 이다 — 성능률의 분모가 없다. */
+ | 'actual-production-time';
 export interface EquipmentState extends EffectivePeriod {
     id: string;
     kind: string;
@@ -3230,6 +3256,8 @@ export interface TwinModelDef {
     /** parallelism = 동시 처리 수(LocationState.parallelism 참조). capacity 는 저장 용량. */
     locations: (EffectivePeriod & {
         id: string;
+        name?: string;
+        gs1Id?: string;
         type: string;
         capacity: number;
         parallelism?: number;
@@ -3243,6 +3271,7 @@ export interface TwinModelDef {
      */
     equipment: (EffectivePeriod & {
         id: string;
+        name?: string;
         kind: string;
         homeLocation: string;
         identity?: string;

package/dist/domain-definition.d.ts

@@ -133,6 +133,7 @@ export interface DurationVariability {
 export interface OperationDef extends EffectivePeriod {
     key: string;
     label: string;
+    name?: string;
     intent: OperationIntent;
     /** 오퍼레이션이 수행되는 자리 타입(LocationTypeDef.key). 커널이 locationByType 로 위치 해소. */
     locationType?: string;

package/dist/index.d.ts

@@ -18,3 +18,4 @@ export * from './wms-profile.ts';
 export * from './yms-profile.ts';
 export * from './canonical-record.ts';
 export * from './version.ts';
+export * from './oee.ts';

package/dist/index.js

@@ -39,3 +39,4 @@ export * from "./wms-profile.js";
 export * from "./yms-profile.js";
 export * from "./canonical-record.js";
 export * from "./version.js";
+export * from "./oee.js";

package/dist/oee.d.ts

@@ -0,0 +1,54 @@
+import type { OeeMetrics } from './contract.ts';
+/**
+ * OEE 계측 카운터 — 시뮬은 틱으로, 라이브는 텔레메트리나 사건 누적기가 채운다.
+ *
+ * 이름은 ISO 22400-2 의 시간 항목을 따른다.
+ */
+export interface OeeCounters {
+    /** 실 생산 시간(APT) — 실제로 만들고 있던 시간. 준비·대기·고장은 여기 들어가지 않는다. */
+    runMs: number;
+    /** 준비(AUST). */
+    setupMs: number;
+    /** 고장(ADOT). */
+    downMs: number;
+    goodCount: number;
+    scrapCount: number;
+    /** 계획정지 — 계획 조업 시간에서 뺀다(점심·예방보전·교대). */
+    holdMs?: number;
+    /** 언제부터 쟀나. 없으면 잰 구간이 없는 것이고, 그때는 가동률을 낼 수 없다. */
+    metricsSinceMs?: number;
+    /**
+     * **품목당 표준 시간**(PRI) — 성능률의 분자를 만든다.
+     *
+     * 없으면 성능률을 내지 않는다. 이 값이 없는데 실 가동 시간으로 대신 나누면 「얼마나 빨리
+     * 만들었나」가 아니라 「얼마나 쉬지 않았나」가 되고, 이름만 성능률이 된다.
+     */
+    plannedRunTimePerItemMs?: number;
+}
+/**
+ * **OEE** — ISO 22400-2 의 정의를 따른다.
+ *
+ * ```
+ * PBT           계획 조업 시간 = 잰 구간 − 계획정지
+ * APT           실 생산 시간 = runMs
+ * availability  APT / PBT
+ * effectiveness PRI × PQ / APT          PQ = 양품 + 불량
+ * quality       GQ / PQ
+ * overall       셋의 곱
+ * ```
+ *
+ * ── 예전 식과 무엇이 달랐나 (2026-08-30 대조) ────────────────────────────
+ * 예전에는 가동률의 분자가 `PBT − 준비 − 고장` 이었다. **대기가 분자에 남아 있었다.** 표준은
+ * `AOET = APT + AUST + ADET + ADOT` 로 대기도 실 생산 시간에서 뺀다.
+ *
+ * 총합은 같았다(가동률 × 성능률이 양쪽 다 `runMs / PBT` 로 떨어진다). 다른 것은 두 값을 따로 볼
+ * 때다. 자재를 기다린 시간이 성능률로 넘어가 있어서, **자재 문제를 설비 성능 문제로 읽게 했다.**
+ * 공장이 손 쓰는 방법이 그 둘에서 갈린다 — 가동률이 낮으면 보전·자재를 보고, 성능률이 낮으면
+ * 사이클 타임을 본다.
+ *
+ * 성능률도 달랐다. 표준은 품목당 표준 시간으로 재는데 우리는 실 가동 시간의 비율을 냈다.
+ *
+ * 대조는 원문이 아니라 그 표준을 구현한 규격에서 했다(OPC Foundation MachineTool §C.2). ISO 22400-2
+ * 원문은 유료라 읽지 못했다 — 이 주석이 근거의 한계를 함께 말한다.
+ */
+export declare function computeOee(c: OeeCounters, nowMs: number): OeeMetrics;

package/dist/oee.js

@@ -0,0 +1,62 @@
+/**
+ * **OEE** — ISO 22400-2 의 정의를 따른다.
+ *
+ * ```
+ * PBT           계획 조업 시간 = 잰 구간 − 계획정지
+ * APT           실 생산 시간 = runMs
+ * availability  APT / PBT
+ * effectiveness PRI × PQ / APT          PQ = 양품 + 불량
+ * quality       GQ / PQ
+ * overall       셋의 곱
+ * ```
+ *
+ * ── 예전 식과 무엇이 달랐나 (2026-08-30 대조) ────────────────────────────
+ * 예전에는 가동률의 분자가 `PBT − 준비 − 고장` 이었다. **대기가 분자에 남아 있었다.** 표준은
+ * `AOET = APT + AUST + ADET + ADOT` 로 대기도 실 생산 시간에서 뺀다.
+ *
+ * 총합은 같았다(가동률 × 성능률이 양쪽 다 `runMs / PBT` 로 떨어진다). 다른 것은 두 값을 따로 볼
+ * 때다. 자재를 기다린 시간이 성능률로 넘어가 있어서, **자재 문제를 설비 성능 문제로 읽게 했다.**
+ * 공장이 손 쓰는 방법이 그 둘에서 갈린다 — 가동률이 낮으면 보전·자재를 보고, 성능률이 낮으면
+ * 사이클 타임을 본다.
+ *
+ * 성능률도 달랐다. 표준은 품목당 표준 시간으로 재는데 우리는 실 가동 시간의 비율을 냈다.
+ *
+ * 대조는 원문이 아니라 그 표준을 구현한 규격에서 했다(OPC Foundation MachineTool §C.2). ISO 22400-2
+ * 원문은 유료라 읽지 못했다 — 이 주석이 근거의 한계를 함께 말한다.
+ */
+export function computeOee(c, nowMs) {
+    const missing = [];
+    /* 계획 조업 시간 — 잰 구간을 모르면 없다. 0 으로 메우면 「1970년부터 재고 있었다」가 된다. */
+    const planned = c.metricsSinceMs == null ? 0 : Math.max(0, nowMs - c.metricsSinceMs - (c.holdMs ?? 0));
+    if (planned <= 0)
+        missing.push('planned-busy-time');
+    /* 대기는 남는 시간이다 — 계획 조업에서 생산·준비·고장을 뺀 것. 따로 재지 않아도 나온다. */
+    const delayMs = Math.max(0, planned - c.runMs - c.setupMs - c.downMs);
+    const availability = planned > 0 ? Math.min(1, c.runMs / planned) : undefined;
+    const produced = c.goodCount + c.scrapCount;
+    if (produced <= 0)
+        missing.push('produced-quantity');
+    const quality = produced > 0 ? c.goodCount / produced : undefined;
+    /* 성능률 — 표준 시간이 없으면 내지 않는다. 실 생산 시간이 0 이어도 나눌 수 없다. */
+    if (c.plannedRunTimePerItemMs == null)
+        missing.push('planned-run-time-per-item');
+    else if (c.runMs <= 0)
+        missing.push('actual-production-time');
+    const performance = c.plannedRunTimePerItemMs != null && c.runMs > 0
+        ? Math.min(1, (c.plannedRunTimePerItemMs * produced) / c.runMs)
+        : undefined;
+    const overall = availability != null && performance != null && quality != null ? availability * performance * quality : undefined;
+    return {
+        ...(availability != null ? { availability } : {}),
+        ...(performance != null ? { performance } : {}),
+        ...(quality != null ? { quality } : {}),
+        ...(overall != null ? { overall } : {}),
+        ...(missing.length ? { missing } : {}),
+        runMs: c.runMs,
+        setupMs: c.setupMs,
+        downMs: c.downMs,
+        delayMs,
+        goodCount: c.goodCount,
+        scrapCount: c.scrapCount
+    };
+}

package/dist/operational-ingest.js

@@ -60,6 +60,8 @@ const ASSET_STATUS = ['idle', 'in-use'];
 const SPECS = {
     task: {
         eventType: OP_EVENT.task,
+        match: ['taskId'],
+        matchOrder: 50,
         identity: 'taskId',
         /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
         required: ['taskId', 'kind', 'status'],
@@ -79,6 +81,8 @@ const SPECS = {
     },
     equipment: {
         eventType: OP_EVENT.equipment,
+        match: ['moverId'],
+        matchOrder: 20,
         identity: 'moverId', // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
         required: ['moverId', 'kind', 'status'], // vocabulary-guard: allow 위와 같은 이유
         fields: {
@@ -94,6 +98,8 @@ const SPECS = {
     },
     person: {
         eventType: OP_EVENT.person,
+        match: ['personId'],
+        matchOrder: 30,
         identity: 'personId',
         required: ['personId', 'status'],
         fields: {
@@ -104,6 +110,8 @@ const SPECS = {
     },
     asset: {
         eventType: OP_EVENT.asset,
+        match: ['assetId'],
+        matchOrder: 40,
         identity: 'assetId',
         required: ['assetId', 'status'],
         fields: {
@@ -114,6 +122,8 @@ const SPECS = {
     },
     order: {
         eventType: OP_EVENT.order,
+        match: ['orderId'],
+        matchOrder: 60,
         identity: 'orderId',
         /*
          * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
@@ -129,6 +139,8 @@ const 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
@@ -170,6 +182,8 @@ const SPECS = {
      */
     'equipment-period': {
         eventType: OP_EVENT.equipmentPeriod,
+        match: ['moverId', 'status', 'from', 'to'],
+        matchOrder: 10,
         identity: 'moverId', // vocabulary-guard: allow 저널 와이어 필드 — 전이와 같은 이름을 쓴다
         required: ['moverId', 'status', 'from', 'to'], // vocabulary-guard: allow 위와 같은 이유
         fields: {
@@ -196,6 +210,8 @@ const SPECS = {
      */
     disposition: {
         eventType: OP_EVENT.disposition,
+        match: ['subjectId', 'decision'],
+        matchOrder: 80,
         identity: 'subjectId',
         /* 무엇을 어떻게 하기로 했나 — 둘 중 하나가 없으면 그 결정은 아무 데도 붙지 못한다. */
         required: ['subjectId', 'decision'],
@@ -207,6 +223,8 @@ const SPECS = {
     },
     test: {
         eventType: OP_EVENT.test,
+        match: ['testableObjectId'],
+        matchOrder: 70,
         identity: 'testableObjectId',
         /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
         required: ['testableObjectId', 'specId'],
@@ -234,12 +252,16 @@ const 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'],
@@ -268,68 +290,34 @@ export function operationalKindOf(record) {
     if (!record || typeof record !== 'object')
         return undefined;
     const r = record;
-    if (r.epc !== undefined || r.meterId !== undefined || r.equipmentId !== undefined)
-        return undefined;
-    const has = (k) => typeof r[k] === 'string' && r[k].trim().length > 0;
-    /* vocabulary-guard: allow 저널 와이어 필드로 가른다 */
-    /*
-     * 구간이 있으면 **마감된 상태 구간**이지 시점의 전이가 아니다. 전이보다 먼저 본다 — 뒤에 두면
-     * 사람이 되돌아가 적은 구간이 「지금 이 상태다」로 읽혀 트윈의 상태가 과거로 끌린다.
-     */
-    if (has('moverId') && has('from') && has('to'))
-        return 'equipment-period';
-    if (has('moverId'))
-        return r.good !== undefined ? 'quality' : 'equipment';
-    if (has('personId'))
-        return 'person';
-    if (has('assetId'))
-        return 'asset';
-    if (has('taskId'))
-        return 'task'; // 작업이 든 `orderId` 는 소속(참조)이다
-    if (has('orderId'))
-        return 'order';
-    /*
-     * ── ★ **채널을 열고 들어오는 길을 내지 않았다** (2026-08-24) ─────────────────
-     * `OP_EVENT.test` 를 계약에 냈는데 이 라우팅이 `testableObjectId` 를 보지 않았다. 그래서 커넥터의
-     * 시험 결과가 **어느 통도 아니어서 조용히 버려졌다** — 거부 목록에도 남지 않았다(운영 경로를 아예
-     * 지나지 않으므로).
-     *
-     * 같은 부류가 하루에 세 번 났다: `ilmd`(매핑에 자리 없음) · 사건 시각(이름 어긋남) · 그리고 이것.
-     * **계약에 자리를 만드는 것과 그 자리로 가는 길을 내는 것은 다른 일이다.** 앞의 것만 하면 보내는
-     * 쪽에는 「실었다」로 보이고 화면에는 「없다」로 보인다.
-     *
-     * 순서상 뒤에 둔다 — 시험 결과가 작업·오더를 함께 가리킬 수 있고, 그때 그것은 **그 작업의 사실**이다.
-     */
-    if (has('testableObjectId'))
-        return 'test';
-    /*
-     * **처분** — 같은 부류가 또 났다(2026-08-30). `OP_EVENT.disposition` 을 계약에 내고 여기로 오는 길을
-     * 내지 않아, MES 가 보내면 어느 통도 아니어서 사라졌다. 위 주석이 적은 것이 **셋째**다.
-     *
-     * 시험 결과 뒤에 둔다 — 처분은 판정을 가리킬 수 있고(`specId`), 그때 정체성은 처분 대상이지
-     * 시험 대상이 아니다. 앞에 두면 판정에 딸린 처분이 시험으로 읽힌다.
-     */
-    if (has('subjectId') && has('decision'))
-        return 'disposition';
     /*
-     * ── ★ **채널을 열고 또 길을 내지 않았다** (2026-08-24) ──────────────────────
-     * `OP_EVENT.observation`(`location.measured`)을 내고 상태(`LocationState.observations`)와 조회
-     * (`observationAt`)까지 붙였는데 **이 라우팅이 `locationId` 를 보지 않았다.** 커넥터가 방의 온습도를
-     * 실어 보내면 「어느 운영 사실인지 모른다」로 거부됐다.
-     *
-     * 같은 부류를 하루에 일곱 번 만났다. 다만 이번엔 **거부되고 이유가 남았다** — 시험 결과 때는 어느
-     * 통도 아니어서 조용히 사라졌다. 그 차이가 이것을 5분 만에 찾게 했다(§`isOperationalRecord`).
-     *
-     * **둘을 함께 요구한다.** `locationId` 만으로는 자리를 말하는 다른 사실과 섞인다. 관측은 「어느
-     * 자리의 **무엇**을 쟀나」이므로 속성 없이는 담을 곳이 없다 — 그때는 받지 않는 것이 옳다.
+     * EPCIS·에너지와 겹치지 않게 본다: `epc`·`meterId` 가 있으면 그쪽 어휘이고, `equipmentId` 는 설비
+     * **에너지** 상태의 이름이다(운영 설비는 `moverId`).
      */
-    if (has('locationId') && has('propertyId'))
-        return 'observation';
-    /* 「이 목록이 전부다」 — 어느 목록인지를 스스로 말하므로 다른 사실과 섞이지 않는다. */
-    if (has('completeAxis'))
-        return 'complete';
+    if (r.epc !== undefined || r.meterId !== undefined || r.equipmentId !== undefined)
+        return undefined;
+    /* 문자열은 비어 있으면 없는 것으로 본다 — 공백만 실은 필드는 말한 것이 아니다. */
+    const present = (k) => {
+        const v = r[k];
+        if (v === undefined || v === null)
+            return false;
+        return typeof v === 'string' ? v.trim().length > 0 : true;
+    };
+    for (const kind of MATCH_ORDER) {
+        const spec = SPECS[kind];
+        const fields = spec.match ?? [spec.identity];
+        if (fields.every(present))
+            return kind;
+    }
     return undefined;
 }
+/**
+ * 판정 순서 — 표의 `matchOrder` 에서 한 번만 만든다.
+ *
+ * 좁은 것이 먼저다. 그리고 자원(설비·사람·자산)을 작업보다, 작업을 오더보다 먼저 본다 — 정체 필드는
+ * 하나만 오지 않고, 아무거나 먼저 보면 **참조를 주체로 읽는다**(설비 델타가 든 `taskId` 는 소속이다).
+ */
+const MATCH_ORDER = Object.keys(SPECS).sort((a, b) => (SPECS[a].matchOrder ?? 1000) - (SPECS[b].matchOrder ?? 1000));
 /** 이 레코드가 운영 사실인가 — 호스트의 라우팅이 묻는 자리. */
 export function isOperationalRecord(record) {
     return operationalKindOf(record) !== undefined;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CONTRACT_VERSION = "0.4.0";
+export declare const CONTRACT_VERSION = "0.5.0";

package/dist/version.js

@@ -11,4 +11,4 @@
  *
  * **정본은 `package.json` 이다.** 이 값이 그것과 같은지는 시험이 지킨다(§`version-matches`).
  */
-export const CONTRACT_VERSION = '0.4.0';
+export const CONTRACT_VERSION = '0.5.0';

package/dist-cjs/index.cjs

@@ -80,6 +80,7 @@ __export(index_exports, {
   classClosure: () => classClosure,
   classIdentifierViolation: () => classIdentifierViolation,
   commandsOf: () => commandsOf,
+  computeOee: () => computeOee,
   conversionFactorOf: () => conversionFactorOf,
   criterionSaysNothing: () => criterionSaysNothing,
   documentPath: () => documentPath,
@@ -3164,6 +3165,8 @@ var ASSET_STATUS = ["idle", "in-use"];
 var SPECS = {
   task: {
     eventType: OP_EVENT.task,
+    match: ["taskId"],
+    matchOrder: 50,
     identity: "taskId",
     /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
     required: ["taskId", "kind", "status"],
@@ -3200,6 +3203,8 @@ var SPECS = {
   },
   equipment: {
     eventType: OP_EVENT.equipment,
+    match: ["moverId"],
+    matchOrder: 20,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
     required: ["moverId", "kind", "status"],
@@ -3226,6 +3231,8 @@ var SPECS = {
   },
   person: {
     eventType: OP_EVENT.person,
+    match: ["personId"],
+    matchOrder: 30,
     identity: "personId",
     required: ["personId", "status"],
     fields: {
@@ -3243,6 +3250,8 @@ var SPECS = {
   },
   asset: {
     eventType: OP_EVENT.asset,
+    match: ["assetId"],
+    matchOrder: 40,
     identity: "assetId",
     required: ["assetId", "status"],
     fields: {
@@ -3260,6 +3269,8 @@ var SPECS = {
   },
   order: {
     eventType: OP_EVENT.order,
+    match: ["orderId"],
+    matchOrder: 60,
     identity: "orderId",
     /*
      * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
@@ -3289,6 +3300,8 @@ var SPECS = {
   },
   quality: {
     eventType: OP_EVENT.quality,
+    match: ["moverId", "good"],
+    matchOrder: 15,
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드
     /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
@@ -3333,6 +3346,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"],
@@ -3367,6 +3382,8 @@ var SPECS = {
    */
   disposition: {
     eventType: OP_EVENT.disposition,
+    match: ["subjectId", "decision"],
+    matchOrder: 80,
     identity: "subjectId",
     /* 무엇을 어떻게 하기로 했나 — 둘 중 하나가 없으면 그 결정은 아무 데도 붙지 못한다. */
     required: ["subjectId", "decision"],
@@ -3385,6 +3402,8 @@ var SPECS = {
   },
   test: {
     eventType: OP_EVENT.test,
+    match: ["testableObjectId"],
+    matchOrder: 70,
     identity: "testableObjectId",
     /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
     required: ["testableObjectId", "specId"],
@@ -3418,12 +3437,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"],
@@ -3445,19 +3468,21 @@ function operationalKindOf(record) {
   if (!record || typeof record !== "object") return void 0;
   const r = record;
   if (r.epc !== void 0 || r.meterId !== void 0 || r.equipmentId !== void 0) return void 0;
-  const has = (k) => typeof r[k] === "string" && r[k].trim().length > 0;
-  if (has("moverId") && has("from") && has("to")) return "equipment-period";
-  if (has("moverId")) return r.good !== void 0 ? "quality" : "equipment";
-  if (has("personId")) return "person";
-  if (has("assetId")) return "asset";
-  if (has("taskId")) return "task";
-  if (has("orderId")) return "order";
-  if (has("testableObjectId")) return "test";
-  if (has("subjectId") && has("decision")) return "disposition";
-  if (has("locationId") && has("propertyId")) return "observation";
-  if (has("completeAxis")) return "complete";
+  const present = (k) => {
+    const v = r[k];
+    if (v === void 0 || v === null) return false;
+    return typeof v === "string" ? v.trim().length > 0 : true;
+  };
+  for (const kind of MATCH_ORDER) {
+    const spec = SPECS[kind];
+    const fields = spec.match ?? [spec.identity];
+    if (fields.every(present)) return kind;
+  }
   return void 0;
 }
+var MATCH_ORDER = Object.keys(SPECS).sort(
+  (a, b) => (SPECS[a].matchOrder ?? 1e3) - (SPECS[b].matchOrder ?? 1e3)
+);
 function isOperationalRecord(record) {
   return operationalKindOf(record) !== void 0;
 }
@@ -3733,7 +3758,36 @@ function retiredVocabularyIn(line) {
 }
 
 // src/version.ts
-var CONTRACT_VERSION = "0.4.0";
+var CONTRACT_VERSION = "0.5.0";
+
+// src/oee.ts
+function computeOee(c, nowMs) {
+  const missing = [];
+  const planned = c.metricsSinceMs == null ? 0 : Math.max(0, nowMs - c.metricsSinceMs - (c.holdMs ?? 0));
+  if (planned <= 0) missing.push("planned-busy-time");
+  const delayMs = Math.max(0, planned - c.runMs - c.setupMs - c.downMs);
+  const availability = planned > 0 ? Math.min(1, c.runMs / planned) : void 0;
+  const produced = c.goodCount + c.scrapCount;
+  if (produced <= 0) missing.push("produced-quantity");
+  const quality = produced > 0 ? c.goodCount / produced : void 0;
+  if (c.plannedRunTimePerItemMs == null) missing.push("planned-run-time-per-item");
+  else if (c.runMs <= 0) missing.push("actual-production-time");
+  const performance = c.plannedRunTimePerItemMs != null && c.runMs > 0 ? Math.min(1, c.plannedRunTimePerItemMs * produced / c.runMs) : void 0;
+  const overall = availability != null && performance != null && quality != null ? availability * performance * quality : void 0;
+  return {
+    ...availability != null ? { availability } : {},
+    ...performance != null ? { performance } : {},
+    ...quality != null ? { quality } : {},
+    ...overall != null ? { overall } : {},
+    ...missing.length ? { missing } : {},
+    runMs: c.runMs,
+    setupMs: c.setupMs,
+    downMs: c.downMs,
+    delayMs,
+    goodCount: c.goodCount,
+    scrapCount: c.scrapCount
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BIZSTEP,
@@ -3797,6 +3851,7 @@ var CONTRACT_VERSION = "0.4.0";
   classClosure,
   classIdentifierViolation,
   commandsOf,
+  computeOee,
   conversionFactorOf,
   criterionSaysNothing,
   documentPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/ops-contract",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Operations domain contract — the standard vocabulary that producers and readers agree on (EPCIS 2.0/GS1, ISA-95, IEC 61850/ISO 50001). Types, guards, validation. No state, no engine.",
   "type": "module",
   "main": "./dist-cjs/index.cjs",