@operato/ops-contract 0.9.2 → 0.9.4

package/dist/contract.d.ts

@@ -1,3 +1,4 @@
+import { type RatedUsage, type UsedUsage } from './rated-usage.ts';
 export type ISOTime = string;
 export interface CanonicalEnvelope<T = unknown> {
     eventId: string;
@@ -476,6 +477,8 @@ export type CapabilityReason =
  | 'resting'
 /** 요구된 시험의 결과가 만료·불합격 — 자격이 성립하지 않는다(§TestResult). */
  | 'test-expired'
+/** 정격 사용량을 다 썼다 — 교체할 일이다(§`RatedUsage`). 고장(`down`)과 다르다: 고쳐서 쓰지 않는다. */
+ | 'worn-out'
 /** 지금 다른 일을 하고 있다 — 능력은 있고 여유가 없다. */
  | 'working'
 /** 쓸 수 있다. */
@@ -748,6 +751,41 @@ export interface ResourceClassDef extends EffectivePeriod {
     testSpecificationIds?: TestSpecificationRefs;
 }
 export declare function classClosure(directIds: readonly string[] | undefined, defs: readonly ResourceClassDef[] | undefined, at?: ISOTime): Set<string>;
+/**
+ * 설비의 **등급 소속** — 선언한 등급들과 `kind` 를 합친 것.
+ *
+ * ── 왜 설비만 함수가 있나 ────────────────────────────────────────────────────
+ * 사람과 자산은 소속이 `personnelClassIds`·`assetClassIds` 하나뿐이라 부르는 쪽이 그 필드를 그대로
+ * 넘긴다. 설비는 소속이 **두 곳에서 온다** — 선언한 `equipmentClassIds` 와, 예전부터 소속 노릇을 해 온
+ * `kind`. 그 합침을 부르는 쪽마다 손으로 쓰면 한 곳이 빠진 날 그 설비는 **거기서만 등급을 잃는다.**
+ *
+ * 실제로 그 자리가 여섯이다: 스냅샷·가용 개수·배정 고르기·재수화·op 이벤트·관측 축소. 여섯이 같은
+ * 답을 내야 하므로 규칙이 한 자리에 있다(`requiredTestsFor` 가 계약에 있는 것과 같은 이유).
+ *
+ * ── `kind` 를 왜 소속으로 세나 (2026-09-03, 재고 결정) ──────────────────────
+ * 처음에는 설비 소속이 `kind` **하나**였다. 그것을 복수로 넓히면서 `kind` 를 뺄지 재 봤다.
+ *
+ * ```
+ * 저장된 트윈 32개 · kind 19종(cutter welder painter assembler hostler forklift meter pv-array …)
+ * equipmentClasses 를 선언한 트윈    0
+ * 설비를 이름으로 부르는 공정        52   그 이름이 전부 kind (cutter · welder · painter · assembler)
+ * ```
+ *
+ * **`kind` 는 지금 하중을 받고 있다.** 빼면 그 52 공정이 설비를 못 찾고, 요구가 채워지지 않아 라인이
+ * 굶는다 — 오류는 안 난다. 그리고 표준에서도 `EquipmentClass` 는 "정해진 목적으로 묶은 설비 무리" 이니
+ * 설비의 종류는 그 자체로 등급이다. 그래서 뺄 이유가 없고, **선언한 것에 더한다.**
+ *
+ * 합치는 것이 위험한 경우는 하나다 — 선언한 등급 id 가 어떤 `kind` 와 우연히 같을 때. 그때는 그 설비가
+ * 뜻하지 않은 요구를 만족한다. 다만 등급 id 는 사람이 일부러 짓는 이름이고 `kind` 도 그렇다. 같은
+ * 이름을 지었다면 같은 것을 뜻한 것으로 본다.
+ *
+ * 순서는 **선언한 것이 먼저**다 — 부르는 쪽이 첫 값을 대표 등급으로 쓸 때 종류가 아니라 선언이 대표가
+ * 된다. 중복은 접는다.
+ */
+export declare function equipmentClassMembership(e: {
+    kind?: string;
+    equipmentClassIds?: readonly string[];
+}): string[];
 /**
  * 우선순위 — **ISA-95 `Priority`**(`JobOrderType`·`OperationsRequestType`, 타입은 `PriorityType` =
  * `NumericType` 제한). 즉 표준은 **숫자라는 것만 정하고 방향은 정하지 않는다.**
@@ -1079,6 +1117,9 @@ export declare function capabilityOf(r: {
     };
     workCalendar?: WorkCalendarEntry[];
     testResults?: TestResult[];
+    /** 정격 사용량과 쓴 양 — 소모 공구만 든다(§`RatedUsage`). 없으면 이 축으로 막지 않는다. */
+    ratedUsage?: RatedUsage;
+    usedUsage?: UsedUsage;
 } & EffectivePeriod, ctx?: {
     at?: ISOTime;
     utcOffsetMinutes?: number;
@@ -1419,7 +1460,7 @@ export interface OeeMetrics {
     downMs: number;
     delayMs: number;
     goodCount: number;
-    scrapCount: number;
+    nonconformingCount: number;
 }
 /**
  * OEE 값이 없는 이유.
@@ -1439,6 +1480,16 @@ export type OeeMissing =
 export interface EquipmentState extends EffectivePeriod {
     id: string;
     kind: string;
+    /**
+     * 속한 **등급들** — 표준 `EquipmentClassID`(복수). 사람·자산의 상태가 등급을 싣는 것과 같다.
+     *
+     * 스냅샷과 op 이벤트가 이것을 실어야 **재기동한 미러가 소속을 이어받는다** — 실지 않으면 되살린
+     * 트윈에서 등급이 비고, 등급으로 부르는 요구(`equipmentSpecification`)가 채워지지 않아 라인이 굶는다.
+     * 오류는 나지 않는다.
+     *
+     * 판정은 `equipmentClassMembership` 을 거친다 — 이 선언과 `kind` 를 합치는 규칙은 한 자리에 있다.
+     */
+    equipmentClassIds?: string[];
     /** **지금 어디에 있나.** 운반 작업이 끝나면 도착 자리로 옮겨진다(제자리 작업은 안 움직인다). */
     location?: string;
     /**
@@ -1712,6 +1763,18 @@ export interface AssetState extends EffectivePeriod {
      * 비어 있으면 빈 팔레트다(회수 대상이자 다음 출고의 재료).
      */
     carrying?: string;
+    /**
+     * **정격 사용량** — 이만큼 쓰면 교체한다(§`RatedUsage`).
+     *
+     * 자산에 두는 이유: 닳는 것은 개체다. 등급에 두면 「메탈마스크는 5만 번」은 말할 수 있어도
+     * **「지금 걸려 있는 이 한 장이 4만 7천 번째다」**를 말할 수 없고, 교체해야 하는 것은 그 한 장이다.
+     *
+     * 속성(`properties`)에 두지 않는 이유: 이 값은 **막는 데 쓴다.** 속성 배열을 뒤져 읽으면 오타
+     * 하나가 오류 보고 없이 「정격 없음」이 된다(§`ResourceProperty` — 속성은 열림, 효과는 닫힘).
+     */
+    ratedUsage?: RatedUsage;
+    /** 지금까지 쓴 양 — 정격과 **같은 단위**여야 견준다(§`UsedUsage`). 없으면 0이 아니라 모르는 것이다. */
+    usedUsage?: UsedUsage;
     /** 자원 속성 — 표준 `PhysicalAssetProperty`(§ResourceProperty). */
     properties?: ResourceProperty[];
     /** 적격을 검증한 시험 명세들 — 표준 `PhysicalAsset.TestSpecificationID`(§TestSpecificationRefs). */
@@ -3058,6 +3121,15 @@ export interface PersonStatusDelta extends EffectivePeriod {
 export interface AssetStatusDelta extends EffectivePeriod {
     assetId: string;
     assetClassIds?: string[];
+    /**
+     * 정격과 쓴 양 — **상태에 있으면 델타에도 있어야 한다**(상태⊆이벤트).
+     *
+     * 특히 쓴 양은 시뮬이 작업마다 올리는 값이라 나가지 않으면 미러가 영원히 처음 값을 들고 있고,
+     * 「이 공구가 언제 소진되나」에 답할 수 없다. 정격은 선언이라 잘 안 바뀌지만 함께 낸다 —
+     * 미러가 정격 없이 쓴 양만 받으면 견줄 것이 없다.
+     */
+    ratedUsage?: RatedUsage;
+    usedUsage?: UsedUsage;
     status: string;
     location?: string;
     taskId?: string;
@@ -3151,12 +3223,33 @@ export interface EquipmentStatePeriodFact {
     decidedBy?: string;
     recordTime?: ISOTime;
 }
-/** 품질 산출 델타 — recordOutput(양품/불량) 시 방출. goodCount/scrapCount 는 설비 누적값. */
+/**
+ * 품질 산출 델타 — recordOutput(양품/부적합) 시 방출. 두 수는 설비 누적값이다.
+ *
+ * ── 이름을 `scrapCount` 에서 바꾼 이유 (2026-09-03) — vocabulary-guard: allow (옛 이름을 글로 남긴다)
+ * 이 수는 **검사에서 떨어진 것 전부**다. 재작업으로 되살아날 것도 든다. 그런데 이름이
+ * `scrapCount` 였고(vocabulary-guard: allow), 처분 어휘의 `scrap` 은 **「폐기」 하나**다(§`DISPOSITION_DECISION`) — 되돌리지 않고 버리는
+ * 것. 같은 낱말이 두 뜻이었다.
+ *
+ * **그리고 ISO 22400-2 의 SQ(scrap quantity)가 아니다.** 표준은 셋을 가른다: GQ(양품) · SQ(폐기,
+ * 재작업할 수 없는 것) · RQ(재작업). 이 수는 `SQ + RQ` 다.
+ *
+ * 비율 계산은 지금도 맞다 — 품질률은 `GQ / (GQ + SQ + RQ)` 이므로 `goodCount / (goodCount +
+ * nonconformingCount)` 가 정확히 그것이다. **틀린 것은 이름뿐이었고**, 그래서 새로 붙이는 쪽이
+ * 이것을 폐기 수로 읽고 폐기 원가를 세거나 재작업 수를 따로 더해 분모를 두 번 셀 위험이 있었다.
+ *
+ * 낱말은 `nonconforming` 으로 정했다 — `reject` 도 검사에서 「떨어뜨려 버린다」는 결정을 뜻해 같은
+ * 모호함을 남긴다. 계약이 이미 `nonconformance.disposition`·`FirstPassInput.nonconforming` 을 쓰고
+ * 있으니 세 번째 낱말을 만들지 않는다. **화면은 「불량 / reject」로 남는다** — 현장이 쓰는 말이고,
+ * 국문이 이미 「불량 수」와 「부적합 처분」을 갈라 쓴다.
+ */
 export interface QualityDelta {
     moverId: string;
     good: boolean;
+    /** 처음에 통과한 수가 아니다 — 재작업해서 통과한 것이 여기 더해지면 직행수율이 품질률이 된다(§`FIRST_PASS_RULE`). */
     goodCount: number;
-    scrapCount: number;
+    /** **부적합 전체**(폐기 + 재작업 + 특채 …). ISO 22400 의 SQ 가 아니라 `SQ + RQ` 다 — 위 머리말. */
+    nonconformingCount: number;
     /**
      * 이 산출이 어느 작업의 것인가 — **귀속이고, 수량의 뜻을 바꾸지 않는다**(설비 누적 그대로).
      *
@@ -3176,11 +3269,26 @@ export interface QualityDelta {
  * 표준 매핑은 커널이 이미 적어 두었다 — `MaterialDefinitionID` → `definitionId`,
  * `MaterialUse` → `use`. 그 이름을 그대로 쓴다.
  */
+/**
+ * **실적의 자재 쓰임** — 표준 `MaterialUse`. 들어갔나 나왔나 둘이다.
+ *
+ * 공정 **명세**의 쓰임(`OperationMaterial.use`)은 셋이다 — 거기에는 `consumable` 이 있다(쓰이지만
+ * 제품에 남지 않는 것: 세척수·윤활유). **실적에는 그 낱말이 없다** — 일어난 일을 적는 자리이고,
+ * 소모품이 실제로 들어간 것은 `consumed` 다.
+ *
+ * 둘을 한 어휘로 묶지 않는다. 묶으면 실적에 `consumable` 이 올 수 있게 되고, 그때 그것이
+ * 「들어갔다」인지 「쓰였지만 안 남았다」인지 받는 쪽이 정해야 한다.
+ *
+ * 유입 게이트가 이 상수를 가리킨다(§`operational-ingest.ts` 의 `shapes`) — 낱말을 두 곳에 적으면
+ * 한쪽만 늘어나는 날 게이트가 계약에 없는 낱말을 통과시킨다.
+ */
+export declare const MATERIAL_ACTUAL_USE: readonly ["consumed", "produced"];
+export type MaterialActualUse = (typeof MATERIAL_ACTUAL_USE)[number];
 export interface MaterialActual {
     /** 표준 `MaterialDefinitionID`. */
     definitionId: string;
-    /** 표준 `MaterialUse`. */
-    use: 'consumed' | 'produced';
+    /** 표준 `MaterialUse` — 실적은 둘이다(§`MATERIAL_ACTUAL_USE`). */
+    use: MaterialActualUse;
     quantity: number;
     uom?: string;
     /**
@@ -3259,6 +3367,14 @@ export interface TaskStatusDelta {
 export interface EquipmentStatusDelta extends EffectivePeriod {
     moverId: string;
     kind: string;
+    /**
+     * 속한 **등급들**(`EquipmentState.equipmentClassIds`). 나가지 않으면 미러가 소속을 영영 모른다 —
+     * 상태⊆이벤트. 사람·자산 델타가 등급을 싣는 것과 같은 자리다.
+     *
+     * 그러면 등급으로 부르는 요구(`equipmentSpecification`)가 미러에서 채워지지 않고, **라인이 굶는데
+     * 오류는 나지 않는다.**
+     */
+    equipmentClassIds?: string[];
     status: string;
     location?: string;
     /** 붙박인 자리(`EquipmentState.homeLocation`). 나가지 않으면 미러가 소속을 영영 모른다 — 상태⊆이벤트. */
@@ -3404,13 +3520,18 @@ export interface TwinModelDef {
         testSpecificationIds?: TestSpecificationRefs;
     })[];
     /**
-     * 설비(설비). mtbfMs/mttrMs 지정 시 확률적 고장 모델 참여(OEE Availability 손실). 미지정=고장 없음.
-     * `window` 지정 시 그 시간대에만 일한다(교대·가동시간) — 미지정이면 24시간 가용(기존 거동).
+     * 설비 — ISA-95 `Equipment`. mtbfMs/mttrMs 지정 시 확률적 고장 모델 참여(OEE Availability 손실).
+     * 미지정=고장 없음. `window` 지정 시 그 시간대에만 일한다(교대·가동시간) — 미지정이면 24시간 가용.
+     *
+     * `equipmentClassIds` 로 **속한 등급들**을 밝힌다(복수가 표준 — 사람·자산과 같은 규칙). 선언하지
+     * 않으면 `kind` 하나가 소속이다(기존 거동). 판정은 늘 `equipmentClassMembership` 을 거친다 —
+     * 선언과 종류를 합치는 규칙이 한 자리에 있다.
      */
     equipment: (EffectivePeriod & {
         id: string;
         name?: string;
         kind: string;
+        equipmentClassIds?: string[];
         homeLocation: string;
         identity?: string;
         mtbfMs?: number;
@@ -3446,6 +3567,8 @@ export interface TwinModelDef {
     assets?: (EffectivePeriod & {
         id: string;
         assetClassIds?: string[];
+        ratedUsage?: RatedUsage;
+        usedUsage?: UsedUsage;
         homeLocation?: string;
         properties?: ResourceProperty[];
         testSpecificationIds?: TestSpecificationRefs;

package/dist/contract.js

@@ -32,6 +32,7 @@
  * 지키는 하네스: `derived-not-input` · `actuals-come-from-transitions` · `accumulators-survive-restart` ·
  * `purpose-conformance`.
  */
+import { ratedUsageOf } from "./rated-usage.js";
 /** 오더가 **종결 상태**로 인정되는 낱말 — 이 밖은 진행 중이다(§`isOrderTerminal`). */
 export const ORDER_TERMINAL_STATUS = ['completed', 'cancelled'];
 /**
@@ -503,6 +504,46 @@ export function classClosure(directIds, defs, at) {
     }
     return out;
 }
+/**
+ * 설비의 **등급 소속** — 선언한 등급들과 `kind` 를 합친 것.
+ *
+ * ── 왜 설비만 함수가 있나 ────────────────────────────────────────────────────
+ * 사람과 자산은 소속이 `personnelClassIds`·`assetClassIds` 하나뿐이라 부르는 쪽이 그 필드를 그대로
+ * 넘긴다. 설비는 소속이 **두 곳에서 온다** — 선언한 `equipmentClassIds` 와, 예전부터 소속 노릇을 해 온
+ * `kind`. 그 합침을 부르는 쪽마다 손으로 쓰면 한 곳이 빠진 날 그 설비는 **거기서만 등급을 잃는다.**
+ *
+ * 실제로 그 자리가 여섯이다: 스냅샷·가용 개수·배정 고르기·재수화·op 이벤트·관측 축소. 여섯이 같은
+ * 답을 내야 하므로 규칙이 한 자리에 있다(`requiredTestsFor` 가 계약에 있는 것과 같은 이유).
+ *
+ * ── `kind` 를 왜 소속으로 세나 (2026-09-03, 재고 결정) ──────────────────────
+ * 처음에는 설비 소속이 `kind` **하나**였다. 그것을 복수로 넓히면서 `kind` 를 뺄지 재 봤다.
+ *
+ * ```
+ * 저장된 트윈 32개 · kind 19종(cutter welder painter assembler hostler forklift meter pv-array …)
+ * equipmentClasses 를 선언한 트윈    0
+ * 설비를 이름으로 부르는 공정        52   그 이름이 전부 kind (cutter · welder · painter · assembler)
+ * ```
+ *
+ * **`kind` 는 지금 하중을 받고 있다.** 빼면 그 52 공정이 설비를 못 찾고, 요구가 채워지지 않아 라인이
+ * 굶는다 — 오류는 안 난다. 그리고 표준에서도 `EquipmentClass` 는 "정해진 목적으로 묶은 설비 무리" 이니
+ * 설비의 종류는 그 자체로 등급이다. 그래서 뺄 이유가 없고, **선언한 것에 더한다.**
+ *
+ * 합치는 것이 위험한 경우는 하나다 — 선언한 등급 id 가 어떤 `kind` 와 우연히 같을 때. 그때는 그 설비가
+ * 뜻하지 않은 요구를 만족한다. 다만 등급 id 는 사람이 일부러 짓는 이름이고 `kind` 도 그렇다. 같은
+ * 이름을 지었다면 같은 것을 뜻한 것으로 본다.
+ *
+ * 순서는 **선언한 것이 먼저**다 — 부르는 쪽이 첫 값을 대표 등급으로 쓸 때 종류가 아니라 선언이 대표가
+ * 된다. 중복은 접는다.
+ */
+export function equipmentClassMembership(e) {
+    const out = [];
+    for (const id of e?.equipmentClassIds ?? [])
+        if (id && !out.includes(id))
+            out.push(id);
+    if (e?.kind && !out.includes(e.kind))
+        out.push(e.kind);
+    return out;
+}
 /**
  * 우선순위 — **ISA-95 `Priority`**(`JobOrderType`·`OperationsRequestType`, 타입은 `PriorityType` =
  * `NumericType` 제한). 즉 표준은 **숫자라는 것만 정하고 방향은 정하지 않는다.**
@@ -910,6 +951,17 @@ export function capabilityOf(r, ctx) {
         return { available: false, reason: 'held' };
     if (r.status === 'down')
         return { available: false, reason: 'down' };
+    /*
+     * 다 쓴 자원 — **고장보다 뒤, 교대보다 앞.**
+     *
+     * 고장이 먼저인 이유: 고장 난 것을 「수명 끝」이라고 말하면 고치러 가지 않는다. 교대보다 앞인
+     * 이유: 다 쓴 공구는 다음 교대가 와도 돌아오지 않는다 — 기다릴 일이 아니라 바꿀 일이다.
+     *
+     * **판정할 수 없으면 막지 않는다.** 정격을 선언하지 않았거나 쓴 양이 안 왔으면 `exhausted` 가
+     * 비어 있고, 그때 막으면 선언하지 않은 현장의 라인이 통째로 굶는다.
+     */
+    if (ratedUsageOf(r).exhausted === true)
+        return { available: false, reason: 'worn-out' };
     if (at) {
         const ms = parsedMs(at);
         if (Number.isFinite(ms)) {
@@ -1266,6 +1318,31 @@ export function isFailureStatus(value) {
 export function isPlannedStopStatus(value) {
     return normalizeEquipmentStatus(value) === 'planned-stop';
 }
+/**
+ * 실제로 들어가고 나온 자재 한 줄 — ISA-95 `OpMaterialActualType` 의 부분집합.
+ *
+ * ── 왜 이름 있는 타입인가 (2026-08-31) ────────────────────────────────────
+ * 같은 데이터가 네 곳에 각각 인라인으로 적혀 있었다(작업 상태 둘 · 커널 · ERP). ERP 쪽은 필드명까지
+ * 달랐다(`materialDefinitionId` · `direction`). 같은 데이터를 여러 이름으로 부르면 옮기는 코드가
+ * 생기고, 그 코드가 언젠가 어긋난다.
+ *
+ * 표준 매핑은 커널이 이미 적어 두었다 — `MaterialDefinitionID` → `definitionId`,
+ * `MaterialUse` → `use`. 그 이름을 그대로 쓴다.
+ */
+/**
+ * **실적의 자재 쓰임** — 표준 `MaterialUse`. 들어갔나 나왔나 둘이다.
+ *
+ * 공정 **명세**의 쓰임(`OperationMaterial.use`)은 셋이다 — 거기에는 `consumable` 이 있다(쓰이지만
+ * 제품에 남지 않는 것: 세척수·윤활유). **실적에는 그 낱말이 없다** — 일어난 일을 적는 자리이고,
+ * 소모품이 실제로 들어간 것은 `consumed` 다.
+ *
+ * 둘을 한 어휘로 묶지 않는다. 묶으면 실적에 `consumable` 이 올 수 있게 되고, 그때 그것이
+ * 「들어갔다」인지 「쓰였지만 안 남았다」인지 받는 쪽이 정해야 한다.
+ *
+ * 유입 게이트가 이 상수를 가리킨다(§`operational-ingest.ts` 의 `shapes`) — 낱말을 두 곳에 적으면
+ * 한쪽만 늘어나는 날 게이트가 계약에 없는 낱말을 통과시킨다.
+ */
+export const MATERIAL_ACTUAL_USE = ['consumed', 'produced'];
 // ── Command 채널 어휘 — 트윈의 "행위(act)" 면 (prescriptive/트랜잭션 프론트엔드) ──
 // 코어 공통: order.hold/resume(할당 보류). 도메인: order.release(즉시 투입) 등은 handleCommand 로.
 export const CMD = {

package/dist/epcis.d.ts

@@ -385,6 +385,24 @@ export declare function gdtiUri(companyPrefix: string, docType: string, serial:
  * Link 를 **권한다**(SHOULD) — 이 길은 프리픽스가 없을 때의 정합 경로다.
  */
 export declare function objectUri(namespace: string, objId: string | number): string | undefined;
+/**
+ * **선언된 이름공간 아래의 클래스 식별자** — SGTIN·LGTIN 을 쓰지 않는 길.
+ *
+ * 품목 등급·로트 등급처럼 「낱개가 아니라 종류」를 가리키는 자리다. 개체 쪽(`objectUri`)과 같은
+ * 사정으로 필요하다: GTIN 을 조립하려면 회사 프리픽스가 있어야 하고, 없는 현장이 그 길로 못 간다.
+ *
+ *  · CBV 2.0 §8.3.4 `http(s)://[Subdomain.]Domain/⁎⁎/class/ClassID`
+ *  · CBV 2.0 §8.3.3 `urn:URNNamespace:⁎⁎:class:ClassID`
+ *
+ * ── 왜 계약에 두나 (2026-09-04, plant 레인이 올림) ─────────────────────────
+ * 체프 커넥터가 이 URI 를 **직접 조립하고 있었다** — `productClassId` · `lotClassId` 라는 자기
+ * 이름으로. 그중 `bizTransactionId` 는 이 파일의 `bizTransactionUri` 와 **같은 것을 다르게**
+ * 만들고 있었다. `underNamespace` 는 처음부터 `'class'` 표지를 알고 있었고(그 함수 주석에
+ * §8.3.3·§8.3.4 까지 적혀 있다) **부를 문만 없었다.**
+ *
+ * 그래서 한 표준에 방언이 둘이 됐다. 문을 낸다.
+ */
+export declare function classUri(namespace: string, classId: string | number): string | undefined;
 export declare function bizTransactionUri(namespace: string, transId: string | number): string | undefined;
 /** 모든 빌더가 공통으로 받는 표준 헤더 옵션(선택) — 방출부가 필요할 때 채운다. */
 export interface EpcisHeaderOptions {

package/dist/epcis.js

@@ -263,6 +263,26 @@ export function gdtiUri(companyPrefix, docType, serial) {
 export function objectUri(namespace, objId) {
     return underNamespace(namespace, 'obj', objId);
 }
+/**
+ * **선언된 이름공간 아래의 클래스 식별자** — SGTIN·LGTIN 을 쓰지 않는 길.
+ *
+ * 품목 등급·로트 등급처럼 「낱개가 아니라 종류」를 가리키는 자리다. 개체 쪽(`objectUri`)과 같은
+ * 사정으로 필요하다: GTIN 을 조립하려면 회사 프리픽스가 있어야 하고, 없는 현장이 그 길로 못 간다.
+ *
+ *  · CBV 2.0 §8.3.4 `http(s)://[Subdomain.]Domain/⁎⁎/class/ClassID`
+ *  · CBV 2.0 §8.3.3 `urn:URNNamespace:⁎⁎:class:ClassID`
+ *
+ * ── 왜 계약에 두나 (2026-09-04, plant 레인이 올림) ─────────────────────────
+ * 체프 커넥터가 이 URI 를 **직접 조립하고 있었다** — `productClassId` · `lotClassId` 라는 자기
+ * 이름으로. 그중 `bizTransactionId` 는 이 파일의 `bizTransactionUri` 와 **같은 것을 다르게**
+ * 만들고 있었다. `underNamespace` 는 처음부터 `'class'` 표지를 알고 있었고(그 함수 주석에
+ * §8.3.3·§8.3.4 까지 적혀 있다) **부를 문만 없었다.**
+ *
+ * 그래서 한 표준에 방언이 둘이 됐다. 문을 낸다.
+ */
+export function classUri(namespace, classId) {
+    return underNamespace(namespace, 'class', classId);
+}
 export function bizTransactionUri(namespace, transId) {
     return underNamespace(namespace, 'bt', transId);
 }
@@ -271,15 +291,44 @@ export function bizTransactionUri(namespace, transId) {
  *
  * `obj`(개체 §8.2.3·§8.2.4) · `class`(클래스 §8.3.3·§8.3.4) · `bt`(거래문서 §8.5.4·§8.5.5) 가 같은
  * 모양이다. 규칙을 세 곳에 적으면 한 곳만 고쳐지는 날이 온다.
+ *
+ * ── 구분자를 계약이 부호화한다 (2026-09-04) ────────────────────────────────
+ * 전에는 구분자가 들면 **아무것도 만들지 않았다.** 그러면 부르는 쪽이 자기 손으로 부호화해서
+ * 넘기게 되고 — 실제로 그랬다 — 부르는 쪽마다 부호화가 달라진다. 방금 `classUri` 가 없어서
+ * 방언이 생긴 것과 **같은 부류**다. 표지 규칙만 계약이 갖고 부호화는 소비처에 남기면 반쪽이다.
+ *
+ * 그래서 **원문을 받아 계약이 부호화한다.** 부르는 쪽은 미리 부호화하지 않는다 — 하면 두 번
+ * 부호화되어(`A%2FB` → `A%252FB`) 다른 개체가 된다.
+ *
+ * ── 저장된 식별자를 건드리지 않는다 ────────────────────────────────────────
+ * 이 함수가 내는 값은 **저널에 남는 정체성**이다(인티그레이션 레인 실측: 47만 건 넘음). 한 글자만
+ * 달라도 이전 사실과 새 사실이 다른 개체가 된다. 그래서 **구조를 깨는 글자만** 부호화한다.
+ *
+ *   부호화한다   %  /  :  ?  #  공백    URL 경로 성분이나 URN 성분 경계를 깬다(`%` 는 부호화의
+ *                                      부호이므로 먼저 해야 뜻이 하나로 정해진다)
+ *   그대로 둔다  그 밖의 모든 글자      영숫자 · `-` · `.` · `_` · `~` 를 포함해 전부
+ *
+ * 그래서 **위 여섯 글자가 없는 값은 바이트까지 그대로다** — 지금 저장된 값은 그 집합에 들었나만
+ * 확인하면 된다(그 확인은 값을 가진 쪽이 한다). 전에 통과하던 값 중 구분자가 든 것은 없었으므로
+ * (구분자가 들면 만들지 않았다) 이 변경으로 **바뀔 수 있는 것은 공백·`%`·`?`·`#` 이 든 값뿐**이다.
  */
+const STRUCTURE_BREAKING = /[%/:?# ]/g;
+const PERCENT_ENCODED = {
+    '%': '%25',
+    '/': '%2F',
+    ':': '%3A',
+    '?': '%3F',
+    '#': '%23',
+    ' ': '%20'
+};
 function underNamespace(namespace, marker, id) {
     const ns = namespace?.trim();
     if (!ns)
         return undefined;
-    const v = String(id);
-    /* 표준이 요구하는 「성분 하나」가 깨진다 — 구분자가 든 값은 만들지 않는다. */
-    if (!v || v.includes('/') || v.includes(':'))
+    const raw = String(id);
+    if (!raw)
         return undefined;
+    const v = raw.replace(STRUCTURE_BREAKING, c => PERCENT_ENCODED[c]);
     if (/^https?:\/\/[^/\s]+/.test(ns))
         return `${ns.replace(/\/+$/, '')}/${marker}/${v}`;
     /*
@@ -447,7 +496,30 @@ const CBV_URN_CLASS = /^urn:[^:\s]+:(?:[^:\s]+:)*class:[^:\s]+$/;
  * 합계만 본다 — 프리픽스가 몇 자리인지는 GS1 이 회사마다 다르게 배정하므로 우리가 알 수 없다.
  * 합계는 키 종류가 정한다: SGTIN 13(GTIN-14 의 표시자+13자리) · SSCC 17 · GRAI 12 · GDTI 12.
  */
-const GS1_KEY_DIGITS = { sgtin: 13, sscc: 17, grai: 12, gdti: 12 };
+/*
+ * 키마다 「숫자 마디의 자릿수 합」 — 이 표에 없는 키는 아래 함수가 **아무 말도 하지 않는다.**
+ *
+ * ── lgtin 이 빠져 있었다 (2026-09-04, plant 레인 실측) ──────────────────────
+ * `urn:epc:class:lgtin:880.01.LOT-A` 는 합이 5 인데 그냥 지났고, 같은 값을 sgtin 으로 적으면
+ * 거절됐다. **하필 로트로 관리하는 자재가 쓰는 종류다** — 원자재·화학·식품이 다 여기다.
+ *
+ * 규칙은 이미 이 파일의 `lgtinClass` 주석에 적혀 있었다("두 숫자 마디의 자릿수 합은 13", EPC TDS
+ * 2.1.0 §6.4.1). 규칙을 알고, 검사도 있고, **표에 키만 없었다.**
+ *
+ * 셋째 마디(로트)는 숫자가 아니다 — 아래 함수가 앞의 두 마디만 세므로 그대로 맞다.
+ *
+ * ── sgln 도 같이 없었다 ────────────────────────────────────────────────────
+ * 로트를 찾다가 봤다. GLN 은 검사숫자를 뺀 두 마디 합이 12 라 `grai`·`gdti` 와 같은 규칙인데
+ * 표에 없었다.
+ *
+ * 값이 흐르고 있는지는 재봤다: **아직 안 흐른다.** 접수면에 자리가 있고(`RefLocation.gs1Id`)
+ * 매핑도 그것을 옮기는데, plant 마스터의 자리 표에는 그 컬럼 자체가 없다(`properties` 안에도
+ * 없다 — 0건). 그러니 이 키를 더해서 **지금 거절되는 값은 없다.** 오는 날에 맞아 있으려고 둔다.
+ *
+ * `giai`(개별 자산)는 일부러 없다 — 자산 참조 길이가 가변이어서 **합이 고정되지 않는다**(전체
+ * 30자리 이내라는 상한만 있다). 자릿수로 판정할 수 없는 키를 표에 넣으면 맞는 값을 거절한다.
+ */
+const GS1_KEY_DIGITS = { sgtin: 13, lgtin: 13, sscc: 17, grai: 12, gdti: 12, sgln: 12 };
 /**
  * 그 GS1 키의 자리 수가 맞나 — 어긋나면 왜인지 말한다.
  *

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from './yms-profile.ts';
 export * from './canonical-record.ts';
 export * from './webhook.ts';
 export * from './oee.ts';
+export * from './rated-usage.ts';
 export * from './yield.ts';
 export * from './reliability.ts';
 export * from './erp.ts';

package/dist/index.js

@@ -41,6 +41,7 @@ export * from "./canonical-record.js";
 /* `webhook-signature.ts` 는 여기 없다 — `node:crypto` 를 쓰므로 `@operato/ops-contract/webhook` 으로만 나간다. */
 export * from "./webhook.js";
 export * from "./oee.js";
+export * from "./rated-usage.js";
 export * from "./yield.js";
 export * from "./reliability.js";
 export * from "./erp.js";

package/dist/oee.d.ts

@@ -11,8 +11,15 @@ export interface OeeCounters {
     setupMs: number;
     /** 고장(ADOT). */
     downMs: number;
+    /** 양품(GQ). */
     goodCount: number;
-    scrapCount: number;
+    /**
+     * **부적합 전체**(GQ 가 아닌 것 전부) — ISO 22400 의 **SQ 가 아니고 `SQ + RQ`** 다.
+     *
+     * 품질률 `GQ / (GQ + SQ + RQ)` 의 분모가 `goodCount + nonconformingCount` 로 정확히 맞는다.
+     * 예전 이름은 `scrapCount` 였고 폐기 수로 읽혔다 — §`QualityDelta`. vocabulary-guard: allow
+     */
+    nonconformingCount: number;
     /** 계획정지 — 계획 조업 시간에서 뺀다(점심·예방보전·교대). */
     holdMs?: number;
     /** 언제부터 쟀나. 없으면 잰 구간이 없는 것이고, 그때는 가동률을 낼 수 없다. */

package/dist/oee.js

@@ -33,7 +33,7 @@ export function computeOee(c, nowMs) {
     /* 대기는 남는 시간이다 — 계획 조업에서 생산·준비·고장을 뺀 것. 따로 재지 않아도 나온다. */
     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;
+    const produced = c.goodCount + c.nonconformingCount;
     if (produced <= 0)
         missing.push('produced-quantity');
     const quality = produced > 0 ? c.goodCount / produced : undefined;
@@ -57,6 +57,6 @@ export function computeOee(c, nowMs) {
         downMs: c.downMs,
         delayMs,
         goodCount: c.goodCount,
-        scrapCount: c.scrapCount
+        nonconformingCount: c.nonconformingCount
     };
 }

package/dist/operational-ingest.d.ts

@@ -19,6 +19,34 @@ export interface OperationalIngestOptions {
     /** 레코드에 시각이 없을 때 쓸 값 — 주지 않으면 그 레코드를 거부한다. */
     defaultEventTime?: string;
 }
+/**
+ * **객체 안쪽의 모양** — `object`·`object[]` 자리가 계약의 타입을 실제로 보게 한다.
+ *
+ * ── 왜 필요한가 (2026-09-04 실측, 인티그레이션 레인이 찾음) ────────────────
+ * `materialActual: 'object[]'` 은 **객체 배열이면 지나갔다.** 그래서 틀린 이름이 저널에 앉았다.
+ *
+ *   계약의 이름   definitionId
+ *   온 것         materialDefinitionId
+ *
+ *   적히나   예 — 저널에 그 줄이 그대로 있다
+ *   읽히나   아니오 — 계약의 타입으로 읽으면 undefined 다
+ *
+ * 거절도 경고도 없었다. **같은 계약의 ERP 경로는 이것을 잡는다**(§`erp.ts` 의 자재 줄 검사).
+ * 한 계약 안에 검사가 두 벌이고 한쪽만 봤다.
+ *
+ * 이름을 맞춰 달라고 원본에 청하는 것으로는 다음에 또 조용해진다 — 다음 원본이 `use: 'out'` 같은
+ * 것을 보내면 같은 일이 난다(실제로 그런 시드가 있었다: 계약에 `out` 이라는 낱말이 없다).
+ */
+export interface ObjectShape {
+    /** 반드시 있어야 하는 안쪽 필드 — 비어 있으면 그 줄을 거절한다. */
+    required?: readonly string[];
+    /** 안쪽 필드의 형 — 선언한 것만 본다. */
+    fields?: Readonly<Record<string, 'string' | 'number' | 'boolean'>>;
+    /** 낱말이 정해진 안쪽 필드 — 계약에 없는 낱말을 거절한다. */
+    enums?: Readonly<Record<string, readonly string[]>>;
+    /** 0 보다 커야 하는 수 — 「모른다」는 **비워서** 말한다(0 으로 말하지 않는다). */
+    positive?: readonly string[];
+}
 /**
  * 이 레코드가 어느 운영 사실인가 — **라우팅 판정을 한 곳에 둔다**(소비처가 각자 짐작하지 않게).
  *

package/dist/operational-ingest.js

@@ -34,7 +34,59 @@
  * 모르는 필드는 **조용히 버리지 않고 거부한다.** `taskID` 처럼 한 글자 틀린 이름은 통과시키면 영원히
  * 보이지 않는 손실이 된다(이 문에는 아직 옛 발신자가 없어 호환 부담도 없다).
  */
-import { OP_EVENT, DISPOSITION_DECISION } from "./contract.js";
+import { OP_EVENT, DISPOSITION_DECISION, MATERIAL_ACTUAL_USE } from "./contract.js";
+/**
+ * 객체 한 줄이 선언된 안쪽 모양을 지키나 — **선언하지 않은 자리는 보지 않는다.**
+ *
+ * 순수하다. 그래서 「어떤 줄이 거절되나」를 값만 바꿔 가며 잴 수 있다.
+ *
+ * ── 「모른다」를 0 으로 말하지 않는다 ───────────────────────────────────────
+ * `positive` 에 든 수는 0 보다 커야 한다. 라벨에 수량이 없는 것이 정상인 현장이 있는데(한 통·한
+ * 팔레트), 그때 **비워서** 말한다 — 0 으로 실으면 받는 쪽에서 「0개」와 「모른다」가 같아지고,
+ * 소요량 집계가 조용히 틀린다.
+ *
+ * 없는 필드는 `required` 가 아니면 그냥 없는 것이다. 이 함수가 채워 주지 않는다.
+ */
+function shapeErrors(where, row, shape) {
+    if (!shape)
+        return [];
+    const errors = [];
+    for (const f of shape.required ?? []) {
+        const v = row[f];
+        const empty = v === undefined || v === null || (typeof v === 'string' && !v.trim());
+        if (empty)
+            errors.push(`${where}.${f} 가 없다 — 계약이 요구하는 이름이다`);
+    }
+    for (const [f, t] of Object.entries(shape.fields ?? {})) {
+        const v = row[f];
+        if (v === undefined || v === null)
+            continue;
+        if (t === 'number' && (typeof v !== 'number' || !Number.isFinite(v))) {
+            errors.push(`${where}.${f} 가 수가 아니다: ${JSON.stringify(v)}`);
+        }
+        else if (t !== 'number' && typeof v !== t) {
+            errors.push(`${where}.${f} 가 ${t} 가 아니다: ${JSON.stringify(v)}`);
+        }
+    }
+    for (const [f, allowed] of Object.entries(shape.enums ?? {})) {
+        const v = row[f];
+        if (v === undefined || v === null)
+            continue;
+        if (!allowed.includes(String(v))) {
+            errors.push(`${where}.${f} 에 계약에 없는 낱말이 왔다: ${JSON.stringify(v)} (${allowed.join(' · ')})`);
+        }
+    }
+    for (const f of shape.positive ?? []) {
+        const v = row[f];
+        /* 없는 것은 「모른다」다 — 여기서 막지 않는다. 위 `required` 가 필요하면 거기서 막는다. */
+        if (v === undefined || v === null)
+            continue;
+        if (typeof v !== 'number' || !(v > 0)) {
+            errors.push(`${where}.${f} 가 0 이하다: ${JSON.stringify(v)} — 모르는 수량은 0 이 아니라 비워서 말한다`);
+        }
+    }
+    return errors;
+}
 /**
  * 닫아 둔 낱말과 그 이유.
  *  · 작업 상태 — 성과 폴드가 `completed`·`in-progress` 로 갈린다(`kpi-fold`).
@@ -72,6 +124,27 @@ const SPECS = {
             startedAtSimMs: 'number', outcome: 'string', priority: 'number', startTime: 'string', endTime: 'string',
             materialActual: 'object[]', recordTime: 'string'
         },
+        /*
+         * **자재 줄의 안쪽** — 계약의 `MaterialActual` 그대로다.
+         *
+         * `definitionId` 를 요구하는 이유: 이 이름이 없으면 그 줄이 무엇을 가리키는지 아무도 모른다.
+         * 실제로 `materialDefinitionId` 로 온 줄이 저널에 앉았고, 계약의 타입으로 읽으면 비어 있었다.
+         *
+         * `quantity` 를 `positive` 에 두는 이유: 「모른다」는 **비워서** 말한다. 0 으로 실으면 받는
+         * 쪽에서 「0개」와 구별되지 않고, 소요량 집계가 조용히 틀린다.
+         *
+         * `uom` 은 요구하지 않는다 — 계약에서 선택이다(§`MaterialActual`). ERP 경로는 요구하는데
+         * 그것은 **그 경로의 규칙**이다(정산에 단위 없는 수량을 쓸 수 없다). 커널이 그 규칙을 통째로
+         * 물려받으면 단위를 모르는 현장의 사실이 통째로 거절된다.
+         */
+        shapes: {
+            materialActual: {
+                required: ['definitionId', 'use'],
+                fields: { definitionId: 'string', lotId: 'string', quantity: 'number', uom: 'string' },
+                enums: { use: MATERIAL_ACTUAL_USE },
+                positive: ['quantity']
+            }
+        },
         enums: {
             status: TASK_STATUS,
             intent: ['transport', 'process', 'dwell'],
@@ -143,7 +216,7 @@ const SPECS = {
         matchOrder: 15,
         identity: 'moverId', // vocabulary-guard: allow 저널 와이어 필드
         /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
-        required: ['moverId', 'good', 'goodCount', 'scrapCount'], // vocabulary-guard: allow
+        required: ['moverId', 'good', 'goodCount', 'nonconformingCount'], // vocabulary-guard: allow
         /*
          * `taskId` 는 **귀속**이다 — 이 산출이 어느 작업의 것인가. 수량의 뜻은 바뀌지 않는다(설비 누적).
          *
@@ -153,7 +226,7 @@ const SPECS = {
          * 정체를 `taskId` 로 바꾸지 않는 이유는 OEE 가 설비 단위여서다. 정체를 옮기면 설비 누적을 셀 수
          * 없어진다.
          */
-        fields: { moverId: 'string', good: 'boolean', goodCount: 'number', scrapCount: 'number', taskId: 'string', recordTime: 'string' } // vocabulary-guard: allow
+        fields: { moverId: 'string', good: 'boolean', goodCount: 'number', nonconformingCount: 'number', taskId: 'string', recordTime: 'string' } // vocabulary-guard: allow
     },
     /*
      * **시험 결과** — 대상을 가리켜 들어온다(표준 `TestResult.TestableObjectID`).
@@ -400,7 +473,7 @@ export function ingestOperationalRecords(records, opts) {
                         errors.push(`${kind}.progress 는 0~1 비율이다: ${n}`);
                         break;
                     }
-                    if ((name === 'requested' || name === 'fulfilled' || name === 'goodCount' || name === 'scrapCount') && n < 0) {
+                    if ((name === 'requested' || name === 'fulfilled' || name === 'goodCount' || name === 'nonconformingCount') && n < 0) {
                         errors.push(`${kind}.${name} 가 음수다: ${n}`);
                         break;
                     }
@@ -428,6 +501,7 @@ export function ingestOperationalRecords(records, opts) {
                         errors.push(`${kind}.${name} 가 객체가 아니다: ${JSON.stringify(v)}`);
                         break;
                     }
+                    errors.push(...shapeErrors(`${kind}.${name}`, v, spec.shapes?.[name]));
                     data[name] = { ...v };
                     break;
                 }
@@ -436,6 +510,7 @@ export function ingestOperationalRecords(records, opts) {
                         errors.push(`${kind}.${name} 가 객체 배열이 아니다: ${JSON.stringify(v)}`);
                         break;
                     }
+                    v.forEach((x, i) => errors.push(...shapeErrors(`${kind}.${name}[${i}]`, x, spec.shapes?.[name])));
                     data[name] = v.map(x => ({ ...x }));
                     break;
                 }

package/dist/rated-usage.d.ts

@@ -0,0 +1,59 @@
+/** UN/CEFACT 권고 20 에서 **무차원 「하나」** — 「몇 번 썼나」의 단위. */
+export declare const USE_UOM = "C62";
+/** 정격 사용량 — 「얼마」와 「무엇으로」. */
+export interface RatedUsage {
+    /** 이만큼 쓰면 교체한다. 0 이나 음수는 정격이 아니다(§`ratedUsageOf`). */
+    limit: number;
+    /** 단위 — UN/CEFACT 권고 20. 「번」은 `USE_UOM`(`C62`), 길이는 `MTR` 등. */
+    uom: string;
+}
+/** 지금까지 쓴 양 — 정격과 **같은 단위여야** 견줄 수 있다. */
+export interface UsedUsage {
+    value: number;
+    uom: string;
+    /**
+     * 언제부터 센 것인가(ISO). 교정·오버홀이 자산을 처음 상태로 되돌리면 그 시각부터 다시 센다 —
+     * 되돌린 뒤에도 예전 양을 계속 세면 멀쩡한 지그가 정격 초과로 잠긴다.
+     *
+     * 없으면 「도입 이후 전체」로 읽는다. 그것은 짐작이 아니라 이 필드의 정의다.
+     */
+    since?: string;
+}
+/** 정격으로 판정할 수 없는 이유 — 「남은 것 0」으로 답하지 않는다. */
+export type RatedUsageMissing = 
+/** 정격을 선언하지 않았다. **무한이 아니라 모르는 것**이다 — 화면이 「제한 없음」으로 그리면 안 된다. */
+'not-declared'
+/** 정격이 0 이나 음수다 — 마스터가 잘못 적혔다. */
+ | 'invalid-limit'
+/** 쓴 양이 아직 없다 — 원천이 보내 주지 않았거나 아직 안 썼다. 둘을 여기서 가리지 않는다. */
+ | 'usage-unknown'
+/**
+ * 단위가 다르다 — **견주지 않는다.**
+ *
+ * 50미터 정격에 「120번 썼다」가 오면 답할 수 있는 것이 없다. 숫자만 견주면 120 > 50 이라
+ * 「수명 끝」이라고 말하는데, 그것은 참일 수도 거짓일 수도 있다.
+ */
+ | 'uom-mismatch';
+export interface RatedUsageStatus {
+    /** 정격 그대로. 없으면 없다. */
+    rated?: RatedUsage;
+    /** 쓴 양 그대로. 없으면 없다. */
+    used?: UsedUsage;
+    /** 남은 양 — **낼 수 없으면 없다.** */
+    remaining?: number;
+    /** 다 썼나 — 판정할 수 없으면 없다(`false` 가 아니다: 「아니다」와 「모른다」는 다르다). */
+    exhausted?: boolean;
+    /** 커널이 스스로 셀 수 있는 정격인가 — 「번」이면 참, 그 밖이면 거짓(§머리말). */
+    countable: boolean;
+    missing: RatedUsageMissing[];
+}
+/**
+ * 이 자원의 정격 사용 상태.
+ *
+ * **모르면 답하지 않는다.** 정격이 없으면 「무제한」이 아니고, 쓴 양이 없으면 「0」이 아니다. 둘 중
+ * 하나만 없어도 남은 양과 초과 여부를 내지 않는다 — 그때 화면은 「모른다」를 그려야 한다.
+ */
+export declare function ratedUsageOf(r: {
+    ratedUsage?: RatedUsage;
+    usedUsage?: UsedUsage;
+}): RatedUsageStatus;

package/dist/rated-usage.js

@@ -0,0 +1,60 @@
+/*
+ * **정격 사용량** — 소모 공구가 얼마를 쓰면 교체되나.
+ *
+ * ── 왜 필요한가 (2026-09-03, 미라텍 관리계획서) ─────────────────────────────
+ * 고객의 관리계획서가 공구마다 수명을 못 박아 둔다. 메탈마스크 5만 번, 스퀴즈 10만 번, EOL 프로브
+ * 핀 5만 번, 카메라 실리콘 패킹 10만 번, OQC 케이블 3만 번, **라우터 비트 50미터.**
+ *
+ * 트윈에 그 숫자를 담을 자리가 없었다. 그래서 정비 계획은 그것을 날수로 바꿔서 들고 있었다 —
+ * 「핀 5만 번 ÷ 하루 69대 = 720일」. 그 환산은 **생산량이 바뀌는 순간 틀리고**, 틀렸다는 것을
+ * 아무도 모른다. 라인을 증설하면 실제 수명은 반으로 줄지만 계획은 여전히 720일을 말한다.
+ *
+ * ── 단위를 함께 드는 이유 ────────────────────────────────────────────────────
+ * 여섯 중 다섯은 「번」이고 하나는 「미터」다. 숫자만 담는 칸에 라우터 비트를 넣으면 **50미터가
+ * 50번이 된다.** 한 번에 0.2미터를 깎는 공정이라면 실제 수명의 250분의 1에서 교체하라고 말하는
+ * 셈이다. 그래서 정격은 늘 「얼마」와 「무엇으로」 둘을 든다.
+ *
+ * 단위 어휘는 다른 자리와 같다 — UN/CEFACT 권고 20(§`MaterialQuantity.uom`).
+ *
+ * ── 커널이 스스로 셀 수 있는 경우와 없는 경우 ────────────────────────────────
+ * 정격이 「번」이면 작업이 끝날 때마다 하나 늘리면 된다. **「미터」면 늘릴 수 없다** — 그 작업이
+ * 몇 미터를 깎았는지는 공정이 말해 줘야 하는 사실이고, 커널이 「한 번이니 1미터」로 놓으면 그것은
+ * 지어낸 값이다.
+ *
+ * 그래서 커널은 셀 수 있는 것만 세고, 못 세는 것은 **못 센다고 말한다**(`countable`). 값이 오지
+ * 않으면 사용량은 비어 있고, 비어 있는 것은 0이 아니다.
+ */
+/** UN/CEFACT 권고 20 에서 **무차원 「하나」** — 「몇 번 썼나」의 단위. */
+export const USE_UOM = 'C62';
+const num = (n) => typeof n === 'number' && Number.isFinite(n);
+/**
+ * 이 자원의 정격 사용 상태.
+ *
+ * **모르면 답하지 않는다.** 정격이 없으면 「무제한」이 아니고, 쓴 양이 없으면 「0」이 아니다. 둘 중
+ * 하나만 없어도 남은 양과 초과 여부를 내지 않는다 — 그때 화면은 「모른다」를 그려야 한다.
+ */
+export function ratedUsageOf(r) {
+    const rated = r?.ratedUsage;
+    const used = r?.usedUsage;
+    const missing = [];
+    /* 셀 수 있는지는 정격의 단위만으로 정해진다 — 쓴 양이 아직 없어도 답할 수 있다. */
+    const countable = rated?.uom === USE_UOM;
+    if (!rated)
+        missing.push('not-declared');
+    else if (!num(rated.limit) || rated.limit <= 0)
+        missing.push('invalid-limit');
+    if (!used || !num(used.value))
+        missing.push('usage-unknown');
+    if (rated && used && rated.uom !== used.uom)
+        missing.push('uom-mismatch');
+    const out = {
+        ...(rated ? { rated } : {}),
+        ...(used ? { used } : {}),
+        countable,
+        missing
+    };
+    if (missing.length)
+        return out;
+    const remaining = Math.max(0, rated.limit - used.value);
+    return { ...out, remaining, exhausted: used.value >= rated.limit };
+}

package/dist/vocabulary.d.ts

@@ -8,7 +8,7 @@
  * (문서 쪽은 `test/doc-vocabulary-guard.test.ts` 가 **자기 목록**으로 본다 — 이 목록의 `node`·`mover` 는
  *  ADR 기록이 없어 문서의 개념 명사에까지 들이대지 않는다.)
  */
-export declare const RETIRED_VOCABULARY: readonly ["mover", "Mover", "MOVER", "node", "Node", "NODE", "BoardDef", "loadBoard"];
+export declare const RETIRED_VOCABULARY: readonly ["mover", "Mover", "MOVER", "node", "Node", "NODE", "BoardDef", "loadBoard", "scrapCount"];
 /**
  * 예외 — 남아 있는 것이 **정당한** 토큰. 각 항목에 이유가 붙는다.
  *

package/dist/vocabulary.js

@@ -20,7 +20,7 @@
  * (문서 쪽은 `test/doc-vocabulary-guard.test.ts` 가 **자기 목록**으로 본다 — 이 목록의 `node`·`mover` 는
  *  ADR 기록이 없어 문서의 개념 명사에까지 들이대지 않는다.)
  */
-export const RETIRED_VOCABULARY = ['mover', 'Mover', 'MOVER', 'node', 'Node', 'NODE', 'BoardDef', 'loadBoard'];
+export const RETIRED_VOCABULARY = ['mover', 'Mover', 'MOVER', 'node', 'Node', 'NODE', 'BoardDef', 'loadBoard', 'scrapCount'];
 /**
  * 예외 — 남아 있는 것이 **정당한** 토큰. 각 항목에 이유가 붙는다.
  *

package/dist-cjs/index.cjs

@@ -50,6 +50,7 @@ __export(index_exports, {
   GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
   LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
+  MATERIAL_ACTUAL_USE: () => MATERIAL_ACTUAL_USE,
   MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
   MES_BIZSTEP: () => MES_BIZSTEP,
   MES_COMMANDS: () => MES_COMMANDS,
@@ -66,6 +67,7 @@ __export(index_exports, {
   TWIN_AXES: () => TWIN_AXES,
   TWIN_PROPERTIES: () => TWIN_PROPERTIES,
   TWIN_RELATIONS: () => TWIN_RELATIONS,
+  USE_UOM: () => USE_UOM,
   UTC_OFFSET: () => UTC_OFFSET,
   VOCABULARY_EXCEPTIONS: () => VOCABULARY_EXCEPTIONS,
   VOCABULARY_TYPE: () => VOCABULARY_TYPE,
@@ -94,6 +96,7 @@ __export(index_exports, {
   checkSequenceRun: () => checkSequenceRun,
   classClosure: () => classClosure,
   classIdentifierViolation: () => classIdentifierViolation,
+  classUri: () => classUri,
   commandFromSpec: () => commandFromSpec,
   commandSpecGaps: () => commandSpecGaps,
   commandTypeOf: () => commandTypeOf,
@@ -107,6 +110,7 @@ __export(index_exports, {
   dueStatusOf: () => dueStatusOf,
   effectivityAt: () => effectivityAt,
   electricalUpstreamOf: () => electricalUpstreamOf,
+  equipmentClassMembership: () => equipmentClassMembership,
   erpCapabilityGaps: () => erpCapabilityGaps,
   expiryFromAttributes: () => expiryFromAttributes,
   gdtiUri: () => gdtiUri,
@@ -182,6 +186,7 @@ __export(index_exports, {
   procedureViolations: () => procedureViolations,
   propertiesOf: () => propertiesOf,
   quantityIn: () => quantityIn,
+  ratedUsageOf: () => ratedUsageOf,
   readBoardAssets: () => readBoardAssets,
   readBoardEquipment: () => readBoardEquipment,
   readBoardLocations: () => readBoardLocations,
@@ -352,6 +357,29 @@ function commandsOf(caps) {
   return [...out];
 }
 
+// src/rated-usage.ts
+var USE_UOM = "C62";
+var num = (n) => typeof n === "number" && Number.isFinite(n);
+function ratedUsageOf(r) {
+  const rated = r?.ratedUsage;
+  const used = r?.usedUsage;
+  const missing = [];
+  const countable = rated?.uom === USE_UOM;
+  if (!rated) missing.push("not-declared");
+  else if (!num(rated.limit) || rated.limit <= 0) missing.push("invalid-limit");
+  if (!used || !num(used.value)) missing.push("usage-unknown");
+  if (rated && used && rated.uom !== used.uom) missing.push("uom-mismatch");
+  const out = {
+    ...rated ? { rated } : {},
+    ...used ? { used } : {},
+    countable,
+    missing
+  };
+  if (missing.length) return out;
+  const remaining = Math.max(0, rated.limit - used.value);
+  return { ...out, remaining, exhausted: used.value >= rated.limit };
+}
+
 // src/contract.ts
 var ORDER_TERMINAL_STATUS = ["completed", "cancelled"];
 function isOrderTerminal(o) {
@@ -577,6 +605,12 @@ function classClosure(directIds, defs, at2) {
   }
   return out;
 }
+function equipmentClassMembership(e) {
+  const out = [];
+  for (const id of e?.equipmentClassIds ?? []) if (id && !out.includes(id)) out.push(id);
+  if (e?.kind && !out.includes(e.kind)) out.push(e.kind);
+  return out;
+}
 var PRIORITY_UNSET = Number.POSITIVE_INFINITY;
 function priorityRank(p) {
   return typeof p === "number" && Number.isFinite(p) ? p : PRIORITY_UNSET;
@@ -588,8 +622,8 @@ function dueStatusOf(x, nowIso) {
   if (!Number.isFinite(due) || !Number.isFinite(now)) return void 0;
   return now > due ? "late" : "on-time";
 }
-function subLotIdOf(classUri, location) {
-  return `${classUri}@${location}`;
+function subLotIdOf(classUri2, location) {
+  return `${classUri2}@${location}`;
 }
 function itemKeyOf(item) {
   return item.subLotId ?? item.epc;
@@ -757,6 +791,7 @@ function capabilityOf(r, ctx) {
   if (eff === "expired") return { available: false, reason: "retired" };
   if (r.held) return { available: false, reason: "held" };
   if (r.status === "down") return { available: false, reason: "down" };
+  if (ratedUsageOf(r).exhausted === true) return { available: false, reason: "worn-out" };
   if (at2) {
     const ms = parsedMs(at2);
     if (Number.isFinite(ms)) {
@@ -999,6 +1034,7 @@ function isFailureStatus(value) {
 function isPlannedStopStatus(value) {
   return normalizeEquipmentStatus(value) === "planned-stop";
 }
+var MATERIAL_ACTUAL_USE = ["consumed", "produced"];
 var CMD = {
   orderHold: "order.hold",
   orderResume: "order.resume",
@@ -2070,7 +2106,7 @@ function ingestEnergyRecords(records, opts) {
     const at2 = String(record?.at ?? "").trim() || opts.defaultEventTime;
     const atMs = at2 ? Date.parse(at2) : Number.NaN;
     if (!Number.isFinite(atMs)) errors.push("at \uC5C6\uC74C/\uD615\uC2DD \uC624\uB958 \u2014 \uC9C0\uAE08 \uC2DC\uAC01\uC73C\uB85C \uBA54\uC6B0\uBA74 \uB0A8\uC758 \uC218\uC694 \uAD6C\uAC04\uC5D0 \uC2E4\uB9B0\uB2E4");
-    const num = (v, name) => {
+    const num2 = (v, name) => {
       if (v === void 0 || v === null || v === "") return void 0;
       const n = Number(v);
       if (!Number.isFinite(n)) {
@@ -2079,9 +2115,9 @@ function ingestEnergyRecords(records, opts) {
       }
       return n;
     };
-    const kW = num(record?.kW, "kW");
-    const kWh = num(record?.kWh, "kWh");
-    const powerFactor = num(record?.powerFactor, "powerFactor");
+    const kW = num2(record?.kW, "kW");
+    const kWh = num2(record?.kWh, "kWh");
+    const powerFactor = num2(record?.powerFactor, "powerFactor");
     if (errors.length) {
       rejected.push({ record, errors });
       continue;
@@ -2126,7 +2162,7 @@ function ingestEnergyEquipmentRecords(records, opts) {
     const at2 = String(r?.at ?? "").trim() || opts.defaultEventTime;
     const atMs = at2 ? Date.parse(at2) : Number.NaN;
     if (!Number.isFinite(atMs)) errors.push("at \uC5C6\uC74C/\uD615\uC2DD \uC624\uB958 \u2014 \uC9C0\uAE08 \uC2DC\uAC01\uC73C\uB85C \uBA54\uC6B0\uBA74 \uC5B8\uC81C\uC758 \uC0C1\uD0DC\uC778\uC9C0 \uC54C \uC218 \uC5C6\uB2E4");
-    const num = (v, name, min, max) => {
+    const num2 = (v, name, min, max) => {
       if (v === void 0 || v === null || v === "") return void 0;
       const n = Number(v);
       if (!Number.isFinite(n)) {
@@ -2143,19 +2179,19 @@ function ingestEnergyEquipmentRecords(records, opts) {
       }
       return n;
     };
-    const generatedKW = num(r?.generatedKW, "generatedKW", 0);
-    const exportKW = num(r?.exportKW, "exportKW");
-    const soc = num(r?.soc, "soc", 0, 100);
-    const chargeKW = num(r?.chargeKW, "chargeKW", 0);
-    const dischargeKW = num(r?.dischargeKW, "dischargeKW", 0);
-    const minKW = num(r?.minKW, "minKW", 0);
+    const generatedKW = num2(r?.generatedKW, "generatedKW", 0);
+    const exportKW = num2(r?.exportKW, "exportKW");
+    const soc = num2(r?.soc, "soc", 0, 100);
+    const chargeKW = num2(r?.chargeKW, "chargeKW", 0);
+    const dischargeKW = num2(r?.dischargeKW, "dischargeKW", 0);
+    const minKW = num2(r?.minKW, "minKW", 0);
     let curtailable;
     if (r?.curtailable !== void 0 && r?.curtailable !== null) {
       if (typeof r.curtailable !== "boolean") errors.push(`curtailable \uAC00 \uCC38/\uAC70\uC9D3\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(r.curtailable)}`);
       else curtailable = r.curtailable;
     }
-    const dcVoltage = num(r?.dcVoltage, "dcVoltage", 0);
-    const dcCurrent = num(r?.dcCurrent, "dcCurrent", 0);
+    const dcVoltage = num2(r?.dcVoltage, "dcVoltage", 0);
+    const dcCurrent = num2(r?.dcCurrent, "dcCurrent", 0);
     const phases = (raw, name) => {
       if (raw === void 0 || raw === null) return void 0;
       if (!Array.isArray(raw)) {
@@ -2758,14 +2794,27 @@ function gdtiUri(companyPrefix, docType, serial) {
 function objectUri(namespace, objId) {
   return underNamespace(namespace, "obj", objId);
 }
+function classUri(namespace, classId) {
+  return underNamespace(namespace, "class", classId);
+}
 function bizTransactionUri(namespace, transId) {
   return underNamespace(namespace, "bt", transId);
 }
+var STRUCTURE_BREAKING = /[%/:?# ]/g;
+var PERCENT_ENCODED = {
+  "%": "%25",
+  "/": "%2F",
+  ":": "%3A",
+  "?": "%3F",
+  "#": "%23",
+  " ": "%20"
+};
 function underNamespace(namespace, marker, id) {
   const ns = namespace?.trim();
   if (!ns) return void 0;
-  const v = String(id);
-  if (!v || v.includes("/") || v.includes(":")) return void 0;
+  const raw = String(id);
+  if (!raw) return void 0;
+  const v = raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]);
   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(/:+$/, "")}:${marker}:${v}`;
@@ -2844,7 +2893,7 @@ var EPC_CLASS_PREFIXES = ["urn:epc:idpat:", "urn:epc:class:"];
 var DL_CANONICAL = "https://id.gs1.org/";
 var CBV_URL_CLASS = /^https?:\/\/[^/\s]+\/(?:[^/\s]+\/)*class\/[^/\s]+$/;
 var CBV_URN_CLASS = /^urn:[^:\s]+:(?:[^:\s]+:)*class:[^:\s]+$/;
-var GS1_KEY_DIGITS = { sgtin: 13, sscc: 17, grai: 12, gdti: 12 };
+var GS1_KEY_DIGITS = { sgtin: 13, lgtin: 13, sscc: 17, grai: 12, gdti: 12, sgln: 12 };
 function gs1KeyDigitViolation(uri) {
   if (!uri) return void 0;
   const m = /^urn:epc:(?:id|idpat|class):([a-z]+):([^:]+)$/.exec(uri);
@@ -3224,6 +3273,39 @@ function readEpochMs(raw) {
 }
 
 // src/operational-ingest.ts
+function shapeErrors(where, row, shape) {
+  if (!shape) return [];
+  const errors = [];
+  for (const f of shape.required ?? []) {
+    const v = row[f];
+    const empty = v === void 0 || v === null || typeof v === "string" && !v.trim();
+    if (empty) errors.push(`${where}.${f} \uAC00 \uC5C6\uB2E4 \u2014 \uACC4\uC57D\uC774 \uC694\uAD6C\uD558\uB294 \uC774\uB984\uC774\uB2E4`);
+  }
+  for (const [f, t] of Object.entries(shape.fields ?? {})) {
+    const v = row[f];
+    if (v === void 0 || v === null) continue;
+    if (t === "number" && (typeof v !== "number" || !Number.isFinite(v))) {
+      errors.push(`${where}.${f} \uAC00 \uC218\uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+    } else if (t !== "number" && typeof v !== t) {
+      errors.push(`${where}.${f} \uAC00 ${t} \uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+    }
+  }
+  for (const [f, allowed] of Object.entries(shape.enums ?? {})) {
+    const v = row[f];
+    if (v === void 0 || v === null) continue;
+    if (!allowed.includes(String(v))) {
+      errors.push(`${where}.${f} \uC5D0 \uACC4\uC57D\uC5D0 \uC5C6\uB294 \uB0B1\uB9D0\uC774 \uC654\uB2E4: ${JSON.stringify(v)} (${allowed.join(" \xB7 ")})`);
+    }
+  }
+  for (const f of shape.positive ?? []) {
+    const v = row[f];
+    if (v === void 0 || v === null) continue;
+    if (typeof v !== "number" || !(v > 0)) {
+      errors.push(`${where}.${f} \uAC00 0 \uC774\uD558\uB2E4: ${JSON.stringify(v)} \u2014 \uBAA8\uB974\uB294 \uC218\uB7C9\uC740 0 \uC774 \uC544\uB2C8\uB77C \uBE44\uC6CC\uC11C \uB9D0\uD55C\uB2E4`);
+    }
+  }
+  return errors;
+}
 var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
 var EQUIPMENT_STATUS2 = ["idle", "busy", "down", "setup", "planned-stop"];
 var PERSON_STATUS = ["idle", "busy"];
@@ -3260,6 +3342,27 @@ var SPECS = {
       materialActual: "object[]",
       recordTime: "string"
     },
+    /*
+     * **자재 줄의 안쪽** — 계약의 `MaterialActual` 그대로다.
+     *
+     * `definitionId` 를 요구하는 이유: 이 이름이 없으면 그 줄이 무엇을 가리키는지 아무도 모른다.
+     * 실제로 `materialDefinitionId` 로 온 줄이 저널에 앉았고, 계약의 타입으로 읽으면 비어 있었다.
+     *
+     * `quantity` 를 `positive` 에 두는 이유: 「모른다」는 **비워서** 말한다. 0 으로 실으면 받는
+     * 쪽에서 「0개」와 구별되지 않고, 소요량 집계가 조용히 틀린다.
+     *
+     * `uom` 은 요구하지 않는다 — 계약에서 선택이다(§`MaterialActual`). ERP 경로는 요구하는데
+     * 그것은 **그 경로의 규칙**이다(정산에 단위 없는 수량을 쓸 수 없다). 커널이 그 규칙을 통째로
+     * 물려받으면 단위를 모르는 현장의 사실이 통째로 거절된다.
+     */
+    shapes: {
+      materialActual: {
+        required: ["definitionId", "use"],
+        fields: { definitionId: "string", lotId: "string", quantity: "number", uom: "string" },
+        enums: { use: MATERIAL_ACTUAL_USE },
+        positive: ["quantity"]
+      }
+    },
     enums: {
       status: TASK_STATUS,
       intent: ["transport", "process", "dwell"],
@@ -3371,7 +3474,7 @@ var SPECS = {
     identity: "moverId",
     // vocabulary-guard: allow 저널 와이어 필드
     /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
-    required: ["moverId", "good", "goodCount", "scrapCount"],
+    required: ["moverId", "good", "goodCount", "nonconformingCount"],
     // vocabulary-guard: allow
     /*
      * `taskId` 는 **귀속**이다 — 이 산출이 어느 작업의 것인가. 수량의 뜻은 바뀌지 않는다(설비 누적).
@@ -3382,7 +3485,7 @@ var SPECS = {
      * 정체를 `taskId` 로 바꾸지 않는 이유는 OEE 가 설비 단위여서다. 정체를 옮기면 설비 누적을 셀 수
      * 없어진다.
      */
-    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", taskId: "string", recordTime: "string" }
+    fields: { moverId: "string", good: "boolean", goodCount: "number", nonconformingCount: "number", taskId: "string", recordTime: "string" }
     // vocabulary-guard: allow
   },
   /*
@@ -3614,7 +3717,7 @@ function ingestOperationalRecords(records, opts) {
             errors.push(`${kind}.progress \uB294 0~1 \uBE44\uC728\uC774\uB2E4: ${n}`);
             break;
           }
-          if ((name === "requested" || name === "fulfilled" || name === "goodCount" || name === "scrapCount") && n < 0) {
+          if ((name === "requested" || name === "fulfilled" || name === "goodCount" || name === "nonconformingCount") && n < 0) {
             errors.push(`${kind}.${name} \uAC00 \uC74C\uC218\uB2E4: ${n}`);
             break;
           }
@@ -3642,6 +3745,7 @@ function ingestOperationalRecords(records, opts) {
             errors.push(`${kind}.${name} \uAC00 \uAC1D\uCCB4\uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
             break;
           }
+          errors.push(...shapeErrors(`${kind}.${name}`, v, spec.shapes?.[name]));
           data[name] = { ...v };
           break;
         }
@@ -3650,6 +3754,9 @@ function ingestOperationalRecords(records, opts) {
             errors.push(`${kind}.${name} \uAC00 \uAC1D\uCCB4 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
             break;
           }
+          v.forEach(
+            (x, i) => errors.push(...shapeErrors(`${kind}.${name}[${i}]`, x, spec.shapes?.[name]))
+          );
           data[name] = v.map((x) => ({ ...x }));
           break;
         }
@@ -3790,7 +3897,7 @@ function validateScenario(def) {
 }
 
 // src/vocabulary.ts
-var RETIRED_VOCABULARY = ["mover", "Mover", "MOVER", "node", "Node", "NODE", "BoardDef", "loadBoard"];
+var RETIRED_VOCABULARY = ["mover", "Mover", "MOVER", "node", "Node", "NODE", "BoardDef", "loadBoard", "scrapCount"];
 var VOCABULARY_EXCEPTIONS = [
   /* ── 저널 와이어 필드 — append-only 역사이므로 이름을 바꾸지 않는다 ───────
    * 같은 사실이 시점에 따라 다른 키로 들어가면 낡은 이름보다 나쁘다. 개명은 이벤트 스키마
@@ -3894,7 +4001,7 @@ function computeOee(c, nowMs) {
   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;
+  const produced = c.goodCount + c.nonconformingCount;
   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");
@@ -3912,7 +4019,7 @@ function computeOee(c, nowMs) {
     downMs: c.downMs,
     delayMs,
     goodCount: c.goodCount,
-    scrapCount: c.scrapCount
+    nonconformingCount: c.nonconformingCount
   };
 }
 
@@ -4200,6 +4307,7 @@ function commandSpecGaps(specs, command) {
   GUARD_PRAGMA,
   ILMD_ATTR,
   LOCATION_SATURATION_NEAR,
+  MATERIAL_ACTUAL_USE,
   MATERIAL_PROPERTY,
   MES_BIZSTEP,
   MES_COMMANDS,
@@ -4216,6 +4324,7 @@ function commandSpecGaps(specs, command) {
   TWIN_AXES,
   TWIN_PROPERTIES,
   TWIN_RELATIONS,
+  USE_UOM,
   UTC_OFFSET,
   VOCABULARY_EXCEPTIONS,
   VOCABULARY_TYPE,
@@ -4244,6 +4353,7 @@ function commandSpecGaps(specs, command) {
   checkSequenceRun,
   classClosure,
   classIdentifierViolation,
+  classUri,
   commandFromSpec,
   commandSpecGaps,
   commandTypeOf,
@@ -4257,6 +4367,7 @@ function commandSpecGaps(specs, command) {
   dueStatusOf,
   effectivityAt,
   electricalUpstreamOf,
+  equipmentClassMembership,
   erpCapabilityGaps,
   expiryFromAttributes,
   gdtiUri,
@@ -4332,6 +4443,7 @@ function commandSpecGaps(specs, command) {
   procedureViolations,
   propertiesOf,
   quantityIn,
+  ratedUsageOf,
   readBoardAssets,
   readBoardEquipment,
   readBoardLocations,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/ops-contract",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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",