@operato/ops-contract 0.7.2 → 0.8.1

package/dist/actuation.d.ts

@@ -0,0 +1,157 @@
+import type { ISOTime } from './contract.ts';
+/**
+ * 커맨드의 상태.
+ *
+ *   proposed    트윈이 냈다. 아직 아무 일도 일어나지 않았다
+ *   approved    사람이 승인했다 — 누가 · 언제가 함께 남는다
+ *   rejected    사람이 거절했다. 여기서 끝난다
+ *   dispatched  어댑터에 넘겼다. 저쪽이 받았는지는 아직 모른다
+ *   acked       저쪽이 답했다
+ *   failed      넘기다 실패했다. 다시 넘길 수 있다
+ */
+export declare const COMMAND_STATE: readonly ["proposed", "approved", "rejected", "dispatched", "acked", "failed"];
+export type CommandState = (typeof COMMAND_STATE)[number];
+/** 이 커맨드를 낸 것이 누구인가 — 사람이 승인할 때 그 판단의 재료가 된다. */
+export declare const COMMAND_ORIGIN: readonly ["operator", "rule", "ai", "schedule"];
+export type CommandOrigin = (typeof COMMAND_ORIGIN)[number];
+/** 사람이 승인하거나 거절한 기록. **재기동을 넘어 살아야 한다.** */
+export interface CommandApproval {
+    by: string;
+    at: ISOTime;
+    note?: string;
+}
+/**
+ * 현장에 내리는 조치 하나.
+ *
+ * `reversible` 의 기본은 **종류가 정한다**(§`CommandTypeSpec.reversible`). 커맨드가 그것을 들고 다니는
+ * 이유는 저장되고 되세워지기 때문이다 — 명세를 매번 다시 찾지 않는다.
+ *
+ * **커맨드는 더 엄하게만 갈 수 있다.** 종류가 「되돌릴 수 있다」고 해도 그 한 건이 되돌릴 수 없다면
+ * 그렇게 적을 수 있다(절반 만든 작업의 취소). 반대는 안 된다 — 종류가 되돌릴 수 없다고 한 것을 커맨드가
+ * 뒤집으면 게이트가 그 한 건에서만 열리고, 그것이 이 자리에서 가장 나쁜 결과다.
+ */
+export interface TwinCommand {
+    id: string;
+    /** 어느 트윈의 조치인가. */
+    instanceId: string;
+    /** 무엇을 하라는 것인가 — 트윈 어휘. 레거시 호출로 옮기는 것은 어댑터의 일이다. */
+    type: string;
+    payload?: Record<string, unknown>;
+    origin: CommandOrigin;
+    proposedAt: ISOTime;
+    /**
+     * 되돌릴 수 있는가. **모르면 적지 않는다** — 없는 것은 「되돌릴 수 없다」로 읽는다.
+     * 모름을 「되돌릴 수 있다」로 읽으면 그 커맨드가 승인 없이 나간다.
+     */
+    reversible?: boolean;
+    state: CommandState;
+    approval?: CommandApproval;
+    /** 어댑터가 돌려준 것 — 저쪽에서 무엇이 되었는지 되짚을 수 있어야 한다. */
+    dispatchRef?: string;
+    error?: string;
+}
+/**
+ * 사람이 먼저 봐야 하는가.
+ *
+ * **모르면 봐야 한다.** `reversible` 이 참이라고 명시된 것만 게이트를 지나지 않는다 — 판단하지 못한
+ * 커맨드가 자동으로 나가는 쪽이 반대보다 훨씬 나쁘다.
+ */
+export declare function requiresApproval(command: Pick<TwinCommand, 'reversible'>): boolean;
+/** 상태를 옮기는 사건. */
+export declare const COMMAND_EVENT: readonly ["approve", "reject", "dispatch", "ack", "fail"];
+export type CommandEvent = (typeof COMMAND_EVENT)[number];
+/** 그 전이가 허용되나 — 허용되면 다음 상태, 아니면 `undefined`. */
+export declare function nextCommandState(from: CommandState, event: CommandEvent): CommandState | undefined;
+/** 더 갈 곳이 없는 상태인가 — 목록에서 지워도 되는지 화면이 이것으로 판단한다. */
+export declare function isCommandTerminal(state: CommandState): boolean;
+declare const approvedBrand: unique symbol;
+/**
+ * **승인을 지난 커맨드** — 조치를 부르는 함수는 이것만 받는다.
+ *
+ * 이 표식은 `approveCommand` 로만 붙는다. 그래서 승인 없는 커맨드를 조치에 넘기는 코드는 **컴파일이
+ * 되지 않는다.** 부르는 자리마다 참·거짓을 확인하는 방식과 다른 점이 이것이다 — 확인을 빠뜨릴 자리가
+ * 없다.
+ *
+ * 우회하려면 `as` 로 억지로 만들어야 하고, 그것은 검토에서 보인다.
+ */
+export type ApprovedCommand = TwinCommand & {
+    readonly [approvedBrand]: true;
+};
+/**
+ * 승인한다 — **승인할 수 없는 것은 던진다.**
+ *
+ * 조용히 실패하지 않는 이유는, 실패를 답으로 돌려주면 부르는 쪽이 그것을 무시할 수 있기 때문이다.
+ * 승인이 안 된 것을 승인된 줄 알고 넘기는 것이 이 자리에서 가장 나쁜 결과다.
+ */
+export declare function approveCommand(command: TwinCommand, approval: CommandApproval): ApprovedCommand;
+/**
+ * 되돌릴 수 있는 커맨드를 사람 없이 통과시킨다 — **게이트를 여는 유일한 다른 문**이다.
+ *
+ * 시뮬레이션과 what-if 가 이 길로 간다. 되돌릴 수 없는 것에 이 함수를 쓰면 던진다 — 그것이 이 문의
+ * 뜻이고, 뜻을 어기면 게이트가 없는 것과 같아진다.
+ */
+export declare function passThroughReversible(command: TwinCommand): ApprovedCommand;
+/**
+ * 승인 표식이 붙었는지 실행 중에도 본다 — **타입만으로는 부족한 자리가 있다.**
+ *
+ * 저장소에서 되세운 커맨드는 타입이 지워진 채로 온다(JSON 에는 표식이 없다). 그때 이 함수로 확인하고
+ * 다시 표식을 붙인다. 확인 없이 `as` 로 붙이면 재기동이 게이트를 여는 길이 된다.
+ */
+export declare function asApproved(command: TwinCommand): ApprovedCommand;
+/**
+ * 조치 한 종류의 명세.
+ *
+ * ── 왜 필요한가 (2026-08-31, 인티그레이션 레인 지적) ──────────────────────
+ * `TwinCommand.type` 이 열린 문자열이었다. 그러면 **어댑터를 만드는 사람이 이름을 지어내고**, 그
+ * 이름이 계약에 없으므로 다음 어댑터가 다른 이름을 쓴다. 같은 조치가 두 이름으로 갈린다.
+ *
+ * ── 왜 전역 목록이 아닌가 ────────────────────────────────────────────────
+ * 조치는 도메인마다 다르다 — 제조의 「생산 지시」와 창고의 「오더 보류」는 같은 목록에 있을 것이 아니다.
+ * 전역 목록으로 두면 도메인이 늘 때마다 계약을 고치게 된다.
+ *
+ * 그래서 **도메인 프로파일이 자기 종류를 선언한다**(`MES_COMMANDS` 처럼). bizStep 과 자리 타입을
+ * 프로파일이 선언하는 것과 같은 결이다.
+ */
+export interface CommandTypeSpec {
+    /** 트윈 어휘의 종류 이름. 점으로 나눈다(`production.order`). */
+    type: string;
+    label: string;
+    /**
+     * 이 종류가 되돌릴 수 있는가 — **기본을 정하는 자리**.
+     *
+     * 커맨드는 이것보다 **더 엄하게만** 갈 수 있다(§`TwinCommand.reversible`). 느슨하게 가는 길을 열면
+     * 그것을 내는 코드의 실수 하나가 게이트를 그 한 건에서만 연다.
+     */
+    reversible: boolean;
+    /**
+     * 이 종류가 요구하는 `payload` 칸.
+     *
+     * 없으면 보내는 쪽이 무엇을 담을지 짐작하고, 받는 어댑터는 없는 칸을 조용히 지나친다.
+     */
+    required: readonly string[];
+}
+/** 그 종류의 명세를 찾는다 — 모르는 종류면 `undefined`. */
+export declare function commandTypeOf(specs: readonly CommandTypeSpec[], type: string): CommandTypeSpec | undefined;
+/**
+ * 그 종류의 커맨드를 만든다 — **되돌릴 수 있는지를 명세에서 가져온다.**
+ *
+ * 부르는 쪽이 `reversible` 을 적지 않는다. 적게 두면 그 값이 두 곳에 살고, 내는 코드의 실수 하나가
+ * 게이트를 그 한 건에서만 연다.
+ */
+export declare function commandFromSpec(spec: CommandTypeSpec, seed: {
+    id: string;
+    instanceId: string;
+    origin: CommandOrigin;
+    proposedAt: ISOTime;
+    payload?: Record<string, unknown>;
+}): TwinCommand;
+/** 요구하는 칸 중 없는 것 — 목록으로 낸다(하나씩 고치게 하지 않는다). */
+export declare function missingCommandPayload(spec: CommandTypeSpec, payload: Record<string, unknown> | undefined): string[];
+/**
+ * 커맨드가 자기 종류의 명세와 어긋나지 않는가 — **어긋남을 조용히 지나치지 않는다.**
+ *
+ * 저장본을 손으로 고치거나 옛 코드가 만든 커맨드가 명세와 다른 `reversible` 을 들고 있을 수 있다.
+ * 그 한 건에서만 게이트가 열리는 것을 막는다.
+ */
+export declare function commandSpecGaps(specs: readonly CommandTypeSpec[], command: TwinCommand): string[];
+export {};

