@operato/twin-kernel 0.6.11 → 0.6.12

package/dist/flow-engine.d.ts

@@ -4,6 +4,7 @@ import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
 import type { OperationDef } from './domain-definition.ts';
 import { type CapacityAnalysis } from './capacity.ts';
+import { type CommittedDemand, type OperationsCapabilityReport } from './operations-capability.ts';
 export interface FlowLocation {
     id: string;
     type: string;
@@ -527,6 +528,37 @@ export declare abstract class FlowEngine implements TwinKernel {
     }): CapacityAnalysis & {
         mixedCalendars: boolean;
     };
+    /**
+     * **생산 능력 보고서** — ISA-95 Part 4 `OperationsCapability`(§operations-capability).
+     *
+     * `capacity()` 는 비율(시간당)을 낸다. 이것은 **구간의 양을 종류로 갈라** 낸다: 약정·가용·달성불가.
+     * 종류가 없으면 "지금 주문을 더 받을 수 있나" 에 답할 수 없다 — 이 개념을 쓰는 가장 흔한 질문이다.
+     *
+     * 커널이 답하는 이유는 `capacity()` 와 같다(사실이 전부 여기 있다). 여기서 더한 것은 둘이다:
+     *
+     *  1. **지금 쓸 수 없는 자원을 걸러 같은 계산을 한 번 더** 돌린다 — 그 차이가 달성불가다. 판정은
+     *     다시 만들지 않고 `capabilityOf` 를 부른다(규칙 한 벌). 표준의 `Unattainable` 정의가 우리
+     *     판정과 정확히 겹친다: 설비 상태·점유·인원 가용성 때문에 못 쓰는 용량.
+     *  2. **약정**은 오더에서 온다 — 이 구간에 납기가 걸린 미완 오더의 잔량.
+     */
+    operationsCapability(opts: {
+        unitsPerDay: number;
+        sampleWeekStartMs: number;
+        window: {
+            fromTime: string;
+            toTime: string;
+        };
+    }): OperationsCapabilityReport & {
+        mixedCalendars: boolean;
+    };
+    /**
+     * 약정의 재료 — **이 구간에 납기가 걸린 미완 오더의 잔량.**
+     *
+     * 이행분을 뺀다(`requested − fulfilled`): 이미 만들어 보낸 것은 능력을 더 쓰지 않는다. 납기를 모르는
+     * 오더는 **구간에 넣지 않는다** — 짐작해 넣으면 남은 능력이 실제보다 적게 보이고, 그 보수성은
+     * "받을 수 있는데 못 받는다" 는 잘못된 판단을 만든다.
+     */
+    protected committedDemands(): CommittedDemand[];
     /**
      * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
      *

package/dist/flow-engine.js

@@ -14,6 +14,7 @@ import { ObservedReducer } from "./observed-reducer.js";
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP } from "./epcis.js";
 import { parseIsoDuration } from "./iso-duration.js";
 import { analyzeCapacity } from "./capacity.js";
+import { operationsCapabilityOf } from "./operations-capability.js";
 const BASE_EPOCH = Date.parse('2026-01-01T00:00:00Z');
 /**
  * 선언한 유효 기간만 뽑는다 — 마스터가 말하지 않으면 필드를 만들지 않는다.
@@ -1140,6 +1141,71 @@ export class FlowEngine {
         });
         return { ...analysis, mixedCalendars: calendars.size > 1 };
     }
+    /**
+     * **생산 능력 보고서** — ISA-95 Part 4 `OperationsCapability`(§operations-capability).
+     *
+     * `capacity()` 는 비율(시간당)을 낸다. 이것은 **구간의 양을 종류로 갈라** 낸다: 약정·가용·달성불가.
+     * 종류가 없으면 "지금 주문을 더 받을 수 있나" 에 답할 수 없다 — 이 개념을 쓰는 가장 흔한 질문이다.
+     *
+     * 커널이 답하는 이유는 `capacity()` 와 같다(사실이 전부 여기 있다). 여기서 더한 것은 둘이다:
+     *
+     *  1. **지금 쓸 수 없는 자원을 걸러 같은 계산을 한 번 더** 돌린다 — 그 차이가 달성불가다. 판정은
+     *     다시 만들지 않고 `capabilityOf` 를 부른다(규칙 한 벌). 표준의 `Unattainable` 정의가 우리
+     *     판정과 정확히 겹친다: 설비 상태·점유·인원 가용성 때문에 못 쓰는 용량.
+     *  2. **약정**은 오더에서 온다 — 이 구간에 납기가 걸린 미완 오더의 잔량.
+     */
+    operationsCapability(opts) {
+        const calendars = new Map();
+        for (const m of this.equipment.values())
+            if (m.workCalendar?.length)
+                calendars.set(JSON.stringify(m.workCalendar), m.workCalendar);
+        const calendar = calendars.size === 1 ? [...calendars.values()][0] : undefined;
+        /* 판정 시각은 **구간의 시작**이다 — 능력은 그 구간을 두고 묻는 것이므로, 지금 고장 난 설비가 아니라
+           그 구간에 못 쓰는 설비를 세야 한다(같은 판정 함수에 다른 시각을 준다). */
+        const at = opts.window.fromTime;
+        const usableEquipment = [...this.equipment.values()].filter(m => this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment, at).available);
+        const usablePersons = [...this.persons.values()].filter(p => this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel, at).available);
+        const usableAssets = [...this.assets.values()].filter(a => this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset, at).available);
+        const base = {
+            operations: [...this.operationSpecs.values()],
+            ...(this.routeKeys() ? { route: this.routeKeys() } : {}),
+            locations: [...this.locations.values()],
+            ...(calendar ? { calendar } : {}),
+            ...(this.boardDef?.utcOffsetMinutes !== undefined ? { utcOffsetMinutes: this.boardDef.utcOffsetMinutes } : {}),
+            sampleWeekStartMs: opts.sampleWeekStartMs,
+            unitsPerDay: opts.unitsPerDay
+        };
+        const eqOf = (list) => list.map(m => ({ kind: m.kind, mtbfMs: m.mtbfMs, mttrMs: m.mttrMs }));
+        const report = operationsCapabilityOf({
+            capacity: { ...base, equipment: eqOf([...this.equipment.values()]), persons: [...this.persons.values()], assets: [...this.assets.values()] },
+            usableCapacity: { ...base, equipment: eqOf(usableEquipment), persons: usablePersons, assets: usableAssets },
+            window: opts.window,
+            ...(calendar ? { calendar } : {}),
+            ...(this.boardDef?.utcOffsetMinutes !== undefined ? { utcOffsetMinutes: this.boardDef.utcOffsetMinutes } : {}),
+            demands: this.committedDemands(),
+            publishedDate: this.now()
+        });
+        return { ...report, mixedCalendars: calendars.size > 1 };
+    }
+    /**
+     * 약정의 재료 — **이 구간에 납기가 걸린 미완 오더의 잔량.**
+     *
+     * 이행분을 뺀다(`requested − fulfilled`): 이미 만들어 보낸 것은 능력을 더 쓰지 않는다. 납기를 모르는
+     * 오더는 **구간에 넣지 않는다** — 짐작해 넣으면 남은 능력이 실제보다 적게 보이고, 그 보수성은
+     * "받을 수 있는데 못 받는다" 는 잘못된 판단을 만든다.
+     */
+    committedDemands() {
+        const out = [];
+        for (const o of this.orders.values()) {
+            if (o.status === 'completed' || o.status === 'cancelled')
+                continue;
+            const remaining = Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
+            if (!remaining)
+                continue;
+            out.push({ remaining, ...(o.endTime ? { dueTime: o.endTime } : {}) });
+        }
+        return out;
+    }
     /**
      * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
      *
@@ -1903,11 +1969,14 @@ export class FlowEngine {
      * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
      * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
      */
