@operato/ops-contract 0.9.0 → 0.9.2

package/dist/actuation.d.ts

@@ -14,6 +14,32 @@ export type CommandState = (typeof COMMAND_STATE)[number];
 /** 이 커맨드를 낸 것이 누구인가 — 사람이 승인할 때 그 판단의 재료가 된다. */
 export declare const COMMAND_ORIGIN: readonly ["operator", "rule", "ai", "schedule"];
 export type CommandOrigin = (typeof COMMAND_ORIGIN)[number];
+/**
+ * 넘긴 조치가 **저쪽에서 실제로 무엇이 되었나** — 상태가 아니라 별개 사실이다.
+ *
+ * ── 왜 상태를 늘리지 않나 (2026-09-02) ────────────────────────────────────
+ * `acked` 는 「저쪽이 답했다」이고 종착 상태다. 여기에 「현장에 나갔다」를 상태로 이어 붙이면
+ * `acked` 가 종착이 아니게 되고, **되돌아오는 관측이 없는 커넥터의 조치가 영원히 끝나지 않은 것으로
+ * 보인다.** 그런 커넥터가 정상이다 — 관측을 되돌려 주는 능력은 커넥터의 성질이지 조치의 수명이 아니다.
+ *
+ * 그래서 수명(상태)과 효과(이 칸)를 갈랐다. 효과가 없는 조치는 그냥 효과가 없는 것이고, 화면은
+ * 「넘겼다」와 「저쪽에서 확인됐다」를 따로 말할 수 있다.
+ *
+ * ── 무엇이 효과인지는 커널이 정하지 않는다 ────────────────────────────────
+ * `status` 를 **그대로 적는다.** 오더 상태 어휘는 도메인 소유이고(§`OrderStatusDelta.status`), 어느
+ * 값이 「현장에 나갔다」인지는 현장마다 다르다. 커널이 그 방언을 알면 보편 계약이 깨진다.
+ *
+ * 커널이 아는 것은 **이어졌다**는 사실뿐이다 — 우리가 낸 지시의 식별자(`dispatchRef`)로 저쪽이
+ * 보고한 것이 돌아왔다. 그 값이 무엇을 뜻하는지는 그 어휘를 아는 쪽이 읽는다.
+ */
+export interface CommandEffect {
+    /** 저쪽이 보고한 상태 — **해석하지 않고 그대로.** */
+    status: string;
+    /** 그 보고를 관측한 시각. */
+    at: ISOTime;
+    /** 몇 번 보고됐나 — 상태가 여러 번 바뀌면 마지막 것이 위에 남고 이 수가 는다. */
+    seen: number;
+}
 /** 사람이 승인하거나 거절한 기록. **재기동을 넘어 살아야 한다.** */
 export interface CommandApproval {
     by: string;
@@ -48,6 +74,14 @@ export interface TwinCommand {
     approval?: CommandApproval;
     /** 어댑터가 돌려준 것 — 저쪽에서 무엇이 되었는지 되짚을 수 있어야 한다. */
     dispatchRef?: string;
+    /**
+     * 저쪽에서 실제로 무엇이 되었나 — **`dispatchRef` 가 없으면 이어 줄 길이 없다.**
+     *
+     * 넘기다 닿지 못한 조치는 식별자를 못 받는다. 그러면 저쪽이 실제로 받았는지 우리는 알 수 없고,
+     * 중복을 막는 것은 저쪽의 멱등성이다. 그 사실을 여기서 숨기지 않는다 — 이 칸이 빈 것은 「효과가
+     * 없었다」가 아니라 **「모른다」**다.
+     */
+    effect?: CommandEffect;
     error?: string;
 }
 /**

package/dist/contract.d.ts

@@ -3072,10 +3072,78 @@ export interface AssetStatusDelta extends EffectivePeriod {
  * 셋을 전이로 담을 수 없다 — 사유가 붙을 자리가 없고(기계가 서는 순간에는 왜 섰는지 아무도 모른다),
  * 계획·비계획을 나중에 정하며, 전이를 내지 않는 정지(자재 대기 · 작업자 부재)가 많다.
  */
+/**
+ * 설비가 그 구간에 어떤 상태였나 — **닫힌 목록이다.**
+ *
+ * ── 왜 닫나 (2026-09-03) ────────────────────────────────────────────────────
+ * 예전에는 `status: string` 이고 주석에만 다섯이 적혀 있었다. 그래서 커넥터가 `broken` 을 보내면
+ * **아무 오류 없이** 고장이 0건이 되고, 가동 시간 지표가 「고장이 없었다」로 답한다. 처분 결정을
+ * 열린 문자열로 두지 않는 이유와 같다(§`DISPOSITION_DECISION`) — 이 값이 **판정에 효과를 준다.**
+ *
+ * ISO 22400-2 의 시간 모델을 덮는다.
+ *
+ * ```
+ * busy          실 생산(APT) — 만들고 있었다
+ * setup         준비(AUST)
+ * down          고장(ADOT) — 가동 시간 지표가 세는 것
+ * idle          대기(ADET) — 자재·지시를 기다렸다. 고장이 아니다
+ * planned-stop  계획정지 — 계획 조업 시간에서 뺀다(점심·예방보전·교대)
+ * ```
+ *
+ * **`down` 과 `planned-stop` 을 가르는 것이 이 목록의 요점이다.** 둘을 한 낱말로 묶으면 예방보전을
+ * 할수록 설비가 고장난 것으로 보이고, 그러면 보전을 미루는 쪽이 지표에 유리해진다.
+ *
+ * 왜 이 값이 「사유」와 다른 축인가 — 사유(`reasonCode`)는 현장이 정하는 열린 값이고, 이 값은 우리가
+ * 정한 닫힌 분류다. 사유를 우리가 가르려 하면 현장마다 코드가 달라 못 가른다.
+ */
+export declare const EQUIPMENT_STATUS: readonly ["busy", "setup", "down", "idle", "planned-stop"];
+export type EquipmentStatus = (typeof EQUIPMENT_STATUS)[number];
+/** 선언된 상태인가. */
+export declare function isEquipmentStatus(value: unknown): value is EquipmentStatus;
+/**
+ * 원본의 낱말을 우리 상태로 옮긴다 — **모르면 `undefined` 다.**
+ *
+ * ── 옮길 표가 비어 있다. 일부러 비웠다 (2026-09-03) ─────────────────────────
+ * 처음에 `running`·`in-use`·`breakdown`·`stopped` 같은 흔한 동의어를 넣었다. **근거가 없었다.**
+ * 세어 보니 이렇다.
+ *
+ * ```
+ * operato-plant   busy·setup·down·idle·planned-stop 다섯만. 동의어 0곳 (그 레인이 세어 줌)
+ * ppms 커넥터      busy·idle·down 만
+ * chef · ems-scada 설비 상태를 안 보낸다
+ * ```
+ *
+ * 커널의 `isRunningStatus` 가 `busy`·`in-use`·`running` 셋을 받는 것을 근거로 삼았는데, 그것도
+ * 방어였다 — `running` 을 만드는 코드가 **한 곳도 없고**, `in-use` 는 **자산의 낱말**이다
+ * (`flow-engine.ts` 가 자산에 그 값을 준다). 그러니 `in-use → busy` 는 두 축을 섞는 것이고,
+ * 이 저장소가 다른 자리에서 계속 거절하는 모양이다.
+ *
+ * 소비처가 있는 것만 적는다 — `MES_COMMANDS` 가 같은 규율을 지킨다. 실제로 다른 낱말을 보내는
+ * 원본을 만나면 **그 낱말을 여기 적는다.** 그때 이 함수가 그 자리가 되고, 커넥터마다 다시 적어
+ * 흩어지지 않는다.
+ *
+ * 지금 하는 일은 둘이다 — 대소문자·공백을 다듬고, **모르는 낱말을 `undefined` 로 답한다.**
+ * 모름을 `idle` 로 채우면 고장이 조용히 사라지고, `down` 으로 채우면 부풀린다.
+ */
+export declare function normalizeEquipmentStatus(value: unknown): EquipmentStatus | undefined;
+/**
+ * 고장이었나 — **가동 시간 지표(MTBF)가 세는 것.**
+ *
+ * 계획정지·준비·대기는 고장이 아니다. 이 판정을 부르는 쪽마다 다시 쓰면 한 곳이 `planned-stop` 을
+ * 고장으로 세는 날이 오고, 그때 두 화면이 다른 수를 말한다.
+ */
+export declare function isFailureStatus(value: unknown): boolean;
+/** 계획정지였나 — 계획 조업 시간에서 빼는 것(§`OeeCounters.holdMs`). */
+export declare function isPlannedStopStatus(value: unknown): boolean;
 export interface EquipmentStatePeriodFact {
     moverId: string;
-    /** `busy` · `setup` · `down` · `idle` · `planned-stop` — ISO 22400 의 시간 모델을 덮는다. */
-    status: string;
+    /**
+     * 그 구간의 상태 — **선언된 다섯 중 하나**(§`EQUIPMENT_STATUS`).
+     *
+     * 원본의 낱말이 다르면 커넥터가 `normalizeEquipmentStatus` 로 옮긴다. 옮길 수 없는 값은 이 사실을
+     * 만들지 말고 그 사실을 말해야 한다 — 모르는 상태를 아무 것으로 채우면 지표가 조용히 틀린다.
+     */
+    status: EquipmentStatus;
     from: ISOTime;
     to: ISOTime;
     /** 사람이 정한 사유. 없을 수 있다 — 적지 않은 것과 사유가 없는 것은 다르므로 지어내지 않는다. */

package/dist/contract.js

@@ -1186,6 +1186,86 @@ export const ENERGY_EVENT = {
  * 커널은 이 값으로 판정하지 않는다 — 무엇을 믿을지는 현장이 정한다.
  */
 export const OBSERVATION_BASIS = ['metered', 'provider', 'billed', 'estimated'];
+/**
+ * **마감된 설비 상태 구간** — 이 설비가 이 구간 동안 이 상태였다.
+ *
+ * 시점의 전이(`EquipmentStatusDelta`)와 다른 사실이다. 전이는 「지금 이 상태로 바뀌었다」이고 이것은
+ * 「그 구간 동안 그 상태였다」다. 되돌아가 적는 사실이라 사건 시각이 `to` 다.
+ *
+ * 셋을 전이로 담을 수 없다 — 사유가 붙을 자리가 없고(기계가 서는 순간에는 왜 섰는지 아무도 모른다),
+ * 계획·비계획을 나중에 정하며, 전이를 내지 않는 정지(자재 대기 · 작업자 부재)가 많다.
+ */
+/**
+ * 설비가 그 구간에 어떤 상태였나 — **닫힌 목록이다.**
+ *
+ * ── 왜 닫나 (2026-09-03) ────────────────────────────────────────────────────
+ * 예전에는 `status: string` 이고 주석에만 다섯이 적혀 있었다. 그래서 커넥터가 `broken` 을 보내면
+ * **아무 오류 없이** 고장이 0건이 되고, 가동 시간 지표가 「고장이 없었다」로 답한다. 처분 결정을
+ * 열린 문자열로 두지 않는 이유와 같다(§`DISPOSITION_DECISION`) — 이 값이 **판정에 효과를 준다.**
+ *
+ * ISO 22400-2 의 시간 모델을 덮는다.
+ *
+ * ```
+ * busy          실 생산(APT) — 만들고 있었다
+ * setup         준비(AUST)
+ * down          고장(ADOT) — 가동 시간 지표가 세는 것
+ * idle          대기(ADET) — 자재·지시를 기다렸다. 고장이 아니다
+ * planned-stop  계획정지 — 계획 조업 시간에서 뺀다(점심·예방보전·교대)
+ * ```
+ *
+ * **`down` 과 `planned-stop` 을 가르는 것이 이 목록의 요점이다.** 둘을 한 낱말로 묶으면 예방보전을
+ * 할수록 설비가 고장난 것으로 보이고, 그러면 보전을 미루는 쪽이 지표에 유리해진다.
+ *
+ * 왜 이 값이 「사유」와 다른 축인가 — 사유(`reasonCode`)는 현장이 정하는 열린 값이고, 이 값은 우리가
+ * 정한 닫힌 분류다. 사유를 우리가 가르려 하면 현장마다 코드가 달라 못 가른다.
+ */
+export const EQUIPMENT_STATUS = ['busy', 'setup', 'down', 'idle', 'planned-stop'];
+/** 선언된 상태인가. */
+export function isEquipmentStatus(value) {
+    return typeof value === 'string' && EQUIPMENT_STATUS.includes(value);
+}
+/**
+ * 원본의 낱말을 우리 상태로 옮긴다 — **모르면 `undefined` 다.**
+ *
+ * ── 옮길 표가 비어 있다. 일부러 비웠다 (2026-09-03) ─────────────────────────
+ * 처음에 `running`·`in-use`·`breakdown`·`stopped` 같은 흔한 동의어를 넣었다. **근거가 없었다.**
+ * 세어 보니 이렇다.
+ *
+ * ```
+ * operato-plant   busy·setup·down·idle·planned-stop 다섯만. 동의어 0곳 (그 레인이 세어 줌)
+ * ppms 커넥터      busy·idle·down 만
+ * chef · ems-scada 설비 상태를 안 보낸다
+ * ```
+ *
+ * 커널의 `isRunningStatus` 가 `busy`·`in-use`·`running` 셋을 받는 것을 근거로 삼았는데, 그것도
+ * 방어였다 — `running` 을 만드는 코드가 **한 곳도 없고**, `in-use` 는 **자산의 낱말**이다
+ * (`flow-engine.ts` 가 자산에 그 값을 준다). 그러니 `in-use → busy` 는 두 축을 섞는 것이고,
+ * 이 저장소가 다른 자리에서 계속 거절하는 모양이다.
+ *
+ * 소비처가 있는 것만 적는다 — `MES_COMMANDS` 가 같은 규율을 지킨다. 실제로 다른 낱말을 보내는
+ * 원본을 만나면 **그 낱말을 여기 적는다.** 그때 이 함수가 그 자리가 되고, 커넥터마다 다시 적어
+ * 흩어지지 않는다.
+ *
+ * 지금 하는 일은 둘이다 — 대소문자·공백을 다듬고, **모르는 낱말을 `undefined` 로 답한다.**
+ * 모름을 `idle` 로 채우면 고장이 조용히 사라지고, `down` 으로 채우면 부풀린다.
+ */
+export function normalizeEquipmentStatus(value) {
+    const said = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return isEquipmentStatus(said) ? said : undefined;
+}
+/**
+ * 고장이었나 — **가동 시간 지표(MTBF)가 세는 것.**
+ *
+ * 계획정지·준비·대기는 고장이 아니다. 이 판정을 부르는 쪽마다 다시 쓰면 한 곳이 `planned-stop` 을
+ * 고장으로 세는 날이 오고, 그때 두 화면이 다른 수를 말한다.
+ */
+export function isFailureStatus(value) {
+    return normalizeEquipmentStatus(value) === 'down';
+}
+/** 계획정지였나 — 계획 조업 시간에서 빼는 것(§`OeeCounters.holdMs`). */
+export function isPlannedStopStatus(value) {
+    return normalizeEquipmentStatus(value) === 'planned-stop';
+}
 // ── Command 채널 어휘 — 트윈의 "행위(act)" 면 (prescriptive/트랜잭션 프론트엔드) ──
 // 코어 공통: order.hold/resume(할당 보류). 도메인: order.release(즉시 투입) 등은 handleCommand 로.
 export const CMD = {

package/dist/index.d.ts

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

package/dist/index.js

@@ -41,5 +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 "./yield.js";
+export * from "./reliability.js";
 export * from "./erp.js";
 export * from "./actuation.js";

package/dist/reliability.d.ts

@@ -0,0 +1,44 @@
+import type { ISOTime } from './contract.ts';
+/** 상태 구간 하나 — `EquipmentStatePeriodFact` 에서 셋만. */
+export interface ReliabilityPeriod {
+    status: string;
+    from: ISOTime;
+    to: ISOTime;
+}
+export interface MtbfInput {
+    /** 어느 설비의. */
+    equipmentId: string;
+    /** 그 설비의 상태 구간들. 순서는 상관없다 — 여기서 시각으로 세운다. */
+    periods: readonly ReliabilityPeriod[];
+}
+/** 낼 수 없는 이유 — 「0」이나 「무한」으로 답하지 않는다. */
+export type MtbfMissing = 
+/** 돈 시간이 없다 — 잰 구간에 `busy` 가 하나도 없다. */
+'no-operating-time'
+/** 고장이 없다 — 나눌 수가 0이다. 좋은 수가 아니라 **답할 수 없는** 것이다. */
+ | 'no-failure'
+/** 모르는 상태 낱말이 있다 — 조용히 빼면 고장이 사라진다. */
+ | 'unknown-status'
+/** 길이가 없거나 시각을 읽을 수 없는 구간이 있다. */
+ | 'invalid-period';
+export interface Mtbf {
+    equipmentId: string;
+    /** 고장 사이 평균 가동 시간(ms). **낼 수 없으면 없다.** */
+    mtbfMs?: number;
+    /** 분자 — `busy` 의 합. */
+    operatingMs: number;
+    /** 분모 — **고장으로 들어간 횟수**(이어진 `down` 은 한 번). */
+    failures: number;
+    /** 받은 `down` 구간의 수 — `failures` 와 다르면 이어진 것이 있었다. */
+    downPeriods: number;
+    /** 옮길 수 없던 상태 낱말들 — 무엇이 왔는지 말한다. */
+    unknownStatuses: string[];
+    missing: MtbfMissing[];
+}
+/**
+ * 이 설비의 MTBF.
+ *
+ * **모르는 상태를 만나면 답하지 않는다.** 빼고 계산하면 그 구간이 고장이었을 때 고장이 조용히
+ * 사라지고, 그러면 이 수가 실제보다 좋아진다 — 자료가 나쁠수록 수가 좋아지는 쪽은 두지 않는다.
+ */
+export declare function computeMtbf(input: MtbfInput): Mtbf;

package/dist/reliability.js

@@ -0,0 +1,105 @@
+/*
+ * **MTBF** — ISO 22400-2. 고장 사이에 얼마나 돌았나.
+ *
+ * ── 왜 구간을 받나 (집계 값이 아니라) ────────────────────────────────────────
+ * `computeMtbf(가동시간, 고장횟수)` 로 두면 **「고장 횟수」를 부르는 쪽이 센다.** 그러면 세는 방법이
+ * 갈리고, 갈린 것을 아무도 모른다 — 오늘 이 저장소에서 여러 번 본 부류다.
+ *
+ * 특히 한 가지를 부르는 쪽이 거의 틀린다(아래 §고장 하나). 그래서 구간을 그대로 받아 세는 것까지
+ * 계약이 한다.
+ *
+ * ── 분자는 **실 가동 시간**이다 ──────────────────────────────────────────────
+ * `busy` 만 더한다. 달력 시간이 아니고, `setup` 도 아니다.
+ *
+ * 표준의 시간 모델에서 준비(AUST)는 실 생산 시간(APT)이 아니다. 준비를 더하면 **준비가 긴 설비의
+ * MTBF 가 좋아진다** — 고장 사이에 더 오래 「돌았다」고 세어지기 때문이다. 그것은 이 수가 답하려는
+ * 물음이 아니다.
+ *
+ * 대기(`idle`)와 계획정지(`planned-stop`)도 안 더한다. 서 있는 동안에는 고장날 일이 없다.
+ *
+ * ── 고장 하나 — **이어진 `down` 은 한 번이다** ───────────────────────────────
+ * 원본이 정지를 토막으로 적는 일이 흔하다. 교대가 갈릴 때, 사유를 나중에 고칠 때, 날짜가 바뀔 때.
+ *
+ * ```
+ * down 08:00–14:00 · down 14:00–20:00      한 번 고장난 것이다
+ * 그것을 두 번으로 세면 MTBF 가 절반이 된다
+ * ```
+ *
+ * 그래서 구간의 수를 세지 않고 **고장으로 들어간 횟수**를 센다. 이어진 `down` 은 들어간 것이 한 번
+ * 이므로 한 번이다. 이 셈을 부르는 쪽에 맡기면 거의 틀리고, 틀린 쪽이 늘 **더 나쁜 수**를 낸다.
+ *
+ * ── 고장이 없으면 답하지 않는다 ──────────────────────────────────────────────
+ * 나누는 수가 0이다. 「무한히 안 고장났다」로 답하면 화면이 그것을 가장 좋은 수로 그리는데, 실제로는
+ * **아직 한 번도 안 고장난 것**이고 그 기간이 한 시간일 수도 있다.
+ *
+ * 그때는 돌았던 시간과 고장 0을 그대로 낸다 — 사람이 그 둘을 보고 판단한다.
+ */
+import { normalizeEquipmentStatus } from "./contract.js";
+const at = (t) => (typeof t === 'string' ? Date.parse(t) : NaN);
+/**
+ * 이 설비의 MTBF.
+ *
+ * **모르는 상태를 만나면 답하지 않는다.** 빼고 계산하면 그 구간이 고장이었을 때 고장이 조용히
+ * 사라지고, 그러면 이 수가 실제보다 좋아진다 — 자료가 나쁠수록 수가 좋아지는 쪽은 두지 않는다.
+ */
+export function computeMtbf(input) {
+    const { equipmentId } = input;
+    const missing = [];
+    const unknown = new Set();
+    /* 시각으로 세운다 — 받은 순서를 믿지 않는다. 이어짐 판정이 순서에 걸린다. */
+    const sorted = [...(input.periods ?? [])]
+        .map(p => ({ status: normalizeEquipmentStatus(p?.status), said: String(p?.status ?? ''), from: at(p?.from), to: at(p?.to) }))
+        .sort((a, b) => a.from - b.from);
+    let operatingMs = 0;
+    let failures = 0;
+    let downPeriods = 0;
+    let invalid = false;
+    /* 앞 구간이 고장이었나 — 이어진 `down` 을 한 번으로 세는 열쇠다. */
+    let wasDown = false;
+    for (const p of sorted) {
+        if (!Number.isFinite(p.from) || !Number.isFinite(p.to) || p.to <= p.from) {
+            invalid = true;
+            /* 길이 없는 구간은 이어짐 판정도 흐트린다 — 앞 상태를 그대로 두고 넘긴다. */
+            continue;
+        }
+        if (p.status === undefined) {
+            unknown.add(p.said);
+            /*
+             * 모르는 낱말은 **이어짐을 끊는다.** 그것이 고장이었는지 아닌지 모르므로, 앞뒤의 `down` 을
+             * 한 번으로 묶어도 두 번으로 세도 근거가 없다. 어차피 답하지 않을 것이라 여기서는 끊어 둔다.
+             */
+            wasDown = false;
+            continue;
+        }
+        if (p.status === 'busy')
+            operatingMs += p.to - p.from;
+        if (p.status === 'down') {
+            downPeriods++;
+            if (!wasDown)
+                failures++;
+            wasDown = true;
+        }
+        else {
+            wasDown = false;
+        }
+    }
+    if (invalid)
+        missing.push('invalid-period');
+    if (unknown.size)
+        missing.push('unknown-status');
+    if (operatingMs <= 0)
+        missing.push('no-operating-time');
+    if (failures === 0)
+        missing.push('no-failure');
+    const out = {
+        equipmentId,
+        operatingMs,
+        failures,
+        downPeriods,
+        unknownStatuses: [...unknown],
+        missing
+    };
+    if (missing.length)
+        return out;
+    return { ...out, mtbfMs: operatingMs / failures };
+}

package/dist/webhook-signature.js

@@ -5,7 +5,7 @@
  * 서명은 양쪽이 **한 글자까지 같은 규칙**을 써야 성립한다. 한쪽이 이어붙이는 순서를 바꾸면 다른 쪽은
  * 401 만 보고 이유를 알 수 없다. 그래서 만드는 함수와 확인하는 함수가 한 파일에 있어야 한다.
  *
- * 실제로 operato-mes 안에 `sign` 과 `verifySignature` 가 함께 있었는데, `verifySignature` 는 저장소
+ * 실제로 operato-plant 안에 `sign` 과 `verifySignature` 가 함께 있었는데, `verifySignature` 는 저장소
  * 어디에서도 불리지 않았다 — 확인할 수신부가 없었기 때문이다. 확인하는 쪽이 생기면서 그 함수의 자리가
  * 여기가 됐다.
  *

package/dist/webhook.d.ts

@@ -55,7 +55,7 @@ export declare const WEBHOOK_TOO_MANY = 429;
  * 봉투 하나 — 번호와 사실을 함께 든다.
  *
  * `scope` 가 **번호를 매기는 단위**다. 이것이 없으면 받는 쪽은 그 번호가 어느 줄의 번호인지 모르고,
- * 커서를 무엇으로 잡을지 짐작해야 한다. 실제로 operato-mes 가 `[domain, channel]` 마다 번호를 매기면서
+ * 커서를 무엇으로 잡을지 짐작해야 한다. 실제로 operato-plant 가 `[domain, channel]` 마다 번호를 매기면서
  * 봉투에는 `channel` 을 싣지 않고 있었다 — 두 채널이 흐르기 시작하면 두 줄의 번호가 한 커서에 섞여
  * 연속성 검사가 끊임없이 「비었다」로 답한다.
  *

package/dist/webhook.js

@@ -4,7 +4,7 @@
  * ── 왜 계약에 있나 (2026-08-31) ──────────────────────────────────────────
  * 보내는 쪽은 응답 코드 하나로 「다시 보낼 것인가 · 기다릴 것인가 · 사람을 부를 것인가」를 정한다.
  * 그 판단표가 양쪽에 따로 있으면 한쪽만 바뀌는 날이 온다. 실제로 그렇게 되어 있었다 — 트윈은 409 를
- * 「그 트윈이 실시간으로 돌지 않는다」로 쓰고 operato-mes 는 409 를 「번호가 비었다」로 읽었다.
+ * 「그 트윈이 실시간으로 돌지 않는다」로 쓰고 operato-plant 는 409 를 「번호가 비었다」로 읽었다.
  * 붙였다면 트윈이 「안 돈다」고 답하는 것을 MES 가 「번호가 비었다」로 읽어 같은 구간을 되풀이 보냈다.
  *
  * 계약 층의 기준이 「만드는 쪽과 읽는 쪽이 합의해야 하는가」이고, 응답 코드와 번호 규칙이 그것이다.

package/dist/yield.d.ts

@@ -0,0 +1,97 @@
+import type { ISOTime } from './contract.ts';
+/** 직행수율 하나의 단위 — **공정 하나**다. 경로 전체는 이름이 다르다(§아래). */
+export interface FirstPassInput {
+    /** 어느 작업지시의. */
+    jobOrderName: string;
+    /** 어느 공정의 — 실적이 이 값을 들고 있다. */
+    operationKey: string;
+    /**
+     * 그 공정에 **들어간 수**. 모르면 적지 않는다 — 아래 둘의 합이 대신 선다.
+     *
+     * **분모가 아니다.** 분모는 마친 수(양품+부적합)이고, 이 값은 **창이 닫혔는지**를 말한다 — 들어간
+     * 것보다 마친 것이 적으면 아직 공정에 남아 있다.
+     */
+    entered?: number;
+    /** 처음에 통과한 수 — **재작업해서 통과한 것을 여기 더하지 않는다**(§`FIRST_PASS_RULE`). */
+    good: number;
+    /**
+     * **부적합 처분이 달린 수** — 종류를 가리지 않는다.
+     *
+     * 이름을 `scrap` 으로 두지 않는다. 실적의 그 칸은 「부적합 전체」를 세는데 처분 어휘의 `scrap` 은
+     * 「폐기」 하나다(§`DISPOSITION_DECISION`). 같은 낱말이 두 뜻이라, 부르는 쪽이 「폐기 수」로 읽으면
+     * 재작업된 것이 분모에서 빠져 **직행수율이 100%로 나온다.** 오류는 안 난다.
+     */
+    nonconforming: number;
+}
+/**
+ * 분모는 **그 공정을 마친 수**다 — 양품과 부적합의 합.
+ *
+ * ── 왜 「들어간 수」가 분모가 아닌가 (첫 판을 고침) ─────────────────────────
+ * 처음에는 `들어간 수 − 부적합` 을 분자로 뒀다. **틀렸다.** 들어갔는데 아직 안 나온 것이 그 계산에서
+ * 「처음에 통과」로 세어진다 — 158이 들어가고 154가 나왔는데 160으로 잰다면 2개를 통과로 센다.
+ *
+ * 마친 수로 세면 그 수가 참이다. `entered` 는 분모가 아니라 **창이 닫혔는지**를 말하는 데 쓴다.
+ */
+export type FirstPassBasis = 'completed';
+/** 낼 수 없는 이유 — 「0%」로 답하지 않는다. */
+export type FirstPassMissing = 
+/** 마친 것이 없다 — 아직 아무 실적이 없다. */
+'no-input'
+/** 마친 수가 들어간 수보다 많다 — 재작업 산출을 되더한 자료가 여기서 걸린다. */
+ | 'inconsistent-counts'
+/** 수가 아니거나 음수다. */
+ | 'invalid-counts';
+export interface FirstPassYield {
+    jobOrderName: string;
+    operationKey: string;
+    /** 0~1. **낼 수 없으면 없다** — 0 으로 채우지 않는다. */
+    fpy?: number;
+    /** 분자로 쓴 수 — 처음에 통과한 수. */
+    firstPassGood: number;
+    /** 분모로 쓴 수 — 그 공정을 마친 수. */
+    completed: number;
+    basis: FirstPassBasis;
+    /**
+     * 아직 그 공정에 있는 수 — **`entered` 를 알 때만.**
+     *
+     * 이 값이 0보다 크면 창이 열려 있고, 그때의 수율은 「지금까지 마친 것」의 수율이다. 모르면 비어
+     * 있고, 그것은 「0개가 남았다」와 다르다.
+     */
+    inProcess?: number;
+    /** 낼 수 없던 이유들. 비어 있으면 낸 것이다. */
+    missing: FirstPassMissing[];
+}
+/**
+ * **이 수가 직행수율이 되기 위한 규율** — 계약이 글로 들고, 두 쪽이 같은 것을 지킨다.
+ *
+ * 트윈과 MES 가 각자 이 문장을 지키지 않으면 같은 이름으로 다른 수가 나오고, 그때 어느 쪽이 맞는지
+ * 말할 수 없다.
+ */
+export declare const FIRST_PASS_RULE = "\uC7AC\uC791\uC5C5\u00B7\uC218\uB9AC\uB85C \uD1B5\uACFC\uD55C \uC0B0\uCD9C\uC740 \uC6D0\uB798 \uACF5\uC815 \uC2E4\uC801\uC758 \uC591\uD488\uC5D0 \uB418\uB354\uD558\uC9C0 \uC54A\uB294\uB2E4 \u2014 \uADF8\uAC83\uC744 \uB354\uD558\uBA74 \uC774 \uC218\uB294 \uD488\uC9C8\uB960\uC774 \uB41C\uB2E4";
+/**
+ * 공정 하나의 직행수율.
+ *
+ * **경로 전체는 이 함수가 아니다.** 갈래가 합류하는 공장에서 공정별과 경로 전체는 다른 수이고, 경로
+ * 전체는 `rolledThroughputYield` 로 이름이 갈린다 — ISO 22400 의 KPI 가 아니라 다른 관행의 이름이라
+ * 섞으면 사람이 공정 하나의 수로 읽는다.
+ */
+export declare function computeFirstPassYield(input: FirstPassInput): FirstPassYield;
+/**
+ * **경로 전체의 수율** — 공정별 직행수율의 곱.
+ *
+ * ISO 22400 의 KPI 가 아니다. 다른 관행(식스시그마)의 이름이고, 그래서 **이름을 갈라 둔다** —
+ * 직행수율이라고 부르면 사람이 공정 하나의 수로 읽고, 「어느 공정을 고칠까」에 답할 수 없다.
+ *
+ * 하나라도 낼 수 없으면 **전체를 내지 않는다.** 빠진 공정을 1로 두고 곱하면 그 공정이 완벽했다는
+ * 뜻이 되고, 자료가 없을수록 수가 좋아진다.
+ */
+export declare function rolledThroughputYield(steps: readonly FirstPassYield[]): {
+    rty?: number;
+    countedSteps: number;
+    skipped: number;
+};
+/** 언제 잰 것인가 — 창이 열린 채로 센 수는 분모가 작다(§머리말). */
+export interface FirstPassWindow {
+    from?: ISOTime;
+    to?: ISOTime;
+}

package/dist/yield.js

@@ -0,0 +1,82 @@
+/**
+ * **이 수가 직행수율이 되기 위한 규율** — 계약이 글로 들고, 두 쪽이 같은 것을 지킨다.
+ *
+ * 트윈과 MES 가 각자 이 문장을 지키지 않으면 같은 이름으로 다른 수가 나오고, 그때 어느 쪽이 맞는지
+ * 말할 수 없다.
+ */
+export const FIRST_PASS_RULE = '재작업·수리로 통과한 산출은 원래 공정 실적의 양품에 되더하지 않는다 — 그것을 더하면 이 수는 품질률이 된다';
+const finite = (n) => typeof n === 'number' && Number.isFinite(n);
+/**
+ * 공정 하나의 직행수율.
+ *
+ * **경로 전체는 이 함수가 아니다.** 갈래가 합류하는 공장에서 공정별과 경로 전체는 다른 수이고, 경로
+ * 전체는 `rolledThroughputYield` 로 이름이 갈린다 — ISO 22400 의 KPI 가 아니라 다른 관행의 이름이라
+ * 섞으면 사람이 공정 하나의 수로 읽는다.
+ */
+export function computeFirstPassYield(input) {
+    const missing = [];
+    const { jobOrderName, operationKey } = input;
+    const good = input.good;
+    const bad = input.nonconforming;
+    const known = input.entered !== undefined;
+    if (!finite(good) || !finite(bad) || good < 0 || bad < 0 || (known && (!finite(input.entered) || input.entered < 0))) {
+        return { jobOrderName, operationKey, firstPassGood: 0, completed: 0, basis: 'completed', missing: ['invalid-counts'] };
+    }
+    const completed = good + bad;
+    if (completed <= 0)
+        missing.push('no-input');
+    /*
+     * 마친 수가 들어간 수보다 많으면 **답하지 않는다.** 어느 쪽이 틀렸는지 우리가 정할 수 없고, 그때
+     * 비율을 내면 그 수가 참인 척한다. 화면이 그것을 그리면 사람이 자료를 의심하지 않고 지표를 의심한다.
+     *
+     * 이 검사가 잡는 실제 경우가 하나 있다 — **재작업 산출을 원래 실적에 되더한 자료**다. 그러면 마친
+     * 수가 들어간 수를 넘고, 여기서 거절된다(§`FIRST_PASS_RULE`).
+     */
+    if (known && completed > input.entered)
+        missing.push('inconsistent-counts');
+    const inProcess = known ? Math.max(0, input.entered - completed) : undefined;
+    if (missing.length) {
+        return {
+            jobOrderName,
+            operationKey,
+            firstPassGood: good,
+            completed,
+            basis: 'completed',
+            ...(inProcess === undefined ? {} : { inProcess }),
+            missing
+        };
+    }
+    /*
+     * 분자는 **양품 수**다 — 규율이 지켜지면 그것이 곧 「처음에 통과한 수」다(§`FIRST_PASS_RULE`).
+     *
+     * **함수는 그 규율이 지켜졌는지 알 수 없다.** 재작업 산출이 그 칸에 되더해져 있으면 같은 식이 품질률을
+     * 낸다. 위의 일관성 검사가 `entered` 를 알 때만 그것을 잡는다 — 모를 때는 자료를 만드는 쪽이 규율을
+     * 지켜야 하고, 그래서 그 규율이 계약에 글로 있다.
+     */
+    return {
+        jobOrderName,
+        operationKey,
+        fpy: good / completed,
+        firstPassGood: good,
+        completed,
+        basis: 'completed',
+        ...(inProcess === undefined ? {} : { inProcess }),
+        missing
+    };
+}
+/**
+ * **경로 전체의 수율** — 공정별 직행수율의 곱.
+ *
+ * ISO 22400 의 KPI 가 아니다. 다른 관행(식스시그마)의 이름이고, 그래서 **이름을 갈라 둔다** —
+ * 직행수율이라고 부르면 사람이 공정 하나의 수로 읽고, 「어느 공정을 고칠까」에 답할 수 없다.
+ *
+ * 하나라도 낼 수 없으면 **전체를 내지 않는다.** 빠진 공정을 1로 두고 곱하면 그 공정이 완벽했다는
+ * 뜻이 되고, 자료가 없을수록 수가 좋아진다.
+ */
+export function rolledThroughputYield(steps) {
+    const usable = steps.filter(s => s.fpy !== undefined);
+    const skipped = steps.length - usable.length;
+    if (!usable.length || skipped > 0)
+        return { countedSteps: usable.length, skipped };
+    return { rty: usable.reduce((acc, s) => acc * s.fpy, 1), countedSteps: usable.length, skipped };
+}

package/dist-cjs/index.cjs

@@ -43,8 +43,10 @@ __export(index_exports, {
   EPCIS_CONTEXT: () => EPCIS_CONTEXT,
   EPCIS_EVENT: () => EPCIS_EVENT,
   EQUIPMENT_LEVEL: () => EQUIPMENT_LEVEL,
+  EQUIPMENT_STATUS: () => EQUIPMENT_STATUS,
   ERP_CAPABILITY: () => ERP_CAPABILITY,
   ERP_MASTER_AXIS: () => ERP_MASTER_AXIS,
+  FIRST_PASS_RULE: () => FIRST_PASS_RULE,
   GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
   LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
@@ -96,6 +98,8 @@ __export(index_exports, {
   commandSpecGaps: () => commandSpecGaps,
   commandTypeOf: () => commandTypeOf,
   commandsOf: () => commandsOf,
+  computeFirstPassYield: () => computeFirstPassYield,
+  computeMtbf: () => computeMtbf,
   computeOee: () => computeOee,
   conversionFactorOf: () => conversionFactorOf,
   criterionSaysNothing: () => criterionSaysNothing,
@@ -137,9 +141,12 @@ __export(index_exports, {
   isEnergyUsagePeriodRecord: () => isEnergyUsagePeriodRecord,
   isEpcisEventType: () => isEpcisEventType,
   isEquipmentLevel: () => isEquipmentLevel,
+  isEquipmentStatus: () => isEquipmentStatus,
+  isFailureStatus: () => isFailureStatus,
   isMasterDataRecord: () => isMasterDataRecord,
   isOperationalRecord: () => isOperationalRecord,
   isOrderTerminal: () => isOrderTerminal,
+  isPlannedStopStatus: () => isPlannedStopStatus,
   isTransformationRecord: () => isTransformationRecord,
   isoDurationHours: () => isoDurationHours,
   itemKeyOf: () => itemKeyOf,
@@ -157,6 +164,7 @@ __export(index_exports, {
   minuteOfDayAt: () => minuteOfDayAt,
   missingCommandPayload: () => missingCommandPayload,
   nextCommandState: () => nextCommandState,
+  normalizeEquipmentStatus: () => normalizeEquipmentStatus,
   objectEvent: () => objectEvent,
   objectUri: () => objectUri,
   observationAt: () => observationAt,
@@ -184,6 +192,7 @@ __export(index_exports, {
   resolveSubject: () => resolveSubject,
   retiredVocabularyIn: () => retiredVocabularyIn,
   reversalKey: () => reversalKey,
+  rolledThroughputYield: () => rolledThroughputYield,
   sgtinClass: () => sgtinClass,
   sgtinUri: () => sgtinUri,
   ssccUri: () => ssccUri,
@@ -396,19 +405,19 @@ function hierarchyOf(s, levelOfType) {
   }
   for (const start of known) {
     const seen = [start];
-    for (let at = parent.get(start); at !== void 0; at = parent.get(at)) {
-      if (seen.includes(at)) throw new Error(`location hierarchy has a cycle: ${[...seen, at].join(" \u2192 ")}`);
-      seen.push(at);
-      if (!known.has(at)) break;
+    for (let at2 = parent.get(start); at2 !== void 0; at2 = parent.get(at2)) {
+      if (seen.includes(at2)) throw new Error(`location hierarchy has a cycle: ${[...seen, at2].join(" \u2192 ")}`);
+      seen.push(at2);
+      if (!known.has(at2)) break;
     }
   }
   const homes = /* @__PURE__ */ new Map();
   for (const m of s.equipment ?? []) if (m.homeLocation) push(homes, m.homeLocation, m.id);
   const ancestorsOf = (id) => {
     const out = [];
-    for (let at = parent.get(id); at !== void 0; at = parent.get(at)) {
-      out.push(at);
-      if (!known.has(at)) break;
+    for (let at2 = parent.get(id); at2 !== void 0; at2 = parent.get(at2)) {
+      out.push(at2);
+      if (!known.has(at2)) break;
     }
     return out;
   };
@@ -463,18 +472,18 @@ var DISPOSITION_DECISION = [
   /** 아직 정하지 않았다 — 묶어 두고 쓰지 않는다. */
   "hold"
 ];
-function testPassedAt(r, at) {
+function testPassedAt(r, at2) {
   if (r.result !== "pass") return false;
-  if (!r.expiresAt || !at) return r.result === "pass";
-  return parsedMs(at) <= parsedMs(r.expiresAt);
+  if (!r.expiresAt || !at2) return r.result === "pass";
+  return parsedMs(at2) <= parsedMs(r.expiresAt);
 }
-function meetsTests(required, results, at) {
+function meetsTests(required, results, at2) {
   if (!required.length) return true;
   const bySpec = new Map((results ?? []).map((r) => [r.specId, r]));
   for (const specId of required) {
     const r = bySpec.get(specId);
     if (!r) continue;
-    if (!testPassedAt(r, at)) return false;
+    if (!testPassedAt(r, at2)) return false;
   }
   return true;
 }
@@ -523,9 +532,9 @@ function judgeAgainstSpec(spec, result) {
   }
   return allJudged ? "pass" : void 0;
 }
-function effectivityAt(p, at, opts) {
-  if (!p || !at) return void 0;
-  const atMs = parsedMs(at);
+function effectivityAt(p, at2, opts) {
+  if (!p || !at2) return void 0;
+  const atMs = parsedMs(at2);
   if (!Number.isFinite(atMs)) return void 0;
   const from = p.effectiveStart ? parsedMs(p.effectiveStart) : NaN;
   if (Number.isFinite(from) && atMs < from) return "not-yet";
@@ -535,12 +544,12 @@ function effectivityAt(p, at, opts) {
 }
 var PARSED_MAX = 64;
 var parsedCache = /* @__PURE__ */ new Map();
-function parsedMs(at) {
-  const hit = parsedCache.get(at);
+function parsedMs(at2) {
+  const hit = parsedCache.get(at2);
   if (hit !== void 0) return hit;
-  const ms = Date.parse(at);
+  const ms = Date.parse(at2);
   if (parsedCache.size >= PARSED_MAX) parsedCache.clear();
-  parsedCache.set(at, ms);
+  parsedCache.set(at2, ms);
   return ms;
 }
 var classIndexCache = /* @__PURE__ */ new WeakMap();
@@ -553,9 +562,9 @@ function classIndex(defs) {
   return built;
 }
 var EMPTY_CLASS_INDEX = /* @__PURE__ */ new Map();
-function classClosure(directIds, defs, at) {
+function classClosure(directIds, defs, at2) {
   const byId = classIndex(defs);
-  const inWindow = (d) => !d || effectivityAt(d, at) === void 0;
+  const inWindow = (d) => !d || effectivityAt(d, at2) === void 0;
   const out = /* @__PURE__ */ new Set();
   const stack = [...directIds ?? []];
   while (stack.length) {
@@ -725,14 +734,14 @@ function offCalendarAt(r, ms, utcOffsetMinutes) {
   const h = Math.floor(minute / 60);
   return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
 }
-function requiredTestsFor(directIds, defs, at) {
+function requiredTestsFor(directIds, defs, at2) {
   if (!defs?.length) return [];
   const cache = requiredTestsCache.get(defs) ?? /* @__PURE__ */ new Map();
   if (!requiredTestsCache.has(defs)) requiredTestsCache.set(defs, cache);
-  const key = `${at ?? ""}\0${(directIds ?? []).join("
")}`;
+  const key = `${at2 ?? ""}\0${(directIds ?? []).join("
")}`;
   const hit = cache.get(key);
   if (hit) return hit;
-  const closure = classClosure(directIds, defs, at);
+  const closure = classClosure(directIds, defs, at2);
   const required = [];
   for (const d of defs) if (closure.has(d.id)) required.push(...d.testSpecificationIds ?? []);
   if (cache.size >= REQUIRED_TESTS_MAX) cache.clear();
@@ -742,27 +751,27 @@ function requiredTestsFor(directIds, defs, at) {
 var REQUIRED_TESTS_MAX = 512;
 var requiredTestsCache = /* @__PURE__ */ new WeakMap();
 function capabilityOf(r, ctx) {
-  const at = ctx?.at;
-  const eff = effectivityAt(r, at);
+  const at2 = ctx?.at;
+  const eff = effectivityAt(r, at2);
   if (eff === "not-yet") return { available: false, reason: "not-yet" };
   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 (at) {
-    const ms = parsedMs(at);
+  if (at2) {
+    const ms = parsedMs(at2);
     if (Number.isFinite(ms)) {
       const why = offCalendarReasonAt(r, ms, ctx?.utcOffsetMinutes);
       if (why === "non-working") return { available: false, reason: "resting" };
       if (why === "off-hours") return { available: false, reason: "off-shift" };
     }
   }
-  if (ctx?.requiredTests?.length && !meetsTests(ctx.requiredTests, r.testResults, at))
+  if (ctx?.requiredTests?.length && !meetsTests(ctx.requiredTests, r.testResults, at2))
     return { available: false, reason: "test-expired" };
   if (r.status && r.status !== "idle" && r.status !== "available") return { available: false, reason: "working" };
   return { available: true, reason: "available" };
 }
-function observationAt(observations, propertyId, at) {
-  const t = parsedMs(at);
+function observationAt(observations, propertyId, at2) {
+  const t = parsedMs(at2);
   if (!(t >= 0)) return void 0;
   let best;
   let bestStart = -1;
@@ -976,6 +985,20 @@ var ENERGY_EVENT = {
   drSuggested: "energy.dr.suggested"
 };
 var OBSERVATION_BASIS = ["metered", "provider", "billed", "estimated"];
+var EQUIPMENT_STATUS = ["busy", "setup", "down", "idle", "planned-stop"];
+function isEquipmentStatus(value) {
+  return typeof value === "string" && EQUIPMENT_STATUS.includes(value);
+}
+function normalizeEquipmentStatus(value) {
+  const said = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return isEquipmentStatus(said) ? said : void 0;
+}
+function isFailureStatus(value) {
+  return normalizeEquipmentStatus(value) === "down";
+}
+function isPlannedStopStatus(value) {
+  return normalizeEquipmentStatus(value) === "planned-stop";
+}
 var CMD = {
   orderHold: "order.hold",
   orderResume: "order.resume",
@@ -2044,8 +2067,8 @@ function ingestEnergyRecords(records, opts) {
     const errors = [];
     const meterId = String(record?.meterId ?? "").trim();
     if (!meterId) errors.push("meterId \uC5C6\uC74C \u2014 \uC5B4\uB514\uC758 \uC18C\uBE44\uC778\uC9C0 \uBAA8\uB974\uB294 \uAC12\uC740 \uB204\uC801\uD560 \uC218 \uC5C6\uB2E4");
-    const at = String(record?.at ?? "").trim() || opts.defaultEventTime;
-    const atMs = at ? Date.parse(at) : Number.NaN;
+    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) => {
       if (v === void 0 || v === null || v === "") return void 0;
@@ -2100,8 +2123,8 @@ function ingestEnergyEquipmentRecords(records, opts) {
     const r = record;
     const equipmentId = String(r?.equipmentId ?? "").trim();
     if (!equipmentId) errors.push("equipmentId \uC5C6\uC74C \u2014 \uC5B4\uB290 \uC124\uBE44\uC758 \uC0C1\uD0DC\uC778\uC9C0 \uBAA8\uB974\uB294 \uAC12\uC740 \uC2E4\uC744 \uC218 \uC5C6\uB2E4");
-    const at = String(r?.at ?? "").trim() || opts.defaultEventTime;
-    const atMs = at ? Date.parse(at) : Number.NaN;
+    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) => {
       if (v === void 0 || v === null || v === "") return void 0;
@@ -2239,9 +2262,9 @@ function ingestEnergyGenerationRecords(records, opts) {
     const rawSince = r?.kWhSince;
     if (rawSince !== void 0 && rawSince !== null && String(rawSince).trim()) {
       const text = String(rawSince).trim();
-      const at = Date.parse(text);
-      if (!Number.isFinite(at)) errors.push(`kWhSince \uB97C \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(rawSince)}`);
-      else if (Number.isFinite(Date.parse(eventTime)) && at > Date.parse(eventTime)) {
+      const at2 = Date.parse(text);
+      if (!Number.isFinite(at2)) errors.push(`kWhSince \uB97C \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(rawSince)}`);
+      else if (Number.isFinite(Date.parse(eventTime)) && at2 > Date.parse(eventTime)) {
         errors.push(`kWhSince(${text}) \uAC00 \uC7B0 \uC2DC\uAC01(${eventTime})\uBCF4\uB2E4 \uB4A4\uB2E4 \u2014 \uB458 \uC911 \uD558\uB098\uAC00 \uD2C0\uB838\uB2E4`);
       } else since = text;
     }
@@ -3196,13 +3219,13 @@ function lotFromAttributes(attrs) {
 function readEpochMs(raw) {
   if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
   if (typeof raw !== "string" || !raw.trim()) return void 0;
-  const at = Date.parse(raw);
-  return Number.isNaN(at) ? void 0 : at;
+  const at2 = Date.parse(raw);
+  return Number.isNaN(at2) ? void 0 : at2;
 }
 
 // src/operational-ingest.ts
 var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
-var EQUIPMENT_STATUS = ["idle", "busy", "down", "setup", "planned-stop"];
+var EQUIPMENT_STATUS2 = ["idle", "busy", "down", "setup", "planned-stop"];
 var PERSON_STATUS = ["idle", "busy"];
 var ASSET_STATUS = ["idle", "in-use"];
 var SPECS = {
@@ -3270,7 +3293,7 @@ var SPECS = {
          재검사하지는 않는다: 그 모양은 `EquipmentMotion` 계약이고, 여기서 두 번 지키면 두 벌이 된다. */
       motion: "object"
     },
-    enums: { status: EQUIPMENT_STATUS }
+    enums: { status: EQUIPMENT_STATUS2 }
   },
   person: {
     eventType: OP_EVENT.person,
@@ -3415,7 +3438,7 @@ var SPECS = {
       decidedBy: "string",
       recordTime: "string"
     },
-    enums: { status: EQUIPMENT_STATUS }
+    enums: { status: EQUIPMENT_STATUS2 }
   },
   /*
    * **부적합 처분** — 재고 판정을 받은 것을 어떻게 하기로 정했나.
@@ -3633,8 +3656,8 @@ function ingestOperationalRecords(records, opts) {
       }
     }
     const closedPeriodEnd = kind === "equipment-period" ? String(r.to ?? "").trim() : "";
-    const at = closedPeriodEnd || String(r.at ?? "").trim() || opts.defaultEventTime;
-    const atMs = at ? Date.parse(at) : Number.NaN;
+    const at2 = closedPeriodEnd || String(r.at ?? "").trim() || opts.defaultEventTime;
+    const atMs = at2 ? Date.parse(at2) : Number.NaN;
     if (!Number.isFinite(atMs)) {
       errors.push(`${kind}: at \uC5C6\uC74C/\uD615\uC2DD \uC624\uB958 \u2014 \uC2DC\uAC01 \uC5C6\uC774\uB294 \uB2A6\uAC8C \uC628 \uC61B \uC0AC\uC2E4\uC744 \uAC78\uB7EC\uB0BC \uC218 \uC5C6\uB2E4`);
     }
@@ -3726,28 +3749,28 @@ function operationsCapabilityOf(input) {
 var DISTRIBUTIONS = /* @__PURE__ */ new Set(["poisson", "uniform", "constant", "profile"]);
 var isNum = (v) => typeof v === "number" && Number.isFinite(v);
 var bad = (errorCode, errorParams) => ({ ok: false, errorCode, errorParams });
-function validateGenerator(g, at) {
-  if (!g || typeof g !== "object") return bad("scenario-generator-invalid", { at });
-  if (!g.kind || typeof g.kind !== "string") return bad("scenario-generator-kind-required", { at });
+function validateGenerator(g, at2) {
+  if (!g || typeof g !== "object") return bad("scenario-generator-invalid", { at: at2 });
+  if (!g.kind || typeof g.kind !== "string") return bad("scenario-generator-kind-required", { at: at2 });
   const rate = g.rate;
-  if (!rate || typeof rate !== "object") return bad("scenario-rate-required", { at, kind: g.kind });
-  if (!isNum(rate.meanPerHour) || rate.meanPerHour < 0) return bad("scenario-rate-mean-invalid", { at, kind: g.kind });
-  if (!DISTRIBUTIONS.has(rate.distribution)) return bad("scenario-rate-distribution-invalid", { at, kind: g.kind, distribution: String(rate.distribution ?? "") });
-  if (rate.distribution === "profile" && !Array.isArray(rate.profile)) return bad("scenario-rate-profile-required", { at, kind: g.kind });
+  if (!rate || typeof rate !== "object") return bad("scenario-rate-required", { at: at2, kind: g.kind });
+  if (!isNum(rate.meanPerHour) || rate.meanPerHour < 0) return bad("scenario-rate-mean-invalid", { at: at2, kind: g.kind });
+  if (!DISTRIBUTIONS.has(rate.distribution)) return bad("scenario-rate-distribution-invalid", { at: at2, kind: g.kind, distribution: String(rate.distribution ?? "") });
+  if (rate.distribution === "profile" && !Array.isArray(rate.profile)) return bad("scenario-rate-profile-required", { at: at2, kind: g.kind });
   const content = g.content;
-  if (!content || typeof content !== "object") return bad("scenario-content-required", { at, kind: g.kind });
-  if (!Array.isArray(content.skuMix) || content.skuMix.length === 0) return bad("scenario-sku-mix-required", { at, kind: g.kind });
+  if (!content || typeof content !== "object") return bad("scenario-content-required", { at: at2, kind: g.kind });
+  if (!Array.isArray(content.skuMix) || content.skuMix.length === 0) return bad("scenario-sku-mix-required", { at: at2, kind: g.kind });
   for (const s of content.skuMix) {
-    if (!s?.gtin || typeof s.gtin !== "string") return bad("scenario-sku-gtin-required", { at, kind: g.kind });
-    if (!isNum(s.weight) || s.weight <= 0) return bad("scenario-sku-weight-invalid", { at, kind: g.kind, gtin: String(s.gtin) });
+    if (!s?.gtin || typeof s.gtin !== "string") return bad("scenario-sku-gtin-required", { at: at2, kind: g.kind });
+    if (!isNum(s.weight) || s.weight <= 0) return bad("scenario-sku-weight-invalid", { at: at2, kind: g.kind, gtin: String(s.gtin) });
   }
   const q = content.qtyPerLine;
-  if (!q || !isNum(q.min) || !isNum(q.max)) return bad("scenario-qty-required", { at, kind: g.kind });
-  if (q.min < 0 || q.max < q.min) return bad("scenario-qty-range-invalid", { at, kind: g.kind, min: q.min, max: q.max });
+  if (!q || !isNum(q.min) || !isNum(q.max)) return bad("scenario-qty-required", { at: at2, kind: g.kind });
+  if (q.min < 0 || q.max < q.min) return bad("scenario-qty-range-invalid", { at: at2, kind: g.kind, min: q.min, max: q.max });
   const l = content.linesPerOrder;
-  if (l && (!isNum(l.min) || !isNum(l.max) || l.min < 1 || l.max < l.min)) return bad("scenario-lines-range-invalid", { at, kind: g.kind });
+  if (l && (!isNum(l.min) || !isNum(l.max) || l.min < 1 || l.max < l.min)) return bad("scenario-lines-range-invalid", { at: at2, kind: g.kind });
   if (g.stimulus !== void 0 && g.stimulus !== "arrival" && g.stimulus !== "order") {
-    return bad("scenario-stimulus-invalid", { at, kind: g.kind, stimulus: String(g.stimulus) });
+    return bad("scenario-stimulus-invalid", { at: at2, kind: g.kind, stimulus: String(g.stimulus) });
   }
   return { ok: true };
 }
@@ -3893,6 +3916,98 @@ function computeOee(c, nowMs) {
   };
 }
 
+// src/yield.ts
+var FIRST_PASS_RULE = "\uC7AC\uC791\uC5C5\xB7\uC218\uB9AC\uB85C \uD1B5\uACFC\uD55C \uC0B0\uCD9C\uC740 \uC6D0\uB798 \uACF5\uC815 \uC2E4\uC801\uC758 \uC591\uD488\uC5D0 \uB418\uB354\uD558\uC9C0 \uC54A\uB294\uB2E4 \u2014 \uADF8\uAC83\uC744 \uB354\uD558\uBA74 \uC774 \uC218\uB294 \uD488\uC9C8\uB960\uC774 \uB41C\uB2E4";
+var finite = (n) => typeof n === "number" && Number.isFinite(n);
+function computeFirstPassYield(input) {
+  const missing = [];
+  const { jobOrderName, operationKey } = input;
+  const good = input.good;
+  const bad2 = input.nonconforming;
+  const known = input.entered !== void 0;
+  if (!finite(good) || !finite(bad2) || good < 0 || bad2 < 0 || known && (!finite(input.entered) || input.entered < 0)) {
+    return { jobOrderName, operationKey, firstPassGood: 0, completed: 0, basis: "completed", missing: ["invalid-counts"] };
+  }
+  const completed = good + bad2;
+  if (completed <= 0) missing.push("no-input");
+  if (known && completed > input.entered) missing.push("inconsistent-counts");
+  const inProcess = known ? Math.max(0, input.entered - completed) : void 0;
+  if (missing.length) {
+    return {
+      jobOrderName,
+      operationKey,
+      firstPassGood: good,
+      completed,
+      basis: "completed",
+      ...inProcess === void 0 ? {} : { inProcess },
+      missing
+    };
+  }
+  return {
+    jobOrderName,
+    operationKey,
+    fpy: good / completed,
+    firstPassGood: good,
+    completed,
+    basis: "completed",
+    ...inProcess === void 0 ? {} : { inProcess },
+    missing
+  };
+}
+function rolledThroughputYield(steps) {
+  const usable = steps.filter((s) => s.fpy !== void 0);
+  const skipped = steps.length - usable.length;
+  if (!usable.length || skipped > 0) return { countedSteps: usable.length, skipped };
+  return { rty: usable.reduce((acc, s) => acc * s.fpy, 1), countedSteps: usable.length, skipped };
+}
+
+// src/reliability.ts
+var at = (t) => typeof t === "string" ? Date.parse(t) : NaN;
+function computeMtbf(input) {
+  const { equipmentId } = input;
+  const missing = [];
+  const unknown = /* @__PURE__ */ new Set();
+  const sorted = [...input.periods ?? []].map((p) => ({ status: normalizeEquipmentStatus(p?.status), said: String(p?.status ?? ""), from: at(p?.from), to: at(p?.to) })).sort((a, b) => a.from - b.from);
+  let operatingMs = 0;
+  let failures = 0;
+  let downPeriods = 0;
+  let invalid = false;
+  let wasDown = false;
+  for (const p of sorted) {
+    if (!Number.isFinite(p.from) || !Number.isFinite(p.to) || p.to <= p.from) {
+      invalid = true;
+      continue;
+    }
+    if (p.status === void 0) {
+      unknown.add(p.said);
+      wasDown = false;
+      continue;
+    }
+    if (p.status === "busy") operatingMs += p.to - p.from;
+    if (p.status === "down") {
+      downPeriods++;
+      if (!wasDown) failures++;
+      wasDown = true;
+    } else {
+      wasDown = false;
+    }
+  }
+  if (invalid) missing.push("invalid-period");
+  if (unknown.size) missing.push("unknown-status");
+  if (operatingMs <= 0) missing.push("no-operating-time");
+  if (failures === 0) missing.push("no-failure");
+  const out = {
+    equipmentId,
+    operatingMs,
+    failures,
+    downPeriods,
+    unknownStatuses: [...unknown],
+    missing
+  };
+  if (missing.length) return out;
+  return { ...out, mtbfMs: operatingMs / failures };
+}
+
 // src/erp.ts
 var SCHEDULE_STATUS = ["draft", "released", "started", "completed", "closed", "cancelled"];
 function acceptsPerformance(status) {
@@ -4078,8 +4193,10 @@ function commandSpecGaps(specs, command) {
   EPCIS_CONTEXT,
   EPCIS_EVENT,
   EQUIPMENT_LEVEL,
+  EQUIPMENT_STATUS,
   ERP_CAPABILITY,
   ERP_MASTER_AXIS,
+  FIRST_PASS_RULE,
   GUARD_PRAGMA,
   ILMD_ATTR,
   LOCATION_SATURATION_NEAR,
@@ -4131,6 +4248,8 @@ function commandSpecGaps(specs, command) {
   commandSpecGaps,
   commandTypeOf,
   commandsOf,
+  computeFirstPassYield,
+  computeMtbf,
   computeOee,
   conversionFactorOf,
   criterionSaysNothing,
@@ -4172,9 +4291,12 @@ function commandSpecGaps(specs, command) {
   isEnergyUsagePeriodRecord,
   isEpcisEventType,
   isEquipmentLevel,
+  isEquipmentStatus,
+  isFailureStatus,
   isMasterDataRecord,
   isOperationalRecord,
   isOrderTerminal,
+  isPlannedStopStatus,
   isTransformationRecord,
   isoDurationHours,
   itemKeyOf,
@@ -4192,6 +4314,7 @@ function commandSpecGaps(specs, command) {
   minuteOfDayAt,
   missingCommandPayload,
   nextCommandState,
+  normalizeEquipmentStatus,
   objectEvent,
   objectUri,
   observationAt,
@@ -4219,6 +4342,7 @@ function commandSpecGaps(specs, command) {
   resolveSubject,
   retiredVocabularyIn,
   reversalKey,
+  rolledThroughputYield,
   sgtinClass,
   sgtinUri,
   ssccUri,

package/package.json

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