@operato/twin-kernel 0.7.54 → 0.7.55

package/dist/contract.d.ts

@@ -415,12 +415,48 @@ export interface TestSpecificationCriterion {
     /** 표준 `Sequence` — 기준이 여럿일 때의 순서. */
     sequence?: number;
     /**
-     * 표준 `Expression`(`TextType`) — **그 현장의 표기 그대로** 나른다. 커널은 평가하지 않는다.
+     * 표준 `Expression`(`TextType`) — **그 현장의 표기 그대로** 나른다. 커널은 이것을 평가하지 않는다.
      *
-     * 표준에서는 선택이지만 **우리는 요구한다**(좁힘): 표현식이 없는 기준은 아무 한계도 말하지 않으므로
-     * 「기준이 선언됐다」는 착각만 만든다. 선언만 있고 내용이 없는 것을 이 저장소는 거절한다.
+     * 문법이 정의돼 있지 않으므로(자유 문자열) 파싱하면 그 순간 방언이고, 현장 규정과 우리 해석이
+     * 갈리는 날 어느 쪽이 옳은지 아무도 모른다. 사람이 읽는 값이다.
+     *
+     * **`expression` 과 `limit` 중 적어도 하나는 있어야 한다**(§`criterionSaysNothing`) — 둘 다 없는
+     * 기준은 아무 한계도 말하지 않으면서 「기준이 선언됐다」는 착각만 만든다.
+     */
+    expression?: string;
+    /**
+     * **평가 가능한 한계** — 이것이 있으면 커널이 판정할 수 있다.
+     *
+     * ── 이 축은 **표준에 없다. 우리 것이다** (2026-08-24) ──────────────────────
+     * B2MML 일곱 파일(Common · OperationsTest · OperationsPerformance(+Types) · OperationalLocation ·
+     * OperationsEvent · OperationsSchedule · WorkAlert)을 원문으로 훑었고 `Minimum`·`Maximum`·
+     * `Tolerance`·`Range`·`LowerLimit`·`UpperLimit` 이 **하나도 없다.** ISA-95 의 기준은
+     * `Expression`(TextType)과 `Result`(TextType)뿐이고, `ValueType` 도 `ValueString`·`DataType`·
+     * `UnitOfMeasure`·`Key` 넷이다. 즉 표준은 한계를 **사람이 읽는 문장**으로만 담는다.
+     *
+     * 그런데 트윈은 **아무도 판정하지 않을 때 판정해야 한다** — 그것이 이 축의 근거다(당위). 자유 문장
+     * 으로는 그것을 할 수 없다. 그래서 숫자 한계를 우리가 더한다. **더한 것이라고 적어 두는 것**이
+     * 이 저장소의 규율이고(§`TestResult.result` 의 좁힘과 같은 자리), 그러면 다음 사람이 이것을
+     * 「표준이 준 이름」으로 읽지 않는다.
+     *
+     * 실 원본이 이 모양으로 준다는 것이 확인됐다(첫 실 연동: `criticalLimits.{minimum,maximum}`).
+     * **그것이 이 축을 정한 것은 아니다** — 판정이 필요하다는 당위가 정했고, 원본은 그것을 채울 수
+     * 있다는 사실을 확인해 준 것이다.
      */
-    expression: string;
+    limit?: {
+        /** 이 값 미만이면 벗어난다. 없으면 아래쪽 한계가 없다(모르는 것이 아니라 없는 것이다). */
+        minimum?: number;
+        /** 이 값 초과면 벗어난다. */
+        maximum?: number;
+        /**
+         * 한계의 단위 — 표준 `UnitOfMeasure` 와 같은 어휘(UN/CEFACT).
+         *
+         * **없으면 짐작하지 않는다.** 관측도 단위를 말하지 않으면 같은 척도로 보고 비교하고(같은 선언에서
+         * 온 값들이다), **둘이 서로 다른 단위를 말하면 판정하지 않는다** — 섭씨 한계에 화씨 관측을
+         * 견주면 조용히 틀린다.
+         */
+        uom?: string;
+    };
     /** 표준 `Result` — 이 기준이 만족될 때 기대하는 값(현장 표기). */
     result?: string;
     /** 표준 `EvaluatedPropertyID` — 이 기준이 **무엇을 재어** 판정하나. 측정값과 짝을 맞추는 키다. */
@@ -465,6 +501,34 @@ export interface PropertyMeasurement extends StandardValue {
      */
     derived?: boolean;
 }
+/**
+ * **이 기준이 아무 한계도 말하지 않나** — 선언만 있고 내용이 없는 것을 가려낸다.
+ *
+ * 표현식(사람이 읽는 것)도 없고 숫자 한계(커널이 판정하는 것)도 없으면, 그 기준은 「기준이 선언됐다」는
+ * 착각만 만든다. 화면이 「관리점 셋이 걸려 있다」고 말하는데 그중 하나가 아무것도 재지 않는 것은
+ * 이 저장소가 거절하는 모양이다.
+ */
+export declare function criterionSaysNothing(c: Pick<TestSpecificationCriterion, 'expression' | 'limit'>): boolean;
+/**
+ * **이 값이 한계를 벗어났나** — 판정할 수 있을 때만 답한다.
+ *
+ * ── 세 갈래를 가린다 ────────────────────────────────────────────────────────
+ *   `true`       벗어났다
+ *   `false`      한계 안이다
+ *   `undefined`  **판정할 수 없다** — 숫자 한계가 없거나, 값이 수가 아니거나, 단위가 어긋난다
+ *
+ * `undefined` 를 `false` 로 뭉개지 않는 것이 이 함수의 요점이다. 「한계 안이다」와 「판정 못 했다」를
+ * 같은 값으로 답하면 화면이 판정하지 못한 것을 **적합으로** 보여 준다 — 규제 기록에서 그것은 사고다.
+ *
+ * ── 표현식은 읽지 않는다 ────────────────────────────────────────────────────
+ * `expression` 이 있어도 파싱하지 않는다(§`TestSpecificationCriterion.expression`). 숫자 한계가
+ * 없으면 사람이 읽을 문장은 있어도 커널은 「모른다」고 답한다.
+ *
+ * ── 단위가 어긋나면 판정하지 않는다 ─────────────────────────────────────────
+ * 섭씨 한계에 화씨 관측을 견주면 **오류 없이 틀린다.** 둘 다 단위를 말하지 않으면 같은 척도로 본다 —
+ * 같은 선언에서 온 값들이고, 그때 판정을 거부하면 단위를 적지 않는 원본에서 이 축이 영원히 침묵한다.
+ */
+export declare function outsideLimit(criterion: Pick<TestSpecificationCriterion, 'limit'> | undefined, observed: Pick<StandardValue, 'value' | 'uom'> | undefined): boolean | undefined;
 /**
  * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
  *
@@ -944,7 +1008,105 @@ export interface LocationState {
      * 보드에 좌표가 없고 용량이 비어 있어 **계획에 참여하지 못한다**(그 사실을 감추지 않기 위한 표시).
      */
     origin?: 'master' | 'observed';
+    /**
+     * 이 자리에서 관측된 **물리량들의 마지막 값** — 속성마다 하나(§`LocationObservation`).
+     *
+     * 이력이 아니라 **지금 값**이다: 이력은 저널이 든다(그것이 「그때 그 방이 몇 도였나」에 답하는
+     * 자리다). 여기 두는 이유는 판정이 지금 값을 보기 때문이고, 상태가 시간에 비례해 자라지 않게
+     * **속성당 하나**만 든다.
+     *
+     * 없으면 **두지 않는다** — 빈 배열을 두면 「센서가 없는 자리」와 「아직 못 들은 자리」가 같아진다.
+     */
+    observations?: LocationObservation[];
 }