-    capabilityOfResource(r, directClassIds, defs) {
+    capabilityOfResource(r, directClassIds, defs, 
+    /* 판정 시각 — 기본은 지금이지만 **구간을 두고 묻는 쪽**이 다른 시각을 준다(§operationsCapability).
+       능력은 "이번 주에 쓸 수 있나" 이므로 지금 고장 난 것이 아니라 그 구간에 못 쓰는 것을 세야 한다. */
+    at = this.now()) {
         return capabilityOf(r, {
-            at: this.now(),
+            at,
             utcOffsetMinutes: this.boardDef?.utcOffsetMinutes,
-            requiredTests: requiredTestsFor(directClassIds, defs, this.now())
+            requiredTests: requiredTestsFor(directClassIds, defs, at)
         });
     }
     claimPersonnel(t) {

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export * from './yms-profile.ts';
 export * from './mes-profile.ts';
 export * from './flow-engine.ts';
 export * from './capacity.ts';
+export * from './operations-capability.ts';
 export { WmsKernel } from './kernel.ts';
 export { YmsKernel } from './yms-kernel.ts';
 export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS, MES_PRODUCTS } from './mes-kernel.ts';

package/dist/index.js

@@ -23,6 +23,7 @@ export * from "./yms-profile.js";
 export * from "./mes-profile.js";
 export * from "./flow-engine.js";
 export * from "./capacity.js";
+export * from "./operations-capability.js";
 export { WmsKernel } from "./kernel.js";
 export { YmsKernel } from "./yms-kernel.js";
 export { MesKernel, MES_PART_GTINS, MES_PRODUCT_GTINS, MES_PRODUCTS } from "./mes-kernel.js";

package/dist/operations-capability.d.ts

@@ -0,0 +1,106 @@
+import { type CapacityAnalysis, type CapacityInput, type CapacityRequirement } from './capacity.ts';
+import { type ISOTime, type WorkCalendarEntry } from './contract.ts';
+/**
+ * 능력의 종류 — **표준 열거형**(B2MML `CapabilityTypeType`). 우리 낱말을 새로 만들지 않는다.
+ *
+ * 표준 정의(스키마 주석 그대로 옮김):
+ *  - `Committed` — 앞으로 쓰기로 약정된 용량
+ *  - `Unattainable` — 설비 상태·점유·인원·자재 때문에 앞으로 쓸 수 없는 용량
+ *  - `Available` — 앞으로 더 쓸 수 있는 용량
+ *  - `Used` / `Unused` — **과거** 값(품질 합격분 / 안 쓰였거나 불합격분)
+ *  - `Total` — 과거로는 Used+Unused, 미래로는 Available+Unattainable+Committed
+ */
+export type CapabilityType = 'Used' | 'Unused' | 'Total' | 'Committed' | 'Available' | 'Unattainable' | 'Other';
+/** 활동의 종류 — 표준 열거형(`OperationsTypeType`). 지금 우리는 생산만 다룬다. */
+export type OperationsType = 'Production' | 'Maintenance' | 'Quality' | 'Inventory' | 'Mixed' | 'Other';
+/** 한 공정의 능력 — 미래 분해. */
+export interface OperationCapability {
+    operation: string;
+    /**
+     * 이 공정이 이 구간에 낼 수 있는 최대량 — `Committed + Available + Unattainable`.
+     *
+     * **`null` 은 "능력 없음" 이 아니라 "모른다"** 다: 공정 명세가 자원을 하나도 요구하지 않으면 상한이
+     * 서지 않는다. 0 으로 메우면 "이 공정은 아무것도 못 한다" 는 없는 사실이 생긴다.
+     */
+    total: number | null;
+    /** 이미 약정된 몫 — 이 구간에 납기가 걸린 미완 오더의 잔량. */
+    committed: number;
+    /**
+     * 지금 쓸 수 없는 자원 때문에 잃는 몫. 자원의 현재 사실을 받지 못했으면 **`null`**(모른다).
+     * 0 으로 내면 "고장도 자격 만료도 없다" 는 없는 사실이 된다.
+     */
+    unattainable: number | null;
+    /**
+     * 남은 능력 — `total − committed − unattainable`.
+     *
+     * **음수를 0 으로 깎지 않는다.** 음수는 사실이다(받을 수 없는 물량을 받았다). 가장 알아야 할 상태를
+     * `Math.max(0, …)` 하나로 덮는 일이 실제로 이 트윈에서 여러 번 있었다.
+     */
+    available: number | null;
+    /** 무엇이 묶고 있나 — 축과 등급(용량 분석이 이미 낸다). */
+    constraint?: CapacityRequirement;
+}
+export interface OperationsCapabilityReport {
+    /** 표준 `OperationsType` — 지금은 생산뿐이다(정비·품질 능력은 별도 보고서가 될 자리). */
+    operationsType: OperationsType;
+    /**
+     * 어느 구간의 능력인가 — **구간 없이 능력은 존재하지 않는다**(표준 `StartTime`·`EndTime`).
+     * `workingHours` 는 그 구간의 **가동 시간**이다(벽시계 시간이 아니다 — 쉬는 시간에는 안 나온다).
+     */
+    window: {
+        fromTime: ISOTime;
+        toTime: ISOTime;
+        workingHours: number;
+    };
+    perOperation: OperationCapability[];
+    /** 라인을 묶는 공정 — 용량 분석의 판정을 그대로 쓴다. */
+    bottleneck?: CapacityAnalysis['bottleneck'];
+    /** 이 보고서를 낸 시각(표준 `PublishedDate`). 부르는 쪽이 준다 — 커널은 벽시계를 읽지 않는다. */
+    publishedDate?: ISOTime;
+}
+/** 이 구간에 납기가 걸린 미완 오더 — 약정의 재료. */
+export interface CommittedDemand {
+    /** 남은 수량(요청 − 이행). 음수는 0 으로 본다(이행 초과는 약정이 아니다). */
+    remaining: number;
+    /** 납기 — 이 구간 안이어야 이 구간의 약정이다. 없으면 구간에 속하지 않는다(짐작하지 않는다). */
+    dueTime?: ISOTime;
+    /** 어느 공정의 약정인가. 없으면 **모든 공정에** 걸린다(라인 전체가 그 물량을 통과시켜야 한다). */
+    operation?: string;
+}
+export interface OperationsCapabilityInput {
+    /** 전량 선언 기준 — 이 모델이 가진 모든 자원. */
+    capacity: CapacityInput;
+    /**
+     * **지금 쓸 수 있는 자원만** 남긴 같은 입력. 없으면 `unattainable` 은 `null` 이다.
+     *
+     * 판정을 여기서 다시 하지 않는 이유: 판정은 한 벌이어야 하고 그 한 벌은 `capabilityOf` 다
+     * (고장·보류·교대·휴일·자격 만료·유효기간). 부르는 쪽이 그것으로 걸러 준 자원을 넘긴다.
+     */
+    usableCapacity?: CapacityInput;
+    window: {
+        fromTime: ISOTime;
+        toTime: ISOTime;
+    };
+    calendar?: readonly WorkCalendarEntry[];
+    utcOffsetMinutes?: number;
+    demands?: readonly CommittedDemand[];
+    operationsType?: OperationsType;
+    publishedDate?: ISOTime;
+}
+/**
+ * 구간의 **가동 시간** — 1분 간격으로 캘린더에 묻는다.
+ *
+ * 규칙을 다시 적지 않는다(`inWorkCalendarAt` 한 곳에만 있다). 캘린더가 없으면 종일 가동으로 본다 —
+ * 제약이 **선언되지 않은** 것이고, 선언이 없으면 커널은 멈출 이유를 모른다(용량 분석과 같은 규율).
+ *
+ * 비용은 구간에 비례한다(1년 = 약 53만 번의 값싼 호출). 근사하지 않는 이유: 한 주를 재서 곱하면
+ * 공휴일이 사라지고, 그 오차는 조용하다.
+ */
+export declare function workingHoursBetween(calendar: readonly WorkCalendarEntry[] | undefined, fromMs: number, toMs: number, utcOffsetMinutes?: number): number;
+/**
+ * 생산 능력 보고서 — 있는 용량 분석 위에 **구간 · 종류 · 약정**을 올린다.
+ *
+ * 용량 분석을 두 번 부른다(전량 · 가용). 같은 함수를 두 번 부르는 것이 요점이다: 달성불가를 따로
+ * 계산하면 규칙이 두 벌이 되고, 두 벌은 갈라진다.
+ */
+export declare function operationsCapabilityOf(input: OperationsCapabilityInput): OperationsCapabilityReport;

package/dist/operations-capability.js

@@ -0,0 +1,114 @@
+/*
+ * 생산 능력 — **ISA-95 Part 4 `OperationsCapability`**: "이 현장이 어느 구간에 얼마나 할 수 있는가."
+ *
+ * ── 왜 용량 분석만으로는 부족한가 ────────────────────────────────────────────
+ * `capacity.ts` 는 이미 네 축(설비·인원·자산·자리) 정상상태 상한과 병목을 낸다. 그런데 그것은 **비율**
+ * 이다(시간당 몇 대). 표준이 게시하라는 것은 **구간의 양**이고, 그 양을 **종류로 가른다.**
+ *
+ * 종류가 없으면 답할 수 없는 질문이 있다 — 그리고 그것이 이 개념을 쓰는 가장 흔한 질문이다:
+ * **"지금 주문을 더 받을 수 있나."** 상한만 있으면 "시간당 12대" 까지고, 이미 약속한 물량을 빼야
+ * 비로소 남은 능력이 나온다.
+ *
+ * ── 표준의 어휘를 그대로 쓴다 ────────────────────────────────────────────────
+ * `CapabilityType` 은 자유 문자열이 아니라 **열거형**이다(B2MML-Common.xsd 대조 완료). 그리고 표준은
+ * `Total` 을 **두 갈래**로 쪼갠다:
+ *
+ *   · 과거 — `Total = Used + Unused`                        (쓴 몫 · 못 쓴 몫)
+ *   · 미래 — `Total = Committed + Available + Unattainable`  (약정 · 가용 · 달성불가)
+ *
+ * 이 보고서는 **미래 쪽**이다. 과거 쪽은 이미 두 곳에 있다(설비 OEE 의 가동/유휴, 호스트의 구간
+ * 가동률) — 우리가 "가동률이 두 벌이다" 로 본 것이 여기서 설명된다: **두 벌인 것이 맞고, 표준이 그
+ * 둘을 다른 종류로 부른다.** 합칠 일이 아니라 각자 어느 종류인지 밝힐 일이다.
+ *
+ * `Unattainable` 의 표준 정의는 우리 판정과 정확히 겹친다 — *설비 상태·설비 점유·인원 가용성·자재
+ * 가용성 때문에 앞으로 쓸 수 없는 용량.* 그래서 이 모듈은 그것을 **다시 판정하지 않는다**:
+ * 부르는 쪽이 "전량 선언 기준" 과 "지금 쓸 수 있는 자원 기준" 두 벌을 주면, 그 **차이가 곧
+ * 달성불가**다(§unattainableOf). 판정은 한 벌이어야 하고 그 한 벌은 `capabilityOf` 다.
+ */
+import { analyzeCapacity } from "./capacity.js";
+import { inWorkCalendarAt } from "./contract.js";
+/**
+ * 구간의 **가동 시간** — 1분 간격으로 캘린더에 묻는다.
+ *
+ * 규칙을 다시 적지 않는다(`inWorkCalendarAt` 한 곳에만 있다). 캘린더가 없으면 종일 가동으로 본다 —
+ * 제약이 **선언되지 않은** 것이고, 선언이 없으면 커널은 멈출 이유를 모른다(용량 분석과 같은 규율).
+ *
+ * 비용은 구간에 비례한다(1년 = 약 53만 번의 값싼 호출). 근사하지 않는 이유: 한 주를 재서 곱하면
+ * 공휴일이 사라지고, 그 오차는 조용하다.
+ */
+export function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
+    if (!(toMs > fromMs))
+        return 0;
+    if (!calendar?.length)
+        return (toMs - fromMs) / 3_600_000;
+    let minutes = 0;
+    for (let ms = fromMs; ms < toMs; ms += 60_000)
+        if (inWorkCalendarAt(calendar, ms, utcOffsetMinutes))
+            minutes++;
+    return minutes / 60;
+}
+/**
+ * 생산 능력 보고서 — 있는 용량 분석 위에 **구간 · 종류 · 약정**을 올린다.
+ *
+ * 용량 분석을 두 번 부른다(전량 · 가용). 같은 함수를 두 번 부르는 것이 요점이다: 달성불가를 따로
+ * 계산하면 규칙이 두 벌이 되고, 두 벌은 갈라진다.
+ */
+export function operationsCapabilityOf(input) {
+    const fromMs = Date.parse(input.window.fromTime);
+    const toMs = Date.parse(input.window.toTime);
+    if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
+        throw new Error(`능력의 구간을 읽을 수 없다: ${input.window.fromTime} ~ ${input.window.toTime}`);
+    }
+    if (toMs <= fromMs)
+        throw new Error(`능력의 구간이 뒤집혔다: ${input.window.fromTime} ~ ${input.window.toTime}`);
+    const workingHours = workingHoursBetween(input.calendar ?? input.capacity.calendar, fromMs, toMs, input.utcOffsetMinutes);
+    const full = analyzeCapacity(input.capacity);
+    const usable = input.usableCapacity ? analyzeCapacity(input.usableCapacity) : undefined;
+    /** 비율(시간당) → 구간의 양. 상한이 무한(요구가 없는 공정)이면 **모른다**. */
+    const amountOf = (perHour) => (Number.isFinite(perHour) ? perHour * workingHours : null);
+    const committedOf = (operation) => {
+        let sum = 0;
+        for (const d of input.demands ?? []) {
+            if (d.operation !== undefined && d.operation !== operation)
+                continue;
+            /* 납기가 없으면 이 구간의 약정이 아니다 — 짐작해서 넣으면 남은 능력이 실제보다 적게 보인다. */
+            if (!d.dueTime)
+                continue;
+            const due = Date.parse(d.dueTime);
+            if (!Number.isFinite(due) || due < fromMs || due >= toMs)
+                continue;
+            sum += Math.max(0, d.remaining);
+        }
+        return sum;
+    };
+    const perOperation = full.operations.map(op => {
+        const total = amountOf(op.perHour);
+        const committed = committedOf(op.operation);
+        /*
+         * 달성불가 = 전량 기준 − 가용 자원 기준. 자원의 현재 사실을 못 받았으면 **모른다**(0 이 아니다).
+         * 음수가 되는 일은 없어야 하지만(가용 ⊆ 전량), 되면 그것을 감추지 않고 0 으로 깎는다 — 부분집합이
+         * 아닌 입력을 받은 것이므로 값을 지어내는 대신 아래 `available` 이 어긋남을 드러낸다.
+         */
+        let unattainable = null;
+        if (usable) {
+            const usableAmount = amountOf(usable.operations.find(o => o.operation === op.operation)?.perHour ?? NaN);
+            unattainable = total != null && usableAmount != null ? Math.max(0, total - usableAmount) : null;
+        }
+        const available = total == null || unattainable == null ? null : total - committed - unattainable;
+        return {
+            operation: op.operation,
+            total,
+            committed,
+            unattainable,
+            available,
+            ...(op.constraint ? { constraint: op.constraint } : {})
+        };
+    });
+    return {
+        operationsType: input.operationsType ?? 'Production',
+        window: { fromTime: input.window.fromTime, toTime: input.window.toTime, workingHours },
+        perOperation,
+        ...(full.bottleneck ? { bottleneck: full.bottleneck } : {}),
+        ...(input.publishedDate ? { publishedDate: input.publishedDate } : {})
+    };
+}