package/dist/actuation.js

@@ -0,0 +1,150 @@
+/**
+ * 커맨드의 상태.
+ *
+ *   proposed    트윈이 냈다. 아직 아무 일도 일어나지 않았다
+ *   approved    사람이 승인했다 — 누가 · 언제가 함께 남는다
+ *   rejected    사람이 거절했다. 여기서 끝난다
+ *   dispatched  어댑터에 넘겼다. 저쪽이 받았는지는 아직 모른다
+ *   acked       저쪽이 답했다
+ *   failed      넘기다 실패했다. 다시 넘길 수 있다
+ */
+export const COMMAND_STATE = ['proposed', 'approved', 'rejected', 'dispatched', 'acked', 'failed'];
+/** 이 커맨드를 낸 것이 누구인가 — 사람이 승인할 때 그 판단의 재료가 된다. */
+export const COMMAND_ORIGIN = ['operator', 'rule', 'ai', 'schedule'];
+/**
+ * 사람이 먼저 봐야 하는가.
+ *
+ * **모르면 봐야 한다.** `reversible` 이 참이라고 명시된 것만 게이트를 지나지 않는다 — 판단하지 못한
+ * 커맨드가 자동으로 나가는 쪽이 반대보다 훨씬 나쁘다.
+ */
+export function requiresApproval(command) {
+    return command?.reversible !== true;
+}
+/* ── 상태 전이 ─────────────────────────────────────────────────────────────── */
+/** 상태를 옮기는 사건. */
+export const COMMAND_EVENT = ['approve', 'reject', 'dispatch', 'ack', 'fail'];
+/**
+ * 어느 상태에서 어느 사건이 허용되나 — **표 하나가 전부다.**
+ *
+ * `if` 사슬로 두면 새 상태를 넣을 때 고칠 자리가 흩어지고, 한 곳을 빠뜨린 것이 「그 전이만 조용히
+ * 허용됨」으로 나타난다.
+ */
+const ALLOWED = {
+    proposed: { approve: 'approved', reject: 'rejected' },
+    approved: { dispatch: 'dispatched', reject: 'rejected' },
+    /* 넘기다 실패한 것은 다시 넘길 수 있다 — 승인은 그대로 살아 있다. */
+    failed: { dispatch: 'dispatched', reject: 'rejected' },
+    dispatched: { ack: 'acked', fail: 'failed' },
+    acked: {},
+    rejected: {}
+};
+/** 그 전이가 허용되나 — 허용되면 다음 상태, 아니면 `undefined`. */
+export function nextCommandState(from, event) {
+    return ALLOWED[from]?.[event];
+}
+/** 더 갈 곳이 없는 상태인가 — 목록에서 지워도 되는지 화면이 이것으로 판단한다. */
+export function isCommandTerminal(state) {
+    return Object.keys(ALLOWED[state] ?? {}).length === 0;
+}
+/**
+ * 승인한다 — **승인할 수 없는 것은 던진다.**
+ *
+ * 조용히 실패하지 않는 이유는, 실패를 답으로 돌려주면 부르는 쪽이 그것을 무시할 수 있기 때문이다.
+ * 승인이 안 된 것을 승인된 줄 알고 넘기는 것이 이 자리에서 가장 나쁜 결과다.
+ */
+export function approveCommand(command, approval) {
+    if (!approval?.by?.trim())
+        throw new Error('승인에는 누가 승인했는지가 있어야 한다');
+    if (!approval?.at?.trim())
+        throw new Error('승인에는 언제 승인했는지가 있어야 한다');
+    const to = nextCommandState(command.state, 'approve');
+    if (!to)
+        throw new Error(`${command.state} 상태의 커맨드는 승인할 수 없다 (${command.id})`);
+    return { ...command, state: to, approval };
+}
+/**
+ * 되돌릴 수 있는 커맨드를 사람 없이 통과시킨다 — **게이트를 여는 유일한 다른 문**이다.
+ *
+ * 시뮬레이션과 what-if 가 이 길로 간다. 되돌릴 수 없는 것에 이 함수를 쓰면 던진다 — 그것이 이 문의
+ * 뜻이고, 뜻을 어기면 게이트가 없는 것과 같아진다.
+ */
+export function passThroughReversible(command) {
+    if (requiresApproval(command)) {
+        throw new Error(`되돌릴 수 없는 커맨드는 사람 승인을 지나야 한다 (${command.id} · ${command.type})`);
+    }
+    const to = nextCommandState(command.state, 'approve');
+    if (!to)
+        throw new Error(`${command.state} 상태의 커맨드는 넘길 수 없다 (${command.id})`);
+    return { ...command, state: to };
+}
+/**
+ * 승인 표식이 붙었는지 실행 중에도 본다 — **타입만으로는 부족한 자리가 있다.**
+ *
+ * 저장소에서 되세운 커맨드는 타입이 지워진 채로 온다(JSON 에는 표식이 없다). 그때 이 함수로 확인하고
+ * 다시 표식을 붙인다. 확인 없이 `as` 로 붙이면 재기동이 게이트를 여는 길이 된다.
+ */
+export function asApproved(command) {
+    if (command.state !== 'approved' && command.state !== 'failed') {
+        throw new Error(`승인되지 않은 커맨드를 조치로 넘길 수 없다 (${command.id} · ${command.state})`);
+    }
+    if (requiresApproval(command) && !command.approval?.by) {
+        throw new Error(`승인 기록이 없는 커맨드를 조치로 넘길 수 없다 (${command.id})`);
+    }
+    return command;
+}
+/** 그 종류의 명세를 찾는다 — 모르는 종류면 `undefined`. */
+export function commandTypeOf(specs, type) {
+    return specs.find(s => s.type === type);
+}
+/**
+ * 그 종류의 커맨드를 만든다 — **되돌릴 수 있는지를 명세에서 가져온다.**
+ *
+ * 부르는 쪽이 `reversible` 을 적지 않는다. 적게 두면 그 값이 두 곳에 살고, 내는 코드의 실수 하나가
+ * 게이트를 그 한 건에서만 연다.
+ */
+export function commandFromSpec(spec, seed) {
+    const missing = missingCommandPayload(spec, seed.payload);
+    if (missing.length) {
+        throw new Error(`${spec.type}: 요구하는 칸이 없다 — ${missing.join(', ')}`);
+    }
+    return {
+        id: seed.id,
+        instanceId: seed.instanceId,
+        type: spec.type,
+        ...(seed.payload ? { payload: seed.payload } : {}),
+        origin: seed.origin,
+        proposedAt: seed.proposedAt,
+        reversible: spec.reversible,
+        state: 'proposed'
+    };
+}
+/** 요구하는 칸 중 없는 것 — 목록으로 낸다(하나씩 고치게 하지 않는다). */
+export function missingCommandPayload(spec, payload) {
+    const has = (k) => {
+        const v = payload?.[k];
+        if (v === undefined || v === null)
+            return false;
+        return typeof v === 'string' ? v.trim().length > 0 : true;
+    };
+    return spec.required.filter(k => !has(k));
+}
+/**
+ * 커맨드가 자기 종류의 명세와 어긋나지 않는가 — **어긋남을 조용히 지나치지 않는다.**
+ *
+ * 저장본을 손으로 고치거나 옛 코드가 만든 커맨드가 명세와 다른 `reversible` 을 들고 있을 수 있다.
+ * 그 한 건에서만 게이트가 열리는 것을 막는다.
+ */
+export function commandSpecGaps(specs, command) {
+    const spec = commandTypeOf(specs, command.type);
+    if (!spec)
+        return [`모르는 조치 종류다 — ${command.type}`];
+    const gaps = missingCommandPayload(spec, command.payload).map(k => `요구하는 칸이 없다 — ${k}`);
+    /*
+     * **느슨해진 것만 잡는다.** 종류가 되돌릴 수 없다고 했는데 커맨드가 되돌릴 수 있다고 하면, 그 한 건이
+     * 사람 승인을 건너뛴다. 반대(더 엄해진 것)는 정상이다 — 절반 만든 작업의 취소가 그렇다.
+     */
+    if (command.reversible === true && spec.reversible === false) {
+        gaps.push(`${command.type} 은 되돌릴 수 없는 종류인데 이 커맨드가 되돌릴 수 있다고 한다 — 승인을 건너뛴다`);
+    }
+    return gaps;
+}

package/dist/domain-definition.d.ts

@@ -239,7 +239,13 @@ export interface OpMaterialSpecification {
     uom?: string;
 }
 /** 라우트(오퍼레이션 시퀀스) — ISA-95 ProcessSegment 연결. */