+/**
+ * **자리에서 관측된 물리량 하나** — 냉장실 온도·습도, 세척수 유량 같은 것.
+ *
+ * ── 왜 트윈이 이것을 들어야 하나 (당위) ─────────────────────────────────────
+ * 트윈의 판정 대상은 「물건의 상태」이고, 물건의 상태는 **조건 없이 정해지지 않는다.** 「이 로트가
+ * 냉장실에 있었다」까지만 아는 트윈은 그 로트가 괜찮았는지 말할 수 없다 — 기능 하나가 없는 것이
+ * 아니라 **판정의 재료가 없는 것**이다.
+ *
+ * 그리고 **이 조인은 트윈만 할 수 있다.** 계측 시스템은 물건의 자리 이력을 모르고, 물류 시스템은
+ * 조건 이력을 모른다. 물건이 여러 시스템을 지나면 어느 원본도 전 경로를 모른다.
+ *
+ * ── 주인은 **자리**다. 물건이 아니다 ────────────────────────────────────────
+ * 방 하나의 온도가 그 안의 물건 수백 개와 관계되고, **그 수백 개는 시간에 따라 바뀐다.** 값을 물건마다
+ * 복사하면 한 사실의 사본이 수백 개 생기고 드나드는 물건마다 어긋난다. 그래서 관측은 **자리에 한 번**
+ * 두고, 「그때 그 방에 있던 물건」은 시각∩자리로 파생한다(파생은 저장하지 않는다).
+ *
+ * 진행 중인 공정이 있어도 마찬가지다: 숙성창고에 로트가 여럿이면 숙성 작업도 여럿이고 구간이 각기
+ * 다른데 **센서는 하나**다. 그 값은 어느 한 작업의 것이 아니다.
+ *
+ * ── 표준 근거 — 붙는 자리가 「자리」가 아니라 **설비 계층 노드**다 ────────────
+ * 1차 출처: `OperationsEventType`(`B2MML-OperationsEvent.xsd`) + `OperationsRecordTemplateType`
+ * (`B2MML-Common.xsd`). 붙는 자리는 `HierarchyScope.EquipmentID` 인데, ISA-95 에서는 **장소 계층이
+ * 곧 설비 계층**이다(Enterprise → Site → Area → StorageZone → StorageUnit) — 냉장실은 `StorageZone`
+ * 수준의 설비다. 커널의 자리가 그 노드이므로(§`LocationState.level` 이 `EquipmentLevel1Type` 근거)
+ * `locationId` 가 그대로 대응된다.
+ *
+ * `OperationalLocationType` 에는 이 축이 **없다** — 그쪽은 나중에 들어온 공간(spatial) 개념이고
+ * 마스터 속성만 든다(시계열이 아니다).
+ *
+ * ── 우리가 좁힌 것 ──────────────────────────────────────────────────────────
+ * 표준의 기록 항목은 `InformationObject`(무엇이든)다. **그 임의성을 쓰지 않는다** — 값을 `ValueType`
+ * 으로 좁힌다(§`StandardValue`). 단위 없는 물리량을 받으면 소비처가 3이 섭씨인지 화씨인지 알 수 없고,
+ * 그 상태로는 어떤 판정도 못 한다.
+ */
+export interface LocationObservation extends StandardValue {
+    /** 표준 `HierarchyScope.EquipmentID` — 어느 자리인가. 커널의 자리 id 다. */
+    locationId: string;
+    /**
+     * **무엇을 쟀나** — 속성 식별자. 기준과 짝을 맞추는 키다
+     * (§`TestSpecificationCriterion.evaluatedPropertyId`).
+     *
+     * 어휘는 커널이 정하지 않는다 — 재는 것은 현장이 정한다(온도·습도·유량·중량). 커널은 나르고
+     * 짝만 맞춘다. `OP_PARAM` 과 같은 규율이고, 표준도 파라미터 ID 어휘를 정하지 않는다.
+     */
+    propertyId: string;
+    /**
+     * **언제의 사실인가** — 표준 `EffectiveTimestamp`.
+     *
+     * 관측 시각이지 기록 시각이 아니다. 둘이 어긋나는 것이 실 연동의 정상이고, 그래서 아래를 따로 든다.
+     */
+    effectiveTime: ISOTime;
+    /**
+     * **언제까지의 사실인가** — 표준 `EffectiveEndDate`. 없으면 그 시점 하나의 값이다.
+     *
+     * ── 왜 구간이 필요한가 ────────────────────────────────────────────────────
+     * ① **원본이 시각을 주지 않는 기록이 있다.** 수동 점검 장부는 「그날 아침」처럼 적고 시계를 적지
+     *    않는다(표준도 주기 점검을 전제한다 — `RecurrenceTimeInterval`). 그때 09:00 을 찍으면 **자정을
+     *    지어내는 것과 같은 발명**이다(§ADR-0039 「선언이 있으면 변환이지만 없으면 발명이다」).
+     *    구간으로 적으면 참인 것만 말한다: 그날 아침의 어느 때.
+     * ② **영향 로트를 찾는 데 구간이 필요하다.** 점 하나로는 며칠 머문 로트를 잡지 못한다 — 온도가 튄
+     *    한 시간의 이벤트 목록에는 정작 그 방의 로트가 하나도 없을 수 있다.
+     *
+     * 구간을 **모르는 것**과 **점인 것**은 다르다: 점이면 이 값이 없고, 모르면 넓은 구간으로 적는다.
+     */
+    effectiveEndTime?: ISOTime;
+    /** 언제 적혔나 — 표준 `RecordTimestamp`. 늦게 도착한 옛 관측이 최신을 덮지 않게 하는 재료다. */
+    recordTime?: ISOTime;
+    /** 누가 말했나 — 표준 `Source`. 계측기인지 사람이 적은 장부인지는 이 값이 답한다. */
+    source?: string;
+    /**
+     * 이 값이 **잰 것이 아니라 접은 것**임을 밝힌다 — §`PropertyMeasurement.derived` 와 같은 규율.
+     *
+     * 트윈은 원본이 주지 않는 값을 계산할 수 있다(그것이 존재 이유다). 그러나 실측과 같은 자리에 같은
+     * 모양으로 두면 보고서가 그것을 잰 값으로 읽는다. 규제 기록에서 그 구별이 사라지는 것은 결함이
+     * 아니라 사고다.
+     */
+    derived?: boolean;
+}
+/**
+ * **이 시각에 이 자리에서 참인 관측** — 구간을 든 관측을 시각으로 찾는다.
+ *
+ * 「그때 그 방이 몇 도였나」에 답하는 첫 칸이다. 점 관측은 그 시각에만, 구간 관측은 구간 안에서 참이다.
+ * 여러 개가 겹치면 **가장 늦게 시작한 것**이 답이다(정정이 나중에 온다).
+ *
+ * 커널은 값이 옳은지 **판정하지 않는다** — 기준의 표현식은 문법이 정의되지 않은 자유 문자열이다
+ * (§`TestSpecificationCriterion`). 여기서 하는 일은 짝을 찾아 주는 것까지다.
+ */
+export declare function observationAt(observations: readonly LocationObservation[] | undefined, propertyId: string, at: ISOTime): LocationObservation | undefined;
 /**
  * 물품 상태 — 표준이 담는 것을 담는다(EPCIS 2.0 / TDS).
  *

package/dist/contract.js

@@ -245,6 +245,63 @@ export function meetsTests(required, results, at) {
     }
     return true;
 }
+/**
+ * **이 기준이 아무 한계도 말하지 않나** — 선언만 있고 내용이 없는 것을 가려낸다.
+ *
+ * 표현식(사람이 읽는 것)도 없고 숫자 한계(커널이 판정하는 것)도 없으면, 그 기준은 「기준이 선언됐다」는
+ * 착각만 만든다. 화면이 「관리점 셋이 걸려 있다」고 말하는데 그중 하나가 아무것도 재지 않는 것은
+ * 이 저장소가 거절하는 모양이다.
+ */
+export function criterionSaysNothing(c) {
+    if (c?.expression?.trim())
+        return false;
+    const l = c?.limit;
+    return !(typeof l?.minimum === 'number' || typeof l?.maximum === 'number');
+}
+/**
+ * **이 값이 한계를 벗어났나** — 판정할 수 있을 때만 답한다.
+ *
+ * ── 세 갈래를 가린다 ────────────────────────────────────────────────────────
+ *   `true`       벗어났다
+ *   `false`      한계 안이다
+ *   `undefined`  **판정할 수 없다** — 숫자 한계가 없거나, 값이 수가 아니거나, 단위가 어긋난다
+ *
+ * `undefined` 를 `false` 로 뭉개지 않는 것이 이 함수의 요점이다. 「한계 안이다」와 「판정 못 했다」를
+ * 같은 값으로 답하면 화면이 판정하지 못한 것을 **적합으로** 보여 준다 — 규제 기록에서 그것은 사고다.
+ *
+ * ── 표현식은 읽지 않는다 ────────────────────────────────────────────────────
+ * `expression` 이 있어도 파싱하지 않는다(§`TestSpecificationCriterion.expression`). 숫자 한계가
+ * 없으면 사람이 읽을 문장은 있어도 커널은 「모른다」고 답한다.
+ *
+ * ── 단위가 어긋나면 판정하지 않는다 ─────────────────────────────────────────
+ * 섭씨 한계에 화씨 관측을 견주면 **오류 없이 틀린다.** 둘 다 단위를 말하지 않으면 같은 척도로 본다 —
+ * 같은 선언에서 온 값들이고, 그때 판정을 거부하면 단위를 적지 않는 원본에서 이 축이 영원히 침묵한다.
+ */
+export function outsideLimit(criterion, observed) {
+    const l = criterion?.limit;
+    if (!l)
+        return undefined;
+    const hasMin = typeof l.minimum === 'number';
+    const hasMax = typeof l.maximum === 'number';
+    if (!hasMin && !hasMax)
+        return undefined;
+    const raw = observed?.value;
+    if (raw === undefined || raw === null || String(raw).trim() === '')
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return undefined;
+    /* 단위가 **둘 다 있고 다르면** 판정하지 않는다. 하나만 있거나 둘 다 없으면 같은 척도로 본다. */
+    const lu = l.uom?.trim();
+    const ou = observed?.uom?.trim();
+    if (lu && ou && lu !== ou)
+        return undefined;
+    if (hasMin && n < l.minimum)
+        return true;
+    if (hasMax && n > l.maximum)
+        return true;
+    return false;
+}
 /**
  * **이 판정에 근거가 있나** — 기준과 측정값의 짝을 맞춰 빈 곳을 돌려준다.
  *
@@ -782,6 +839,40 @@ export function capabilityOf(r, ctx) {
         return { available: false, reason: 'working' };
     return { available: true, reason: 'available' };
 }
+/**
+ * **이 시각에 이 자리에서 참인 관측** — 구간을 든 관측을 시각으로 찾는다.
+ *
+ * 「그때 그 방이 몇 도였나」에 답하는 첫 칸이다. 점 관측은 그 시각에만, 구간 관측은 구간 안에서 참이다.
+ * 여러 개가 겹치면 **가장 늦게 시작한 것**이 답이다(정정이 나중에 온다).
+ *
+ * 커널은 값이 옳은지 **판정하지 않는다** — 기준의 표현식은 문법이 정의되지 않은 자유 문자열이다
+ * (§`TestSpecificationCriterion`). 여기서 하는 일은 짝을 찾아 주는 것까지다.
+ */
+export function observationAt(observations, propertyId, at) {
+    const t = parsedMs(at);
+    if (!(t >= 0))
+        return undefined;
+    let best;
+    let bestStart = -1;
+    for (const o of observations ?? []) {
+        if (o.propertyId !== propertyId)
+            continue;
+        const from = parsedMs(o.effectiveTime);
+        if (!(from >= 0) || from > t)
+            continue;
+        /* 구간이 있으면 그 안이어야 한다. 없으면 그 시점의 값이고, 그 뒤로도 정정될 때까지 유효하다. */
+        if (o.effectiveEndTime) {
+            const to = parsedMs(o.effectiveEndTime);
+            if (to >= 0 && to < t)
+                continue;
+        }
+        if (from > bestStart) {
+            best = o;
+            bestStart = from;
+        }
+    }
+    return best;
+}
 // ── 운영 델타(비-EPCIS) — State 채널의 나머지 절반 ──────────────────────────
 // EPCIS 이벤트는 재고/위치만 재구성 가능. tasks·equipment·orders 의 운영 상태는
 // 이 델타로 미러한다. envelope.eventType = 'task.status' | 'equipment.status' | 'order.status'.

package/dist/forecast.d.ts

@@ -22,6 +22,23 @@ export interface MonteCarloResult {
     mean: number;
     p50: number;
     p90: number;
+    /**
+     * **계보를 잇지 못한 채 넘어간 횟수** — 회차들 중 **최대값**(§`StateSnapshot.stepsWithoutMaterial`).
+     *
+     * ── 왜 예측 결과에 실어야 하나 (2026-08-24) ──────────────────────────────────
+     * 미러의 오더는 확보분을 갖지 않는다(원본이 「어느 개체가 잡혀 있나」를 말하지 않는 것이 그 시스템의
+     * 정상이다). 그래서 예측이 공정을 넘을 때 개체를 이을 수 없고, 커널은 **넘기되 세어 둔다.**
+     *
+     * 그런데 예측은 **회차마다 fork 를 만들고 버린다.** 그 카운터가 사본 안에만 있으면 아무에게도 닿지
+     * 않는다 — 이 저장소가 이미 그 실수를 겪었다(리듀서가 오래 세어 온 값을 스냅샷이 떨어뜨려, 그것을
+     * 읽도록 쓰인 검사가 영원히 조용했다). **세어 놓고 내보내지 않으면 안 센 것과 같다.**
+     *
+     * 왜 합이 아니라 최대인가: 회차는 **같은 미래의 표본들**이다. 서른 번 굴려 각 회차가 열 칸을
+     * 비웠으면 사실은 「열 칸」이고 300이 아니다. 합을 내면 회차 수를 늘리는 것만으로 숫자가 커진다.
+     *
+     * 0 이면 **싣지 않는다** — 0 을 정보처럼 보이게 하지 않는다.
+     */
+    stepsWithoutMaterial?: number;
 }
 export interface MonteCarloOptions {
     runs: number;

package/dist/forecast.js

@@ -19,14 +19,17 @@ function clockOf(twin) {
 export function monteCarloForecast(twin, opts) {
     const now = clockOf(twin);
     const samples = [];
+    let gaps = 0;
     for (let i = 0; i < opts.runs; i++) {
         const { fc, step, target } = startRun(twin, opts, now, i);
         let guard = 0;
         while (clockOf(fc) < target && guard++ < 1_000_000)
             fc.tick(step);
-        samples.push(opts.metric(fc.getSnapshot()));
+        const snap = fc.getSnapshot();
+        gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+        samples.push(opts.metric(snap));
     }
-    return summarize(opts.runs, samples);
+    return summarize(opts.runs, samples, gaps);
 }
 /**
  * 한 회차의 **출발점** — fork(현재 보존) + 그 회차의 미래(seed 변주).
@@ -66,6 +69,7 @@ export async function monteCarloForecastAsync(twin, opts) {
      */
     const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
     const samples = [];
+    let gaps = 0;
     for (let i = 0; i < opts.runs; i++) {
         const { fc, step, target } = startRun(twin, opts, now, i);
         let guard = 0;
@@ -77,15 +81,27 @@ export async function monteCarloForecastAsync(twin, opts) {
                 await yieldFn();
             }
         }
-        samples.push(opts.metric(fc.getSnapshot()));
+        const snap = fc.getSnapshot();
+        gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+        samples.push(opts.metric(snap));
         if (i < opts.runs - 1)
             await yieldFn();
     }
-    return summarize(opts.runs, samples);
+    return summarize(opts.runs, samples, gaps);
 }
-function summarize(runs, samples) {
+function summarize(runs, samples, stepsWithoutMaterial = 0) {
     const sorted = [...samples].sort((a, b) => a - b);
     const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
     const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
-    return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+    return {
+        runs,
+        samples,
+        min: sorted[0],
+        max: sorted[sorted.length - 1],
+        mean,
+        p50: pct(0.5),
+        p90: pct(0.9),
+        /* 0 은 싣지 않는다 — 「구멍이 없다」와 「이 축을 모른다」를 화면이 구별할 수 있게. */
+        ...(stepsWithoutMaterial > 0 ? { stepsWithoutMaterial } : {})
+    };
 }

package/dist-cjs/index.cjs

@@ -96,6 +96,7 @@ __export(index_exports, {
   constantDuration: () => constantDuration,
   conversionFactorOf: () => conversionFactorOf,
   counterfactualAt: () => counterfactualAt,
+  criterionSaysNothing: () => criterionSaysNothing,
   demandWindowStart: () => demandWindowStart,
   deriveAttentions: () => deriveAttentions,
   documentPath: () => documentPath,
@@ -142,10 +143,12 @@ __export(index_exports, {
   monteCarloForecastAsync: () => monteCarloForecastAsync,
   objectEvent: () => objectEvent,
   objectUri: () => objectUri,
+  observationAt: () => observationAt,
   offCalendarAt: () => offCalendarAt,
   offCalendarReasonAt: () => offCalendarReasonAt,
   operationalKindOf: () => operationalKindOf,
   operationsCapabilityOf: () => operationsCapabilityOf,
+  outsideLimit: () => outsideLimit,
   parseEpc: () => parseEpc,
   parseIsoDuration: () => parseIsoDuration,
   partialFitPolicy: () => partialFitPolicy,
@@ -290,6 +293,28 @@ function meetsTests(required, results, at) {
   }
   return true;
 }
+function criterionSaysNothing(c) {
+  if (c?.expression?.trim()) return false;
+  const l = c?.limit;
+  return !(typeof l?.minimum === "number" || typeof l?.maximum === "number");
+}
+function outsideLimit(criterion, observed) {
+  const l = criterion?.limit;
+  if (!l) return void 0;
+  const hasMin = typeof l.minimum === "number";
+  const hasMax = typeof l.maximum === "number";
+  if (!hasMin && !hasMax) return void 0;
+  const raw = observed?.value;
+  if (raw === void 0 || raw === null || String(raw).trim() === "") return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return void 0;
+  const lu = l.uom?.trim();
+  const ou = observed?.uom?.trim();
+  if (lu && ou && lu !== ou) return void 0;
+  if (hasMin && n < l.minimum) return true;
+  if (hasMax && n > l.maximum) return true;
+  return false;
+}
 function testEvidenceGaps(spec, result) {
   const criteria = spec?.criteria ?? [];
   const measurements = result?.propertyMeasurements ?? [];
@@ -532,6 +557,26 @@ function capabilityOf(r, ctx) {
   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);
+  if (!(t >= 0)) return void 0;
+  let best;
+  let bestStart = -1;
+  for (const o of observations ?? []) {
+    if (o.propertyId !== propertyId) continue;
+    const from = parsedMs(o.effectiveTime);
+    if (!(from >= 0) || from > t) continue;
+    if (o.effectiveEndTime) {
+      const to = parsedMs(o.effectiveEndTime);
+      if (to >= 0 && to < t) continue;
+    }
+    if (from > bestStart) {
+      best = o;
+      bestStart = from;
+    }
+  }
+  return best;
+}
 var OP_EVENT = {
   task: "task.status",
   equipment: "equipment.status",
@@ -825,13 +870,16 @@ function clockOf2(twin) {
 function monteCarloForecast(twin, opts) {
   const now = clockOf2(twin);
   const samples = [];
+  let gaps = 0;
   for (let i = 0; i < opts.runs; i++) {
     const { fc, step, target } = startRun(twin, opts, now, i);
     let guard = 0;
     while (clockOf2(fc) < target && guard++ < 1e6) fc.tick(step);
-    samples.push(opts.metric(fc.getSnapshot()));
+    const snap = fc.getSnapshot();
+    gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+    samples.push(opts.metric(snap));
   }
-  return summarize(opts.runs, samples);
+  return summarize(opts.runs, samples, gaps);
 }
 function startRun(twin, opts, nowMs, i) {
   const fc = twin.fork();
@@ -844,6 +892,7 @@ async function monteCarloForecastAsync(twin, opts) {
   const yieldFn = opts.yieldFn ?? (() => Promise.resolve());
   const everyTicks = Math.max(1, opts.yieldEveryTicks ?? 50);
   const samples = [];
+  let gaps = 0;
   for (let i = 0; i < opts.runs; i++) {
     const { fc, step, target } = startRun(twin, opts, now, i);
     let guard = 0;
@@ -855,16 +904,28 @@ async function monteCarloForecastAsync(twin, opts) {
         await yieldFn();
       }
     }
-    samples.push(opts.metric(fc.getSnapshot()));
+    const snap = fc.getSnapshot();
+    gaps = Math.max(gaps, snap.stepsWithoutMaterial ?? 0);
+    samples.push(opts.metric(snap));
     if (i < opts.runs - 1) await yieldFn();
   }
-  return summarize(opts.runs, samples);
+  return summarize(opts.runs, samples, gaps);
 }
-function summarize(runs, samples) {
+function summarize(runs, samples, stepsWithoutMaterial = 0) {
   const sorted = [...samples].sort((a, b) => a - b);
   const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
   const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
-  return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+  return {
+    runs,
+    samples,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    mean,
+    p50: pct(0.5),
+    p90: pct(0.9),
+    /* 0 은 싣지 않는다 — 「구멍이 없다」와 「이 축을 모른다」를 화면이 구별할 수 있게. */
+    ...stepsWithoutMaterial > 0 ? { stepsWithoutMaterial } : {}
+  };
 }
 
 // src/twin-observer.ts
@@ -9126,6 +9187,7 @@ function retiredVocabularyIn(line) {
   constantDuration,
   conversionFactorOf,
   counterfactualAt,
+  criterionSaysNothing,
   demandWindowStart,
   deriveAttentions,
   documentPath,
@@ -9172,10 +9234,12 @@ function retiredVocabularyIn(line) {
   monteCarloForecastAsync,
   objectEvent,
   objectUri,
+  observationAt,
   offCalendarAt,
   offCalendarReasonAt,
   operationalKindOf,
   operationsCapabilityOf,
+  outsideLimit,
   parseEpc,
   parseIsoDuration,
   partialFitPolicy,

package/package.json

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