package/dist-cjs/index.cjs

@@ -106,6 +106,7 @@ __export(index_exports, {
   objectEvent: () => objectEvent,
   offCalendarAt: () => offCalendarAt,
   offCalendarReasonAt: () => offCalendarReasonAt,
+  operationsCapabilityOf: () => operationsCapabilityOf,
   parseEpc: () => parseEpc,
   parseIsoDuration: () => parseIsoDuration,
   partialFitPolicy: () => partialFitPolicy,
@@ -133,6 +134,7 @@ __export(index_exports, {
   validateEpcisEvent: () => validateEpcisEvent,
   validateScenario: () => validateScenario,
   weekdayAt: () => weekdayAt,
+  workingHoursBetween: () => workingHoursBetween,
   workingTimeOfWeek: () => workingTimeOfWeek
 });
 module.exports = __toCommonJS(index_exports);
@@ -2240,6 +2242,63 @@ function analyzeCapacity(input) {
   };
 }
 
+// src/operations-capability.ts
+function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
+  if (!(toMs > fromMs)) return 0;
+  if (!calendar?.length) return (toMs - fromMs) / 36e5;
+  let minutes = 0;
+  for (let ms2 = fromMs; ms2 < toMs; ms2 += 6e4) if (inWorkCalendarAt(calendar, ms2, utcOffsetMinutes)) minutes++;
+  return minutes / 60;
+}
+function operationsCapabilityOf(input) {
+  const fromMs = Date.parse(input.window.fromTime);
+  const toMs = Date.parse(input.window.toTime);
+  if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
+    throw new Error(`\uB2A5\uB825\uC758 \uAD6C\uAC04\uC744 \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${input.window.fromTime} ~ ${input.window.toTime}`);
+  }
+  if (toMs <= fromMs) throw new Error(`\uB2A5\uB825\uC758 \uAD6C\uAC04\uC774 \uB4A4\uC9D1\uD614\uB2E4: ${input.window.fromTime} ~ ${input.window.toTime}`);
+  const workingHours = workingHoursBetween(input.calendar ?? input.capacity.calendar, fromMs, toMs, input.utcOffsetMinutes);
+  const full = analyzeCapacity(input.capacity);
+  const usable = input.usableCapacity ? analyzeCapacity(input.usableCapacity) : void 0;
+  const amountOf = (perHour) => Number.isFinite(perHour) ? perHour * workingHours : null;
+  const committedOf = (operation) => {
+    let sum = 0;
+    for (const d of input.demands ?? []) {
+      if (d.operation !== void 0 && d.operation !== operation) continue;
+      if (!d.dueTime) continue;
+      const due = Date.parse(d.dueTime);
+      if (!Number.isFinite(due) || due < fromMs || due >= toMs) continue;
+      sum += Math.max(0, d.remaining);
+    }
+    return sum;
+  };
+  const perOperation = full.operations.map((op) => {
+    const total = amountOf(op.perHour);
+    const committed = committedOf(op.operation);
+    let unattainable = null;
+    if (usable) {
+      const usableAmount = amountOf(usable.operations.find((o) => o.operation === op.operation)?.perHour ?? NaN);
+      unattainable = total != null && usableAmount != null ? Math.max(0, total - usableAmount) : null;
+    }
+    const available = total == null || unattainable == null ? null : total - committed - unattainable;
+    return {
+      operation: op.operation,
+      total,
+      committed,
+      unattainable,
+      available,
+      ...op.constraint ? { constraint: op.constraint } : {}
+    };
+  });
+  return {
+    operationsType: input.operationsType ?? "Production",
+    window: { fromTime: input.window.fromTime, toTime: input.window.toTime, workingHours },
+    perOperation,
+    ...full.bottleneck ? { bottleneck: full.bottleneck } : {},
+    ...input.publishedDate ? { publishedDate: input.publishedDate } : {}
+  };
+}
+
 // src/flow-engine.ts
 var BASE_EPOCH = Date.parse("2026-01-01T00:00:00Z");
 function effectiveOnly(r) {
@@ -3244,6 +3303,71 @@ var FlowEngine = class {
     });
     return { ...analysis, mixedCalendars: calendars.size > 1 };
   }