-export interface RouteDef {
+/**
+ * 공정을 지나는 순서.
+ *
+ * 유효 기간은 레시피와 같은 이유로 있다 — 라우트도 개정되고, 지난 실적이 어느 경로로 만든 것인지
+ * 잃으면 추적이 성립하지 않는다(§`RecipeDef`).
+ */
+export interface RouteDef extends EffectivePeriod {
     key: string;
     label: string;
     /** OperationDef.key 순서. */
@@ -323,8 +329,20 @@ export interface RecipePart {
      */
     operation?: string;
 }
-/** BOM/레시피 — ISA-95 Material Consumed/Produced · EPCIS TransformationEvent(input→output). */
-export interface RecipeDef {
+/**
+ * BOM/레시피 — ISA-95 Material Consumed/Produced · EPCIS TransformationEvent(input→output).
+ *
+ * ── 유효 기간을 왜 여기 두나 (2026-08-31) ────────────────────────────────
+ * **레시피는 개정된다.** 그런데 이 타입에 그 자리가 없어서, 마스터가 `effectiveStart`·`effectiveEnd` 를
+ * 채워 보내도 커널이 오류 없이 지나쳤다 — 값을 넣어도 트윈에 닿지 않았다.
+ *
+ * 그것이 없으면 **지난 실적이 어느 배합으로 만든 것인지 잃는다.** 정산과 추적이 그 위에 선다.
+ * 마스터가 행을 지우지 않고 이 칸을 채우는 이유도 그것이다.
+ *
+ * 선언 적합성 하네스가 잡았다(`ops-master/test/declaration-reaches-contract.test.ts`) — 마스터가
+ * 내보내는 칸이 계약에 실재하는지 보는 시험이다.
+ */
+export interface RecipeDef extends EffectivePeriod {
     key: string;
     label: string;
     inputs: RecipePart[];

package/dist/erp.d.ts

@@ -0,0 +1,300 @@
+import type { ISOTime } from './contract.ts';
+/**
+ * **무엇을 얼마나 만들라** — 이 사실을 나르는 자리가 둘이고, 어휘는 하나다.
+ *
+ * ── 왜 갈라 두나 (2026-08-31) ────────────────────────────────────────────
+ * 같은 사실이 두 방향으로 흐른다.
+ *
+ *   ERP → MES    `ProductionScheduleEntry`   저쪽 오더번호와 상태를 함께 든다
+ *   트윈 → MES   `production.order` 조치      번호가 없다. MES 가 받아서 자기 번호를 붙인다
+ *
+ * 처음에는 둘을 따로 적었다. ERP 쪽은 `materialId`, 조치 쪽은 `materialDefinitionId` 였다 —
+ * **같은 사실에 이름이 두 벌**이었고, 그것은 이 저장소가 반복해서 거절하는 모양이다. 옮기는 코드가
+ * 생기고, 그 코드가 언젠가 어긋난다.
+ *
+ * 이름은 `materialDefinitionId` 로 모았다 — 마스터의 축과 엔티티가 그 이름이다(`MaterialDefinition`).
+ * `startTime`·`endTime` 은 ISA-95 `JobOrder` 의 낱말이고 계약이 이미 그것을 쓴다.
+ */
+export interface ProductionDemand {
+    /** 무엇을 만드나 — 마스터의 `MaterialDefinition` 식별자. */
+    materialDefinitionId: string;
+    /** 얼마나 — **받은 단위 그대로 든다.** 우리가 변환하지 않는다(변환계수는 원천의 사실이다). */
+    quantity: number;
+    uom: string;
+    /** 언제까지 — 예정 착수와 예정 완료(표준 `JobOrder.StartTime`·`EndTime`). */
+    startTime?: ISOTime;
+    endTime?: ISOTime;
+    /**
+     * 어느 레시피로 만드나 — 품목만으로는 정해지지 않는다(같은 품목에 대체 레시피가 있다).
+     * 아는 경우만 싣는다.
+     */
+    recipeKey?: string;
+    /** 작은 값이 급하다(우리 `JobOrder.Priority` 와 같은 규약). */
+    priority?: number;
+}
+/**
+ * ERP 가 내린 생산 지시 하나.
+ *
+ * **식별자는 ERP 것이다.** `orderId` 는 저쪽 오더번호이고 우리가 만들지 않는다. 우리 식별자를 여기
+ * 담으면 ERP 를 바꾸는 날 지난 기록이 가리킬 것을 잃는다.
+ */
+export interface ProductionScheduleEntry extends ProductionDemand {
+    /** ERP 의 오더번호. 이 지시를 가리키는 이름이다. */
+    orderId: string;
+    /**
+     * **이 지시의 판** — 수량 · 납기 · 취소가 바뀌면 올라간다.
+     *
+     * 덮어쓰지 않고 판마다 남기는 이유는, 이미 올린 실적이 **어느 지시에 대한 것인지** 잃으면 정산이
+     * 성립하지 않기 때문이다. ERP 가 판을 말해 주지 않으면 받은 시각으로 대신하지 않는다 — 그것은
+     * 우리 사정이지 지시의 사실이 아니다.
+     */
+    revision?: string;
+    /** 어디서 — ERP 가 말하는 현장과 작업장. SAP 는 플랜트, Oracle 은 Organization 이라 부른다. */
+    site?: string;
+    workCenter?: string;
+    /** 지시 상태 — 아래 `SCHEDULE_STATUS`. 잠긴 것에는 실적을 올릴 수 없다. */
+    status: ScheduleStatus;
+    recordTime?: ISOTime;
+}
+/**
+ * 지시의 상태 — **어느 ERP 에나 있는 여섯**.
+ *
+ * ERP 마다 이름이 다르고 수가 다르다. SAP 는 `REL`·`TECO`·`CLSD` 로, Oracle 은
+ * `Released`·`Complete`·`Closed` 로, 더존은 다른 코드로 말한다. 그 코드를 그대로 들면 어댑터마다
+ * 다른 어휘가 화면까지 올라온다.
+ *
+ * **여섯으로 좁힌 기준은 「부르는 쪽의 판단이 갈리는가」다.** 이름이 달라도 판단이 같으면 한 칸이다.
+ *
+ *   draft      아직 내려오지 않았다. 실적을 올릴 수 없다
+ *   released   내려왔다. 올릴 수 있다
+ *   started    일부 올라갔다. 계속 올릴 수 있다
+ *   completed  생산이 끝났다고 ERP 가 정했다. 더 못 올린다
+ *   closed     정산까지 닫혔다. 되돌리는 것도 사람이 ERP 에서 한다
+ *   cancelled  취소됐다
+ *
+ * `completed` 와 `closed` 를 합치지 않는 이유는 되돌리기가 갈리기 때문이다 — 앞은 ERP 가 열어 주면
+ * 되돌릴 수 있고 뒤는 그것도 안 된다.
+ */
+export declare const SCHEDULE_STATUS: readonly ["draft", "released", "started", "completed", "closed", "cancelled"];
+export type ScheduleStatus = (typeof SCHEDULE_STATUS)[number];
+/** 실적을 받을 수 있는 지시인가 — 잠긴 것에 올리면 거절되고, 그 거절은 기다려도 풀리지 않는다. */
+export declare function acceptsPerformance(status: ScheduleStatus): boolean;
+/**
+ * MES 가 올리는 생산 실적 하나.
+ *
+ * 수량 확정과 자재 소비는 ERP 에서 **별개 문서**다(§`erp-sap.md` 4-6). 한쪽만 올라간 상태가 실제로
+ * 생기므로 이 레코드는 둘을 함께 들되, 보내는 쪽이 **각각의 결과를 따로 적을 수 있어야** 한다.
+ */
+export interface ProductionPerformanceEntry {
+    /** 어느 지시에 대한 것인가 — ERP 의 오더번호. */
+    orderId: string;
+    /** 그 지시의 어느 판에 대한 것인가. 지시가 판을 말했으면 그대로 옮긴다. */
+    revision?: string;
+    /**
+     * 어느 공정인가 — ERP 의 공정 식별자. **오더 단위로만 받는 ERP 가 있다.**
+     *
+     * 어댑터가 `performanceGranularity: 'order'` 를 말하면 이 값을 보내도 저쪽이 버린다. 그때 이 칸을
+     * 채워 보내는 쪽은 공정별 실적이 올라간 줄 알게 되므로, 어댑터가 **버렸다고 말해야 한다.**
+     */
+    operationId?: string;
+    /** 만든 것 — 양품과 불량을 나눠 든다. 합쳐 보내면 수율이 사라진다. */
+    goodQuantity: number;
+    scrapQuantity: number;
+    uom: string;
+    /** 언제 — 이 실적이 덮는 구간. 마감된 구간이라 미래일 수 없다. */
+    from: ISOTime;
+    to: ISOTime;
+    /** 누가 했나 — ERP 의 인사번호. 「누가 적었나」는 여기 오지 않는다(MES 의 감사 추적이다). */
+    personId?: string;
+    /** 쓴 자재 — 소비 문서가 된다. 없으면 자재 소비를 올리지 않는다(0 으로 채우지 않는다). */
+    materialActual?: MaterialActual[];
+    /**
+     * **이것이 이 지시의 마지막 실적인가** — ERP 가 이 값으로 오더를 닫는다.
+     *
+     * 커널이 판정하지 않는다. 「계획 수량에 도달했으니 마지막」은 틀린 규칙이다 — 초과 생산과 미달 종료가
+     * 둘 다 정상이다. 사람이 정한 것만 참이다.
+     */
+    final?: boolean;
+    recordTime?: ISOTime;
+}
+/** 실제로 들어가고 나온 자재 한 줄. */
+export interface MaterialActual {
+    /** 마스터의 `MaterialDefinition` 식별자 — 지시와 같은 이름을 쓴다. */
+    materialDefinitionId: string;
+    quantity: number;
+    uom: string;
+    /** `consumed` 소비 · `produced` 산출. 부호로 구별하지 않는다 — 음수는 되돌림과 섞인다. */
+    direction: 'consumed' | 'produced';
+    lot?: string;
+}
+/**
+ * 실적의 **멱등 키** — 같은 실적이 두 번 올라가지 않게.
+ *
+ * ── 왜 계약에 있나 ───────────────────────────────────────────────────────
+ * ERP 확정은 삭제가 없다. 잘못 올린 것은 역분개로만 되돌리고 그 역분개도 장부에 남는다. 그래서 이 키를
+ * 만드는 쪽과 확인하는 쪽이 **한 글자까지 같은 규칙**을 써야 한다. 규칙이 두 벌이면 한쪽만 바뀌는 날
+ * 같은 실적이 두 번 앉는다.
+ *
+ * ── 무엇으로 만드나 ──────────────────────────────────────────────────────
+ * 오더 · 공정 · 구간. 같은 오더의 같은 공정에서 **같은 구간**의 실적은 하나뿐이다. 수량을 넣지 않는
+ * 이유는, 수량을 고쳐 다시 올리는 것이 「다른 실적」이 아니라 「같은 실적의 정정」이기 때문이다 —
+ * 정정은 역분개로 처리할 일이지 새 키를 받을 일이 아니다.
+ */
+export declare function performanceKey(e: Pick<ProductionPerformanceEntry, 'orderId' | 'operationId' | 'from' | 'to'>): string;
+/**
+ * 자재 소비의 멱등 키 — **확정과 따로 둔다.**
+ *
+ * 수량 확정과 자재 소비는 ERP 에서 별개 문서이고 한쪽만 성공하는 순간이 실제로 있다. 키를 하나로
+ * 쓰면 「확정은 올라갔고 소비는 안 올라간 상태」를 표시할 방법이 없어진다.
+ */
+export declare function materialMovementKey(e: Pick<ProductionPerformanceEntry, 'orderId' | 'operationId' | 'from' | 'to'>): string;
+/**
+ * 보내기 전에 스스로 본다 — **틀린 모양이 ERP 에서 걸리면 그때는 이미 늦다.**
+ *
+ * 거절 이유를 목록으로 낸다. 첫 번째에서 멈추면 사람이 한 번에 하나씩 고치게 된다.
+ */
+export declare function validatePerformance(e: ProductionPerformanceEntry, nowMs: number): string[];
+/**
+ * 잘못 올린 실적을 되돌리는 요청 — **삭제가 아니라 역분개다.**
+ *
+ * ERP 는 확정을 지우지 않는다. 되돌림도 장부에 남고, 그래서 되돌림에도 자기 멱등 키가 필요하다 —
+ * 되돌림이 두 번 올라가면 원래 수량이 다시 살아난다.
+ */
+export interface PerformanceReversal {
+    /** 되돌릴 실적의 멱등 키(`performanceKey`). */
+    performanceKey: string;
+    /** ERP 가 돌려준 확정 문서 — 이것이 있어야 무엇을 되돌릴지 저쪽이 안다. */
+    confirmationRef: string;
+    reason: string;
+    decidedBy: string;
+    decidedAt: ISOTime;
+}
+/** 되돌림의 멱등 키 — 원래 실적의 키에 표식 하나. */
+export declare function reversalKey(performanceKey: string): string;
+/**
+ * **ERP 어댑터가 구현하는 자리** — 부르는 쪽은 이것만 안다.
+ *
+ * ── 왜 먼저 정하나 (2026-08-31, 사용자 지적) ─────────────────────────────
+ * SAP 구현을 먼저 만들면 **SAP 의 모양이 곧 표준이 된다.** 두 번째 ERP(ECC · Oracle · Dynamics)는
+ * 자기에게 안 맞는 모양을 물려받고, 그때 고치려면 첫 소비처가 이미 그 위에 서 있다.
+ *
+ * 그래서 이 자리에는 **어느 ERP에나 있는 것만** 둔다. OData 인지 IDoc 인지, 어느 엔티티에서 꺼내는지는
+ * 어댑터의 사정이다.
+ *
+ * ── 트윈 커넥터와 같은 규율 두 벌 ────────────────────────────────────────
+ * `capabilities` 로 무엇을 할 수 있는지 선언하고, **선언만 있고 구현이 없으면 없는 것으로 읽는다** —
+ * 선언만 있는 능력은 사용자에게 거짓이 된다(§`ReferenceAdapter.capabilities`).
+ * `grounding` 은 「그 선언이 무엇으로 확인됐나」다 — 목에 대고 만든 것과 실 시스템에 붙어 본 것은
+ * 다르고, 화면이 그 구분을 보여야 한다.
+ */
+export interface ErpAdapter {
+    /** 어느 ERP 인가 — `sap-s4hana` · `sap-ecc` 처럼. */
+    readonly type: string;
+    readonly label: string;
+    readonly capabilities: readonly ErpCapability[];
+    /** `mock` 목에 대고 확인 · `vendor-doc` 공개 문서 기준 · `verified` 실 시스템에 붙여 확인. */
+    readonly grounding: 'mock' | 'vendor-doc' | 'verified';
+    /**
+     * **ERP 마다 갈리는 성질** — 능력이 있고 없고와 다른 축이다.
+     *
+     * 「할 수 있나」가 아니라 「어떻게 하나」이고, 부르는 쪽의 코드가 이 값에 따라 달라진다. 선언하지
+     * 않으면 부르는 쪽이 짐작하게 되고, 짐작이 틀린 것은 화면에 드러나지 않는다.
+     */
+    readonly traits: ErpTraits;
+    /** 붙는지 본다. 값을 바꾸지 않는다. */
+    probe(cfg: ErpConfig): Promise<ErpOutcome<{
+        detail?: string;
+    }>>;
+    /** 지시를 읽는다. `since` 이후에 바뀐 것만 — 없으면 어댑터가 정한 창을 쓴다. */
+    readSchedules?(cfg: ErpConfig, since?: ISOTime): Promise<ErpOutcome<ProductionScheduleEntry[]>>;
+    /**
+     * 실적을 올린다. **`key` 로 두 번 올라가지 않게 한다**(§`performanceKey`).
+     *
+     * 어댑터가 그 키로 이미 올렸는지 먼저 확인해야 한다 — ERP 확정은 삭제가 없다.
+     */
+    postPerformance?(cfg: ErpConfig, entry: ProductionPerformanceEntry, key: string): Promise<ErpOutcome<ErpDocumentRef>>;
+    /**
+     * 자재 소비·산출을 올린다 — **실적과 별개 문서다.** 한쪽만 성공하는 순간이 실제로 있다.
+     */
+    postMaterialMovement?(cfg: ErpConfig, entry: ProductionPerformanceEntry, key: string): Promise<ErpOutcome<ErpDocumentRef>>;
+    /** 잘못 올린 실적을 되돌린다 — 삭제가 아니라 역분개다. */
+    reversePerformance?(cfg: ErpConfig, reversal: PerformanceReversal, key: string): Promise<ErpOutcome<ErpDocumentRef>>;
+    /** 마스터를 당긴다 — 구조는 밀지 않고 당겨 간다(사실과 다른 규율). */
+    readMaster?(cfg: ErpConfig, axis: ErpMasterAxis): Promise<ErpOutcome<unknown[]>>;
+}
+/**
+ * ERP 마다 갈리는 성질.
+ *
+ * 실제로 갈리는 것만 둔다 — 아래 셋은 SAP · Oracle · Dynamics · 국내 ERP 를 견주면 서로 다르고,
+ * 부르는 쪽이 그것을 모르면 조용히 틀린 결과를 낸다.
+ */
+export interface ErpTraits {
+    /**
+     * 실적을 어느 단위로 받나.
+     *
+     * `order` 만 받는 ERP 에 공정별 실적을 올리면 저쪽이 공정을 버리고 합산한다. 부르는 쪽은 공정별로
+     * 올라간 줄 알지만 장부에는 오더 하나로 앉는다.
+     */
+    performanceGranularity: 'order' | 'operation';
+    /**
+     * 자재 소비가 실적과 **같은 문서**인가.
+     *
+     * SAP 는 별개 문서라 한쪽만 성공하는 순간이 있고, 함께 앉는 ERP 는 그 상태가 아예 없다. 별개인 곳에서
+     * 하나로 다루면 반쯤 올라간 것을 아무도 못 본다. 함께인 곳에서 둘로 다루면 소비가 두 번 앉는다.
+     */
+    materialWithPerformance: boolean;
+    /**
+     * 되돌리기를 API 로 할 수 있나.
+     *
+     * `none` 이면 잘못 올린 실적을 **사람이 ERP 화면에서** 지워야 한다. 그 사실을 화면이 말해야 현장이
+     * 기다리지 않는다.
+     */
+    reversal: 'api' | 'manual' | 'none';
+}
+/** 이 ERP 가 할 수 있다고 선언하는 것. 구현이 없으면 없는 것으로 읽는다. */
+export declare const ERP_CAPABILITY: readonly ["schedule", "performance", "material-movement", "reversal", "master"];
+export type ErpCapability = (typeof ERP_CAPABILITY)[number];
+/** 당겨 올 수 있는 마스터의 축. */
+export declare const ERP_MASTER_AXIS: readonly ["product", "bom", "routing", "work-center"];
+export type ErpMasterAxis = (typeof ERP_MASTER_AXIS)[number];
+/** 연결 설정 — 어댑터마다 다른 칸이 붙는다. 비밀값은 여기 두지 않는다. */
+export interface ErpConfig {
+    baseUrl: string;
+    /** ERP 안에서 우리가 어느 현장인가. SAP 는 플랜트, Oracle 은 Organization 이다. */
+    site?: string;
+    [key: string]: unknown;
+}
+/** ERP 가 돌려준 문서 — 되돌리려면 이것이 있어야 저쪽이 무엇을 되돌릴지 안다. */
+export interface ErpDocumentRef {
+    /** 그 ERP 의 문서 식별자 원문. 우리가 모양을 정하지 않는다. */
+    ref: string;
+    postedAt?: ISOTime;
+}
+/**
+ * ERP 호출의 결과 — **다음에 무엇을 할지가 여기서 나온다.**
+ *
+ * 웹훅 응답에서 세운 것과 같은 규율이다: 「다시 보내면 되는가 · 기다리면 되는가 · 사람을 불러야 하는가」가
+ * 하나로 정해져야 한다. 그 판정을 부르는 쪽이 본문을 읽어 짐작하게 두면 어댑터마다 달라진다.
+ */
+export type ErpOutcome<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    action: ErpFailureAction;
+    error: string;
+};
+/**
+ *   retry     다시 보내면 될 수 있다 — 저쪽 오류 · 시간 초과
+ *   wait      지금은 안 되고 기다리면 된다 — 저쪽이 따라오지 못한다
+ *   stop      다시 보내도 같다 — 잠긴 오더 · 없는 자재 · 권한 없음. 사람이 붙어야 한다
+ *   duplicate 이미 올라가 있다 — 실패가 아니다. 우리 기록만 맞추면 된다
+ */
+export type ErpFailureAction = 'retry' | 'wait' | 'stop' | 'duplicate';
+/**
+ * 선언과 구현이 어긋나지 않는가 — **선언만 있는 능력은 사용자에게 거짓이 된다.**
+ *
+ * 어긋난 것을 목록으로 낸다. 등록할 때 이것을 지나게 하면 「할 수 있다고 적혀 있는데 안 되는」 어댑터가
+ * 화면에 서지 않는다.
+ */
+export declare function erpCapabilityGaps(adapter: ErpAdapter): string[];

package/dist/erp.js

@@ -0,0 +1,145 @@
+/**
+ * 지시의 상태 — **어느 ERP 에나 있는 여섯**.
+ *
+ * ERP 마다 이름이 다르고 수가 다르다. SAP 는 `REL`·`TECO`·`CLSD` 로, Oracle 은
+ * `Released`·`Complete`·`Closed` 로, 더존은 다른 코드로 말한다. 그 코드를 그대로 들면 어댑터마다
+ * 다른 어휘가 화면까지 올라온다.
+ *
+ * **여섯으로 좁힌 기준은 「부르는 쪽의 판단이 갈리는가」다.** 이름이 달라도 판단이 같으면 한 칸이다.
+ *
+ *   draft      아직 내려오지 않았다. 실적을 올릴 수 없다
+ *   released   내려왔다. 올릴 수 있다
+ *   started    일부 올라갔다. 계속 올릴 수 있다
+ *   completed  생산이 끝났다고 ERP 가 정했다. 더 못 올린다
+ *   closed     정산까지 닫혔다. 되돌리는 것도 사람이 ERP 에서 한다
+ *   cancelled  취소됐다
+ *
+ * `completed` 와 `closed` 를 합치지 않는 이유는 되돌리기가 갈리기 때문이다 — 앞은 ERP 가 열어 주면
+ * 되돌릴 수 있고 뒤는 그것도 안 된다.
+ */
+export const SCHEDULE_STATUS = ['draft', 'released', 'started', 'completed', 'closed', 'cancelled'];
+/** 실적을 받을 수 있는 지시인가 — 잠긴 것에 올리면 거절되고, 그 거절은 기다려도 풀리지 않는다. */
+export function acceptsPerformance(status) {
+    return status === 'released' || status === 'started';
+}
+/* ── 멱등 ──────────────────────────────────────────────────────────────────── */
+/**
+ * 실적의 **멱등 키** — 같은 실적이 두 번 올라가지 않게.
+ *
+ * ── 왜 계약에 있나 ───────────────────────────────────────────────────────
+ * ERP 확정은 삭제가 없다. 잘못 올린 것은 역분개로만 되돌리고 그 역분개도 장부에 남는다. 그래서 이 키를
+ * 만드는 쪽과 확인하는 쪽이 **한 글자까지 같은 규칙**을 써야 한다. 규칙이 두 벌이면 한쪽만 바뀌는 날
+ * 같은 실적이 두 번 앉는다.
+ *
+ * ── 무엇으로 만드나 ──────────────────────────────────────────────────────
+ * 오더 · 공정 · 구간. 같은 오더의 같은 공정에서 **같은 구간**의 실적은 하나뿐이다. 수량을 넣지 않는
+ * 이유는, 수량을 고쳐 다시 올리는 것이 「다른 실적」이 아니라 「같은 실적의 정정」이기 때문이다 —
+ * 정정은 역분개로 처리할 일이지 새 키를 받을 일이 아니다.
+ */
+export function performanceKey(e) {
+    const parts = [e.orderId, e.operationId ?? '-', e.from, e.to];
+    if (parts.some(p => !String(p ?? '').trim())) {
+        throw new Error(`performanceKey: 오더 · 구간이 없으면 멱등 키를 만들 수 없다 — ${JSON.stringify(e)}`);
+    }
+    return parts.join('|');
+}
+/**
+ * 자재 소비의 멱등 키 — **확정과 따로 둔다.**
+ *
+ * 수량 확정과 자재 소비는 ERP 에서 별개 문서이고 한쪽만 성공하는 순간이 실제로 있다. 키를 하나로
+ * 쓰면 「확정은 올라갔고 소비는 안 올라간 상태」를 표시할 방법이 없어진다.
+ */
+export function materialMovementKey(e) {
+    return `${performanceKey(e)}|goods`;
+}
+/* ── 검증 ──────────────────────────────────────────────────────────────────── */
+/**
+ * 보내기 전에 스스로 본다 — **틀린 모양이 ERP 에서 걸리면 그때는 이미 늦다.**
+ *
+ * 거절 이유를 목록으로 낸다. 첫 번째에서 멈추면 사람이 한 번에 하나씩 고치게 된다.
+ */
+export function validatePerformance(e, nowMs) {
+    const errors = [];
+    if (!String(e?.orderId ?? '').trim())
+        errors.push('orderId 없음 — 어느 지시에 대한 실적인지 지어낼 수 없다');
+    if (!String(e?.uom ?? '').trim())
+        errors.push('uom 없음 — 단위 없는 수량은 정산에 쓸 수 없다');
+    for (const [name, v] of [
+        ['goodQuantity', e?.goodQuantity],
+        ['scrapQuantity', e?.scrapQuantity]
+    ]) {
+        if (typeof v !== 'number' || !Number.isFinite(v))
+            errors.push(`${name} 이 수가 아니다`);
+        else if (v < 0)
+            errors.push(`${name} 이 음수다 — 되돌림은 역분개로 하고 음수 실적으로 하지 않는다`);
+    }
+    if (typeof e?.goodQuantity === 'number' && typeof e?.scrapQuantity === 'number' && e.goodQuantity + e.scrapQuantity <= 0) {
+        errors.push('만든 것이 하나도 없다 — 올릴 실적이 아니다');
+    }
+    const from = Date.parse(String(e?.from ?? ''));
+    const to = Date.parse(String(e?.to ?? ''));
+    if (!Number.isFinite(from) || !Number.isFinite(to))
+        errors.push('구간이 없다 — from · to 가 있어야 한다');
+    else {
+        if (to < from)
+            errors.push('구간이 거꾸로다');
+        /* 마감된 구간의 사실이다. 아직 오지 않은 시각을 정산에 올리면 그 달의 장부가 틀린다. */
+        if (to > nowMs)
+            errors.push('아직 오지 않은 시각까지의 실적이다');
+    }
+    for (const m of e?.materialActual ?? []) {
+        if (!String(m?.materialDefinitionId ?? '').trim())
+            errors.push('자재 줄에 materialDefinitionId 가 없다');
+        if (!String(m?.uom ?? '').trim())
+            errors.push(`${m?.materialDefinitionId}: uom 없음 — 단위는 ERP 의 사실이므로 지어내지 않는다`);
+        if (typeof m?.quantity !== 'number' || !(m.quantity > 0))
+            errors.push(`${m?.materialDefinitionId}: 수량이 0 이하다`);
+        if (m?.direction !== 'consumed' && m?.direction !== 'produced') {
+            errors.push(`${m?.materialDefinitionId}: direction 이 consumed · produced 가 아니다`);
+        }
+    }
+    return errors;
+}
+/** 되돌림의 멱등 키 — 원래 실적의 키에 표식 하나. */
+export function reversalKey(performanceKey) {
+    if (!String(performanceKey ?? '').trim())
+        throw new Error('reversalKey: 되돌릴 실적의 키가 없다');
+    return `${performanceKey}|reversal`;
+}
+/** 이 ERP 가 할 수 있다고 선언하는 것. 구현이 없으면 없는 것으로 읽는다. */
+export const ERP_CAPABILITY = ['schedule', 'performance', 'material-movement', 'reversal', 'master'];
+/** 당겨 올 수 있는 마스터의 축. */
+export const ERP_MASTER_AXIS = ['product', 'bom', 'routing', 'work-center'];
+/**
+ * 선언과 구현이 어긋나지 않는가 — **선언만 있는 능력은 사용자에게 거짓이 된다.**
+ *
+ * 어긋난 것을 목록으로 낸다. 등록할 때 이것을 지나게 하면 「할 수 있다고 적혀 있는데 안 되는」 어댑터가
+ * 화면에 서지 않는다.
+ */
+export function erpCapabilityGaps(adapter) {
+    const needs = {
+        schedule: 'readSchedules',
+        performance: 'postPerformance',
+        'material-movement': 'postMaterialMovement',
+        reversal: 'reversePerformance',
+        master: 'readMaster'
+    };
+    const gaps = [];
+    for (const cap of adapter.capabilities ?? []) {
+        const fn = needs[cap];
+        if (typeof adapter[fn] !== 'function')
+            gaps.push(`${cap} 을 선언했는데 ${String(fn)} 구현이 없다`);
+    }
+    /* 되돌림을 API 로 한다고 말했으면 그 구현이 있어야 한다. `manual`·`none` 은 없는 것이 정상이다. */
+    if (adapter.traits?.reversal === 'api' && typeof adapter.reversePerformance !== 'function') {
+        gaps.push('traits.reversal 이 api 인데 reversePerformance 구현이 없다');
+    }
+    if (adapter.traits?.reversal !== 'api' && adapter.capabilities?.includes('reversal')) {
+        gaps.push('reversal 능력을 선언했는데 traits.reversal 이 api 가 아니다 — 둘 중 하나가 틀렸다');
+    }
+    /* 자재가 실적과 같은 문서인 ERP 에 따로 올리는 문을 두면 소비가 두 번 앉는다. */
+    if (adapter.traits?.materialWithPerformance && typeof adapter.postMaterialMovement === 'function') {
+        gaps.push('traits.materialWithPerformance 가 참인데 postMaterialMovement 가 따로 있다 — 소비가 두 번 앉는다');
+    }
+    return gaps;
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/mes-profile.d.ts

@@ -1,4 +1,5 @@
 import type { TwinTypeInfo } from './domain-catalog.ts';
+import type { CommandTypeSpec } from './actuation.ts';
 export declare const MES_BIZSTEP: {
     readonly receiving: "urn:epcglobal:cbv:bizstep:receiving";
     readonly producing: "urn:epcglobal:cbv:bizstep:commissioning";
@@ -12,3 +13,13 @@ export declare function sgtinUri(companyPrefix: string, itemRef: string, serial:
  * 트레일러 제조 라인: 자재→프레임 절단→용접→도장→조립→완성차(kernel ROUTE 와 일치). */
 export declare const MES_LOCATION_TYPES: readonly ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
 export declare const MES_TYPES: TwinTypeInfo[];
+/**
+ * 제조 도메인이 내리는 조치 — **어댑터가 이름을 지어내지 않게 여기서 정한다.**
+ *
+ * 전역 목록으로 두지 않는 이유는 조치가 도메인마다 다르기 때문이다. bizStep 과 자리 타입을 이 파일이
+ * 선언하는 것과 같은 결이다.
+ *
+ * 지금 하나다. **소비처가 있는 것만 적는다** — 쓰지 않는 종류를 미리 늘리면 그 이름이 무엇을 뜻하는지
+ * 아무도 모르는 채로 계약에 남는다.
+ */
+export declare const MES_COMMANDS: CommandTypeSpec[];

package/dist/mes-profile.js

@@ -57,3 +57,28 @@ export const MES_TYPES = [
     { key: 'painter', role: 'equipment', label: 'twin.type.painter', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] },
     { key: 'assembler', role: 'equipment', label: 'twin.type.assembler', standardClass: { isa95: 'Equipment', iso55000: 'Asset' }, identity: { scheme: 'gs1:GIAI' }, capabilities: ['processable', 'operable'] }
 ];
+/**
+ * 제조 도메인이 내리는 조치 — **어댑터가 이름을 지어내지 않게 여기서 정한다.**
+ *
+ * 전역 목록으로 두지 않는 이유는 조치가 도메인마다 다르기 때문이다. bizStep 과 자리 타입을 이 파일이
+ * 선언하는 것과 같은 결이다.
+ *
+ * 지금 하나다. **소비처가 있는 것만 적는다** — 쓰지 않는 종류를 미리 늘리면 그 이름이 무엇을 뜻하는지
+ * 아무도 모르는 채로 계약에 남는다.
+ */
+export const MES_COMMANDS = [
+    {
+        type: 'production.order',
+        label: '생산 지시',
+        /*
+         * 되돌릴 수 없다. 지시가 나가면 사람과 설비가 그것으로 움직이고, 취소해도 이미 만든 것은 남는다.
+         * 그래서 사람 승인을 지난다(§`requiresApproval`).
+         */
+        reversible: false,
+        /*
+         * 단위를 요구하는 이유 — 단위 없는 수량은 지시가 되지 못한다. 우리가 기본 단위를 지어내면 그것이
+         * 현장의 단위와 다른 날 수량이 조용히 틀린다.
+         */
+        required: ['materialDefinitionId', 'quantity', 'uom']
+    }
+];

package/dist-cjs/index.cjs

@@ -27,6 +27,9 @@ __export(index_exports, {
   CAPABILITY_KEYS: () => CAPABILITY_KEYS,
   CBV_BIZSTEP: () => CBV_BIZSTEP,
   CMD: () => CMD,
+  COMMAND_EVENT: () => COMMAND_EVENT,
+  COMMAND_ORIGIN: () => COMMAND_ORIGIN,
+  COMMAND_STATE: () => COMMAND_STATE,
   DISP: () => DISP,
   DISPOSITION_DECISION: () => DISPOSITION_DECISION,
   DOMAIN_CATALOG: () => DOMAIN_CATALOG,
@@ -40,11 +43,14 @@ __export(index_exports, {
   EPCIS_CONTEXT: () => EPCIS_CONTEXT,
   EPCIS_EVENT: () => EPCIS_EVENT,
   EQUIPMENT_LEVEL: () => EQUIPMENT_LEVEL,
+  ERP_CAPABILITY: () => ERP_CAPABILITY,
+  ERP_MASTER_AXIS: () => ERP_MASTER_AXIS,
   GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
   LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
   MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
   MES_BIZSTEP: () => MES_BIZSTEP,
+  MES_COMMANDS: () => MES_COMMANDS,
   MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
   MES_TYPES: () => MES_TYPES,
   METER_DIRECTION: () => METER_DIRECTION,
@@ -54,6 +60,7 @@ __export(index_exports, {
   ORDER_TERMINAL_STATUS: () => ORDER_TERMINAL_STATUS,
   PRIORITY_UNSET: () => PRIORITY_UNSET,
   RETIRED_VOCABULARY: () => RETIRED_VOCABULARY,
+  SCHEDULE_STATUS: () => SCHEDULE_STATUS,
   TWIN_AXES: () => TWIN_AXES,
   TWIN_PROPERTIES: () => TWIN_PROPERTIES,
   TWIN_RELATIONS: () => TWIN_RELATIONS,
@@ -67,10 +74,13 @@ __export(index_exports, {
   YARD_BIZSTEP: () => YARD_BIZSTEP,
   YMS_LOCATION_TYPES: () => YMS_LOCATION_TYPES,
   YMS_TYPES: () => YMS_TYPES,
+  acceptsPerformance: () => acceptsPerformance,
   activeShiftAt: () => activeShiftAt,
   activeShiftOf: () => activeShiftOf,
   aggregationEvent: () => aggregationEvent,
   analyzeCapacity: () => analyzeCapacity,
+  approveCommand: () => approveCommand,
+  asApproved: () => asApproved,
   axesOfSystem: () => axesOfSystem,
   axisAppliesTo: () => axisAppliesTo,
   axisInfo: () => axisInfo,
@@ -82,6 +92,9 @@ __export(index_exports, {
   checkSequenceRun: () => checkSequenceRun,
   classClosure: () => classClosure,
   classIdentifierViolation: () => classIdentifierViolation,
+  commandFromSpec: () => commandFromSpec,
+  commandSpecGaps: () => commandSpecGaps,
+  commandTypeOf: () => commandTypeOf,
   commandsOf: () => commandsOf,
   computeOee: () => computeOee,
   conversionFactorOf: () => conversionFactorOf,
@@ -90,6 +103,7 @@ __export(index_exports, {
   dueStatusOf: () => dueStatusOf,
   effectivityAt: () => effectivityAt,
   electricalUpstreamOf: () => electricalUpstreamOf,
+  erpCapabilityGaps: () => erpCapabilityGaps,
   expiryFromAttributes: () => expiryFromAttributes,
   gdtiUri: () => gdtiUri,
   generationFractionAt: () => generationFractionAt,
@@ -111,6 +125,7 @@ __export(index_exports, {
   ingestMasterData: () => ingestMasterData,
   ingestOperationalRecords: () => ingestOperationalRecords,
   isAggregationRecord: () => isAggregationRecord,
+  isCommandTerminal: () => isCommandTerminal,
   isElectricalLocationType: () => isElectricalLocationType,
   isEnergyBillRecord: () => isEnergyBillRecord,
   isEnergyEquipmentRecord: () => isEnergyEquipmentRecord,
@@ -137,8 +152,11 @@ __export(index_exports, {
   lotFromAttributes: () => lotFromAttributes,
   mapRecord: () => mapRecord,
   mapRecordChecked: () => mapRecordChecked,
+  materialMovementKey: () => materialMovementKey,
   meetsTests: () => meetsTests,
   minuteOfDayAt: () => minuteOfDayAt,
+  missingCommandPayload: () => missingCommandPayload,
+  nextCommandState: () => nextCommandState,
   objectEvent: () => objectEvent,
   objectUri: () => objectUri,
   observationAt: () => observationAt,
@@ -149,6 +167,8 @@ __export(index_exports, {
   outsideLimit: () => outsideLimit,
   parseEpc: () => parseEpc,
   parseIsoDuration: () => parseIsoDuration,
+  passThroughReversible: () => passThroughReversible,
+  performanceKey: () => performanceKey,
   periodFactId: () => periodFactId,
   priorityRank: () => priorityRank,
   procedureViolations: () => procedureViolations,
@@ -160,8 +180,10 @@ __export(index_exports, {
   relationsFrom: () => relationsFrom,
   relationsTo: () => relationsTo,
   requiredTestsFor: () => requiredTestsFor,
+  requiresApproval: () => requiresApproval,
   resolveSubject: () => resolveSubject,
   retiredVocabularyIn: () => retiredVocabularyIn,
+  reversalKey: () => reversalKey,
   sgtinClass: () => sgtinClass,
   sgtinUri: () => sgtinUri,
   ssccUri: () => ssccUri,
@@ -173,6 +195,7 @@ __export(index_exports, {
   transformationEvent: () => transformationEvent,
   validateDomainDefinition: () => validateDomainDefinition,
   validateEpcisEvent: () => validateEpcisEvent,
+  validatePerformance: () => validatePerformance,
   validateScenario: () => validateScenario,
   webhookSenderAction: () => webhookSenderAction,
   weekdayAt: () => weekdayAt,
@@ -1201,6 +1224,22 @@ var MES_TYPES = [
   { key: "painter", role: "equipment", label: "twin.type.painter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
   { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
+var MES_COMMANDS = [
+  {
+    type: "production.order",
+    label: "\uC0DD\uC0B0 \uC9C0\uC2DC",
+    /*
+     * 되돌릴 수 없다. 지시가 나가면 사람과 설비가 그것으로 움직이고, 취소해도 이미 만든 것은 남는다.
+     * 그래서 사람 승인을 지난다(§`requiresApproval`).
+     */
+    reversible: false,
+    /*
+     * 단위를 요구하는 이유 — 단위 없는 수량은 지시가 되지 못한다. 우리가 기본 단위를 지어내면 그것이
+     * 현장의 단위와 다른 날 수량이 조용히 틀린다.
+     */
+    required: ["materialDefinitionId", "quantity", "uom"]
+  }
+];
 
 // src/ems-profile.ts
 var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
@@ -3853,6 +3892,166 @@ function computeOee(c, nowMs) {
     scrapCount: c.scrapCount
   };
 }
+
+// src/erp.ts
+var SCHEDULE_STATUS = ["draft", "released", "started", "completed", "closed", "cancelled"];
+function acceptsPerformance(status) {
+  return status === "released" || status === "started";
+}
+function performanceKey(e) {
+  const parts = [e.orderId, e.operationId ?? "-", e.from, e.to];
+  if (parts.some((p) => !String(p ?? "").trim())) {
+    throw new Error(`performanceKey: \uC624\uB354 \xB7 \uAD6C\uAC04\uC774 \uC5C6\uC73C\uBA74 \uBA71\uB4F1 \uD0A4\uB97C \uB9CC\uB4E4 \uC218 \uC5C6\uB2E4 \u2014 ${JSON.stringify(e)}`);
+  }
+  return parts.join("|");
+}
+function materialMovementKey(e) {
+  return `${performanceKey(e)}|goods`;
+}
+function validatePerformance(e, nowMs) {
+  const errors = [];
+  if (!String(e?.orderId ?? "").trim()) errors.push("orderId \uC5C6\uC74C \u2014 \uC5B4\uB290 \uC9C0\uC2DC\uC5D0 \uB300\uD55C \uC2E4\uC801\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+  if (!String(e?.uom ?? "").trim()) errors.push("uom \uC5C6\uC74C \u2014 \uB2E8\uC704 \uC5C6\uB294 \uC218\uB7C9\uC740 \uC815\uC0B0\uC5D0 \uC4F8 \uC218 \uC5C6\uB2E4");
+  for (const [name, v] of [
+    ["goodQuantity", e?.goodQuantity],
+    ["scrapQuantity", e?.scrapQuantity]
+  ]) {
+    if (typeof v !== "number" || !Number.isFinite(v)) errors.push(`${name} \uC774 \uC218\uAC00 \uC544\uB2C8\uB2E4`);
+    else if (v < 0) errors.push(`${name} \uC774 \uC74C\uC218\uB2E4 \u2014 \uB418\uB3CC\uB9BC\uC740 \uC5ED\uBD84\uAC1C\uB85C \uD558\uACE0 \uC74C\uC218 \uC2E4\uC801\uC73C\uB85C \uD558\uC9C0 \uC54A\uB294\uB2E4`);
+  }
+  if (typeof e?.goodQuantity === "number" && typeof e?.scrapQuantity === "number" && e.goodQuantity + e.scrapQuantity <= 0) {
+    errors.push("\uB9CC\uB4E0 \uAC83\uC774 \uD558\uB098\uB3C4 \uC5C6\uB2E4 \u2014 \uC62C\uB9B4 \uC2E4\uC801\uC774 \uC544\uB2C8\uB2E4");
+  }
+  const from = Date.parse(String(e?.from ?? ""));
+  const to = Date.parse(String(e?.to ?? ""));
+  if (!Number.isFinite(from) || !Number.isFinite(to)) errors.push("\uAD6C\uAC04\uC774 \uC5C6\uB2E4 \u2014 from \xB7 to \uAC00 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+  else {
+    if (to < from) errors.push("\uAD6C\uAC04\uC774 \uAC70\uAFB8\uB85C\uB2E4");
+    if (to > nowMs) errors.push("\uC544\uC9C1 \uC624\uC9C0 \uC54A\uC740 \uC2DC\uAC01\uAE4C\uC9C0\uC758 \uC2E4\uC801\uC774\uB2E4");
+  }
+  for (const m of e?.materialActual ?? []) {
+    if (!String(m?.materialDefinitionId ?? "").trim()) errors.push("\uC790\uC7AC \uC904\uC5D0 materialDefinitionId \uAC00 \uC5C6\uB2E4");
+    if (!String(m?.uom ?? "").trim()) errors.push(`${m?.materialDefinitionId}: uom \uC5C6\uC74C \u2014 \uB2E8\uC704\uB294 ERP \uC758 \uC0AC\uC2E4\uC774\uBBC0\uB85C \uC9C0\uC5B4\uB0B4\uC9C0 \uC54A\uB294\uB2E4`);
+    if (typeof m?.quantity !== "number" || !(m.quantity > 0)) errors.push(`${m?.materialDefinitionId}: \uC218\uB7C9\uC774 0 \uC774\uD558\uB2E4`);
+    if (m?.direction !== "consumed" && m?.direction !== "produced") {
+      errors.push(`${m?.materialDefinitionId}: direction \uC774 consumed \xB7 produced \uAC00 \uC544\uB2C8\uB2E4`);
+    }
+  }
+  return errors;
+}
+function reversalKey(performanceKey2) {
+  if (!String(performanceKey2 ?? "").trim()) throw new Error("reversalKey: \uB418\uB3CC\uB9B4 \uC2E4\uC801\uC758 \uD0A4\uAC00 \uC5C6\uB2E4");
+  return `${performanceKey2}|reversal`;
+}
+var ERP_CAPABILITY = ["schedule", "performance", "material-movement", "reversal", "master"];
+var ERP_MASTER_AXIS = ["product", "bom", "routing", "work-center"];
+function erpCapabilityGaps(adapter) {
+  const needs = {
+    schedule: "readSchedules",
+    performance: "postPerformance",
+    "material-movement": "postMaterialMovement",
+    reversal: "reversePerformance",
+    master: "readMaster"
+  };
+  const gaps = [];
+  for (const cap of adapter.capabilities ?? []) {
+    const fn = needs[cap];
+    if (typeof adapter[fn] !== "function") gaps.push(`${cap} \uC744 \uC120\uC5B8\uD588\uB294\uB370 ${String(fn)} \uAD6C\uD604\uC774 \uC5C6\uB2E4`);
+  }
+  if (adapter.traits?.reversal === "api" && typeof adapter.reversePerformance !== "function") {
+    gaps.push("traits.reversal \uC774 api \uC778\uB370 reversePerformance \uAD6C\uD604\uC774 \uC5C6\uB2E4");
+  }
+  if (adapter.traits?.reversal !== "api" && adapter.capabilities?.includes("reversal")) {
+    gaps.push("reversal \uB2A5\uB825\uC744 \uC120\uC5B8\uD588\uB294\uB370 traits.reversal \uC774 api \uAC00 \uC544\uB2C8\uB2E4 \u2014 \uB458 \uC911 \uD558\uB098\uAC00 \uD2C0\uB838\uB2E4");
+  }
+  if (adapter.traits?.materialWithPerformance && typeof adapter.postMaterialMovement === "function") {
+    gaps.push("traits.materialWithPerformance \uAC00 \uCC38\uC778\uB370 postMaterialMovement \uAC00 \uB530\uB85C \uC788\uB2E4 \u2014 \uC18C\uBE44\uAC00 \uB450 \uBC88 \uC549\uB294\uB2E4");
+  }
+  return gaps;
+}
+
+// src/actuation.ts
+var COMMAND_STATE = ["proposed", "approved", "rejected", "dispatched", "acked", "failed"];
+var COMMAND_ORIGIN = ["operator", "rule", "ai", "schedule"];
+function requiresApproval(command) {
+  return command?.reversible !== true;
+}
+var COMMAND_EVENT = ["approve", "reject", "dispatch", "ack", "fail"];
+var ALLOWED = {
+  proposed: { approve: "approved", reject: "rejected" },
+  approved: { dispatch: "dispatched", reject: "rejected" },
+  /* 넘기다 실패한 것은 다시 넘길 수 있다 — 승인은 그대로 살아 있다. */
+  failed: { dispatch: "dispatched", reject: "rejected" },
+  dispatched: { ack: "acked", fail: "failed" },
+  acked: {},
+  rejected: {}
+};
+function nextCommandState(from, event) {
+  return ALLOWED[from]?.[event];
+}
+function isCommandTerminal(state) {
+  return Object.keys(ALLOWED[state] ?? {}).length === 0;
+}
+function approveCommand(command, approval) {
+  if (!approval?.by?.trim()) throw new Error("\uC2B9\uC778\uC5D0\uB294 \uB204\uAC00 \uC2B9\uC778\uD588\uB294\uC9C0\uAC00 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+  if (!approval?.at?.trim()) throw new Error("\uC2B9\uC778\uC5D0\uB294 \uC5B8\uC81C \uC2B9\uC778\uD588\uB294\uC9C0\uAC00 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+  const to = nextCommandState(command.state, "approve");
+  if (!to) throw new Error(`${command.state} \uC0C1\uD0DC\uC758 \uCEE4\uB9E8\uB4DC\uB294 \uC2B9\uC778\uD560 \uC218 \uC5C6\uB2E4 (${command.id})`);
+  return { ...command, state: to, approval };
+}
+function passThroughReversible(command) {
+  if (requiresApproval(command)) {
+    throw new Error(`\uB418\uB3CC\uB9B4 \uC218 \uC5C6\uB294 \uCEE4\uB9E8\uB4DC\uB294 \uC0AC\uB78C \uC2B9\uC778\uC744 \uC9C0\uB098\uC57C \uD55C\uB2E4 (${command.id} \xB7 ${command.type})`);
+  }
+  const to = nextCommandState(command.state, "approve");
+  if (!to) throw new Error(`${command.state} \uC0C1\uD0DC\uC758 \uCEE4\uB9E8\uB4DC\uB294 \uB118\uAE38 \uC218 \uC5C6\uB2E4 (${command.id})`);
+  return { ...command, state: to };
+}
+function asApproved(command) {
+  if (command.state !== "approved" && command.state !== "failed") {
+    throw new Error(`\uC2B9\uC778\uB418\uC9C0 \uC54A\uC740 \uCEE4\uB9E8\uB4DC\uB97C \uC870\uCE58\uB85C \uB118\uAE38 \uC218 \uC5C6\uB2E4 (${command.id} \xB7 ${command.state})`);
+  }
+  if (requiresApproval(command) && !command.approval?.by) {
+    throw new Error(`\uC2B9\uC778 \uAE30\uB85D\uC774 \uC5C6\uB294 \uCEE4\uB9E8\uB4DC\uB97C \uC870\uCE58\uB85C \uB118\uAE38 \uC218 \uC5C6\uB2E4 (${command.id})`);
+  }
+  return command;
+}
+function commandTypeOf(specs, type) {
+  return specs.find((s) => s.type === type);
+}
+function commandFromSpec(spec, seed) {
+  const missing = missingCommandPayload(spec, seed.payload);
+  if (missing.length) {
+    throw new Error(`${spec.type}: \uC694\uAD6C\uD558\uB294 \uCE78\uC774 \uC5C6\uB2E4 \u2014 ${missing.join(", ")}`);
+  }
+  return {
+    id: seed.id,
+    instanceId: seed.instanceId,
+    type: spec.type,
+    ...seed.payload ? { payload: seed.payload } : {},
+    origin: seed.origin,
+    proposedAt: seed.proposedAt,
+    reversible: spec.reversible,
+    state: "proposed"
+  };
+}
+function missingCommandPayload(spec, payload) {
+  const has = (k) => {
+    const v = payload?.[k];
+    if (v === void 0 || v === null) return false;
+    return typeof v === "string" ? v.trim().length > 0 : true;
+  };
+  return spec.required.filter((k) => !has(k));
+}
+function commandSpecGaps(specs, command) {
+  const spec = commandTypeOf(specs, command.type);
+  if (!spec) return [`\uBAA8\uB974\uB294 \uC870\uCE58 \uC885\uB958\uB2E4 \u2014 ${command.type}`];
+  const gaps = missingCommandPayload(spec, command.payload).map((k) => `\uC694\uAD6C\uD558\uB294 \uCE78\uC774 \uC5C6\uB2E4 \u2014 ${k}`);
+  if (command.reversible === true && spec.reversible === false) {
+    gaps.push(`${command.type} \uC740 \uB418\uB3CC\uB9B4 \uC218 \uC5C6\uB294 \uC885\uB958\uC778\uB370 \uC774 \uCEE4\uB9E8\uB4DC\uAC00 \uB418\uB3CC\uB9B4 \uC218 \uC788\uB2E4\uACE0 \uD55C\uB2E4 \u2014 \uC2B9\uC778\uC744 \uAC74\uB108\uB6F4\uB2E4`);
+  }
+  return gaps;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BIZSTEP,
@@ -3863,6 +4062,9 @@ function computeOee(c, nowMs) {
   CAPABILITY_KEYS,
   CBV_BIZSTEP,
   CMD,
+  COMMAND_EVENT,
+  COMMAND_ORIGIN,
+  COMMAND_STATE,
   DISP,
   DISPOSITION_DECISION,
   DOMAIN_CATALOG,
@@ -3876,11 +4078,14 @@ function computeOee(c, nowMs) {
   EPCIS_CONTEXT,
   EPCIS_EVENT,
   EQUIPMENT_LEVEL,
+  ERP_CAPABILITY,
+  ERP_MASTER_AXIS,
   GUARD_PRAGMA,
   ILMD_ATTR,
   LOCATION_SATURATION_NEAR,
   MATERIAL_PROPERTY,
   MES_BIZSTEP,
+  MES_COMMANDS,
   MES_LOCATION_TYPES,
   MES_TYPES,
   METER_DIRECTION,
@@ -3890,6 +4095,7 @@ function computeOee(c, nowMs) {
   ORDER_TERMINAL_STATUS,
   PRIORITY_UNSET,
   RETIRED_VOCABULARY,
+  SCHEDULE_STATUS,
   TWIN_AXES,
   TWIN_PROPERTIES,
   TWIN_RELATIONS,
@@ -3903,10 +4109,13 @@ function computeOee(c, nowMs) {
   YARD_BIZSTEP,
   YMS_LOCATION_TYPES,
   YMS_TYPES,
+  acceptsPerformance,
   activeShiftAt,
   activeShiftOf,
   aggregationEvent,
   analyzeCapacity,
+  approveCommand,
+  asApproved,
   axesOfSystem,
   axisAppliesTo,
   axisInfo,
@@ -3918,6 +4127,9 @@ function computeOee(c, nowMs) {
   checkSequenceRun,
   classClosure,
   classIdentifierViolation,
+  commandFromSpec,
+  commandSpecGaps,
+  commandTypeOf,
   commandsOf,
   computeOee,
   conversionFactorOf,
@@ -3926,6 +4138,7 @@ function computeOee(c, nowMs) {
   dueStatusOf,
   effectivityAt,
   electricalUpstreamOf,
+  erpCapabilityGaps,
   expiryFromAttributes,
   gdtiUri,
   generationFractionAt,
@@ -3947,6 +4160,7 @@ function computeOee(c, nowMs) {
   ingestMasterData,
   ingestOperationalRecords,
   isAggregationRecord,
+  isCommandTerminal,
   isElectricalLocationType,
   isEnergyBillRecord,
   isEnergyEquipmentRecord,
@@ -3973,8 +4187,11 @@ function computeOee(c, nowMs) {
   lotFromAttributes,
   mapRecord,
   mapRecordChecked,
+  materialMovementKey,
   meetsTests,
   minuteOfDayAt,
+  missingCommandPayload,
+  nextCommandState,
   objectEvent,
   objectUri,
   observationAt,
@@ -3985,6 +4202,8 @@ function computeOee(c, nowMs) {
   outsideLimit,
   parseEpc,
   parseIsoDuration,
+  passThroughReversible,
+  performanceKey,
   periodFactId,
   priorityRank,
   procedureViolations,
@@ -3996,8 +4215,10 @@ function computeOee(c, nowMs) {
   relationsFrom,
   relationsTo,
   requiredTestsFor,
+  requiresApproval,
   resolveSubject,
   retiredVocabularyIn,
+  reversalKey,
   sgtinClass,
   sgtinUri,
   ssccUri,
@@ -4009,6 +4230,7 @@ function computeOee(c, nowMs) {
   transformationEvent,
   validateDomainDefinition,
   validateEpcisEvent,
+  validatePerformance,
   validateScenario,
   webhookSenderAction,
   weekdayAt,

package/package.json

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