+  /**
+   * **생산 능력 보고서** — ISA-95 Part 4 `OperationsCapability`(§operations-capability).
+   *
+   * `capacity()` 는 비율(시간당)을 낸다. 이것은 **구간의 양을 종류로 갈라** 낸다: 약정·가용·달성불가.
+   * 종류가 없으면 "지금 주문을 더 받을 수 있나" 에 답할 수 없다 — 이 개념을 쓰는 가장 흔한 질문이다.
+   *
+   * 커널이 답하는 이유는 `capacity()` 와 같다(사실이 전부 여기 있다). 여기서 더한 것은 둘이다:
+   *
+   *  1. **지금 쓸 수 없는 자원을 걸러 같은 계산을 한 번 더** 돌린다 — 그 차이가 달성불가다. 판정은
+   *     다시 만들지 않고 `capabilityOf` 를 부른다(규칙 한 벌). 표준의 `Unattainable` 정의가 우리
+   *     판정과 정확히 겹친다: 설비 상태·점유·인원 가용성 때문에 못 쓰는 용량.
+   *  2. **약정**은 오더에서 온다 — 이 구간에 납기가 걸린 미완 오더의 잔량.
+   */
+  operationsCapability(opts) {
+    const calendars = /* @__PURE__ */ new Map();
+    for (const m of this.equipment.values()) if (m.workCalendar?.length) calendars.set(JSON.stringify(m.workCalendar), m.workCalendar);
+    const calendar = calendars.size === 1 ? [...calendars.values()][0] : void 0;
+    const at = opts.window.fromTime;
+    const usableEquipment = [...this.equipment.values()].filter(
+      (m) => this.capabilityOfResource(m, m.kind ? [m.kind] : [], this.classDefs.equipment, at).available
+    );
+    const usablePersons = [...this.persons.values()].filter(
+      (p) => this.capabilityOfResource(p, p.personnelClassIds, this.classDefs.personnel, at).available
+    );
+    const usableAssets = [...this.assets.values()].filter(
+      (a) => this.capabilityOfResource(a, a.assetClassIds, this.classDefs.asset, at).available
+    );
+    const base = {
+      operations: [...this.operationSpecs.values()],
+      ...this.routeKeys() ? { route: this.routeKeys() } : {},
+      locations: [...this.locations.values()],
+      ...calendar ? { calendar } : {},
+      ...this.boardDef?.utcOffsetMinutes !== void 0 ? { utcOffsetMinutes: this.boardDef.utcOffsetMinutes } : {},
+      sampleWeekStartMs: opts.sampleWeekStartMs,
+      unitsPerDay: opts.unitsPerDay
+    };
+    const eqOf = (list) => list.map((m) => ({ kind: m.kind, mtbfMs: m.mtbfMs, mttrMs: m.mttrMs }));
+    const report = operationsCapabilityOf({
+      capacity: { ...base, equipment: eqOf([...this.equipment.values()]), persons: [...this.persons.values()], assets: [...this.assets.values()] },
+      usableCapacity: { ...base, equipment: eqOf(usableEquipment), persons: usablePersons, assets: usableAssets },
+      window: opts.window,
+      ...calendar ? { calendar } : {},
+      ...this.boardDef?.utcOffsetMinutes !== void 0 ? { utcOffsetMinutes: this.boardDef.utcOffsetMinutes } : {},
+      demands: this.committedDemands(),
+      publishedDate: this.now()
+    });
+    return { ...report, mixedCalendars: calendars.size > 1 };
+  }
+  /**
+   * 약정의 재료 — **이 구간에 납기가 걸린 미완 오더의 잔량.**
+   *
+   * 이행분을 뺀다(`requested − fulfilled`): 이미 만들어 보낸 것은 능력을 더 쓰지 않는다. 납기를 모르는
+   * 오더는 **구간에 넣지 않는다** — 짐작해 넣으면 남은 능력이 실제보다 적게 보이고, 그 보수성은
+   * "받을 수 있는데 못 받는다" 는 잘못된 판단을 만든다.
+   */
+  committedDemands() {
+    const out = [];
+    for (const o of this.orders.values()) {
+      if (o.status === "completed" || o.status === "cancelled") continue;
+      const remaining = Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
+      if (!remaining) continue;
+      out.push({ remaining, ...o.endTime ? { dueTime: o.endTime } : {} });
+    }
+    return out;
+  }
   /**
    * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
    *
@@ -3931,11 +4055,11 @@ var FlowEngine = class {
    * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
    * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
    */
-  capabilityOfResource(r, directClassIds, defs) {
+  capabilityOfResource(r, directClassIds, defs, at = this.now()) {
     return capabilityOf(r, {
-      at: this.now(),
+      at,
       utcOffsetMinutes: this.boardDef?.utcOffsetMinutes,
-      requiredTests: requiredTestsFor(directClassIds, defs, this.now())
+      requiredTests: requiredTestsFor(directClassIds, defs, at)
     });
   }
   claimPersonnel(t) {
@@ -5273,6 +5397,7 @@ function retiredVocabularyIn(line) {
   objectEvent,
   offCalendarAt,
   offCalendarReasonAt,
+  operationsCapabilityOf,
   parseEpc,
   parseIsoDuration,
   partialFitPolicy,
@@ -5300,5 +5425,6 @@ function retiredVocabularyIn(line) {
   validateEpcisEvent,
   validateScenario,
   weekdayAt,
+  workingHoursBetween,
   workingTimeOfWeek
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {