@operato/twin-kernel 0.7.88 → 0.7.90

package/dist/class-master-table.d.ts

@@ -0,0 +1,35 @@
+import type { VocabularyElement } from '@operato/operations-contract';
+/**
+ * 클래스 단위 마스터 표 — 관측 리듀서가 든다.
+ *
+ * 물품은 자리마다 따로 서지만(`클래스@자리`) 이 속성은 **클래스의 것**이다. 그래서 물품마다 복사해
+ * 두지 않고 클래스로 한 번 들고, 물품을 세울 때 본다. 마스터가 관측보다 늦게 와도 값이 서는 이유다.
+ */
+export declare class ClassMasterTable {
+    private byId;
+    /**
+     * 속성을 **합친다** — 덮지 않는다(한 번에 일부만 오는 원본이 있다). 바뀐 식별자를 돌려준다.
+     *
+     * ── 지우는 법 ───────────────────────────────────────────────────────────────
+     * 값에 `null` 을 실으면 **그 속성을 지운다**(「모름으로 되돌린다」). 합치기만 하면 원본에서 지운 값이
+     * 트윈에 영원히 남고, 그것을 표현할 방법이 없으면 「지웠다」와 「이번엔 말하지 않았다」가 같아진다.
+     *
+     * `undefined` 는 지우지 않는다 — 그것은 「이 진술에 그 속성이 없다」이고, 원본이 일부만 보내는
+     * 정상이다. 두 뜻을 갈라 둔다.
+     *
+     * 속성이 하나도 남지 않으면 그 요소를 표에서 버린다(빈 껍데기를 들고 있지 않는다).
+     */
+    merge(elements: readonly VocabularyElement[]): string[];
+    /**
+     * 그 식별자의 항목을 버린다 — **아무도 가리키지 않게 된 뒤**에만 부른다.
+     *
+     * 로트는 계속 새로 생기므로 이 표는 스스로 줄지 않는다. 하루 수백 로트면 1년에 수십만 항목이고,
+     * 그것을 아무도 지우지 않으면 재기동으로만 줄어든다(그리고 중간 저장본이 그만큼 커진다).
+     */
+    forget(id: string): boolean;
+    attributesOf(id: string | undefined): Record<string, unknown> | undefined;
+    get size(): number;
+    serialize(): Record<string, Record<string, unknown>>;
+    restore(saved: unknown): void;
+    clear(): void;
+}

package/dist/class-master-table.js

@@ -0,0 +1,72 @@
+/** 계약의 판정과 같은 것 — 이 파일 안에서만 쓴다(계약이 내보내는 것이 아니다). */
+function isPlainObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * 클래스 단위 마스터 표 — 관측 리듀서가 든다.
+ *
+ * 물품은 자리마다 따로 서지만(`클래스@자리`) 이 속성은 **클래스의 것**이다. 그래서 물품마다 복사해
+ * 두지 않고 클래스로 한 번 들고, 물품을 세울 때 본다. 마스터가 관측보다 늦게 와도 값이 서는 이유다.
+ */
+export class ClassMasterTable {
+    byId = new Map();
+    /**
+     * 속성을 **합친다** — 덮지 않는다(한 번에 일부만 오는 원본이 있다). 바뀐 식별자를 돌려준다.
+     *
+     * ── 지우는 법 ───────────────────────────────────────────────────────────────
+     * 값에 `null` 을 실으면 **그 속성을 지운다**(「모름으로 되돌린다」). 합치기만 하면 원본에서 지운 값이
+     * 트윈에 영원히 남고, 그것을 표현할 방법이 없으면 「지웠다」와 「이번엔 말하지 않았다」가 같아진다.
+     *
+     * `undefined` 는 지우지 않는다 — 그것은 「이 진술에 그 속성이 없다」이고, 원본이 일부만 보내는
+     * 정상이다. 두 뜻을 갈라 둔다.
+     *
+     * 속성이 하나도 남지 않으면 그 요소를 표에서 버린다(빈 껍데기를 들고 있지 않는다).
+     */
+    merge(elements) {
+        const touched = [];
+        for (const e of elements) {
+            const next = { ...(this.byId.get(e.id) ?? {}) };
+            for (const [name, value] of Object.entries(e.attributes)) {
+                if (value === null)
+                    delete next[name];
+                else if (value !== undefined)
+                    next[name] = value;
+            }
+            if (Object.keys(next).length)
+                this.byId.set(e.id, next);
+            else
+                this.byId.delete(e.id);
+            touched.push(e.id);
+        }
+        return touched;
+    }
+    /**
+     * 그 식별자의 항목을 버린다 — **아무도 가리키지 않게 된 뒤**에만 부른다.
+     *
+     * 로트는 계속 새로 생기므로 이 표는 스스로 줄지 않는다. 하루 수백 로트면 1년에 수십만 항목이고,
+     * 그것을 아무도 지우지 않으면 재기동으로만 줄어든다(그리고 중간 저장본이 그만큼 커진다).
+     */
+    forget(id) {
+        return this.byId.delete(id);
+    }
+    attributesOf(id) {
+        return id ? this.byId.get(id) : undefined;
+    }
+    get size() {
+        return this.byId.size;
+    }
+    serialize() {
+        return Object.fromEntries(this.byId);
+    }
+    restore(saved) {
+        this.byId.clear();
+        if (!isPlainObject(saved))
+            return;
+        for (const [id, attrs] of Object.entries(saved))
+            if (isPlainObject(attrs))
+                this.byId.set(id, { ...attrs });
+    }
+    clear() {
+        this.byId.clear();
+    }
+}

package/dist/contract.d.ts

@@ -671,7 +671,27 @@ export type Effectivity = 'not-yet' | 'expired';
  * `at` 를 주지 않으면 **판단하지 않는다**(`undefined`). 모르는 시각으로 폐기를 단정하면, 시각을 안 넘긴
  * 소비처 전부가 자원을 잃는다. 파싱 불가한 시각도 같다 — 짐작해 고치지 않는다.
  */
-export declare function effectivityAt(p: EffectivePeriod | undefined, at?: ISOTime): Effectivity | undefined;
+/**
+ * 끝나는 시각을 **포함하는가** — 축마다 다르다. 규칙은 한 벌이고 규약만 밝힌다.
+ *
+ * ── 왜 이 칸이 생겼나 (2026-08-30) ────────────────────────────────────────
+ * 처음에는 이 판정이 한 곳뿐이었고 끝을 포함했다. 자원에는 그것이 맞다 — 폐기 일자가 있는 지게차는
+ * 띄엄띄엄 있고, 두 자원의 기간이 한 순간을 함께 갖는 일이 문제가 되지 않는다.
+ *
+ * 그런데 **선언은 빈틈없이 이어진다.** 8월 요금 주기가 끝나는 순간이 9월 주기가 시작하는 순간이다.
+ * 끝을 포함하면 그 한 순간에 두 단가가 동시에 유효해지고, 어느 것으로 계산했는지 말할 수 없다.
+ *
+ * 그때 같은 판정을 하는 함수를 하나 더 만들었다. 규칙이 두 벌이 되면 한쪽만 고쳐지는 날이 온다 —
+ * 이 저장소가 오늘 하루 그 부류를 여러 번 고쳤다. 그래서 함수는 하나로 두고 **규약을 인자로** 받는다.
+ */
+export interface EffectivityOptions {
+    /**
+     * `'inclusive'`(기본) — 끝나는 시각까지 유효하다. 자원의 유효 기간이 이쪽이다.
+     * `'exclusive'` — 끝나는 시각은 다음 구간의 것이다. 이어지는 주기(요금·단가)가 이쪽이다.
+     */
+    end?: 'inclusive' | 'exclusive';
+}
+export declare function effectivityAt(p: EffectivePeriod | undefined, at?: ISOTime, opts?: EffectivityOptions): Effectivity | undefined;
 /**
  * 자원 **등급 정의** — ISA-95 가 세 자원에 똑같이 정의한 한 모양.
  *

package/dist/contract.js

@@ -376,17 +376,7 @@ export function judgeAgainstSpec(spec, result) {
     }
     return allJudged ? 'pass' : undefined;
 }
-/**
- * 이 시각에 유효 기간 밖인가 — **한 규칙**으로 개체·등급·설비↔자산 매핑을 모두 판정한다.
- *
- * **표준은 날짜만 정하고 "밖이면 어떻게 되는가" 는 정하지 않는다.** 그 판단은 우리 것이므로 여기 밝힌다:
- * 기간 밖이면 **그 자원은 그 시각의 모델에 참여하지 않는다**(배정되지 않고, 가용 분모에 들지 않는다).
- * 지우지는 않는다 — 이유를 달아 남긴다. 조용히 사라지면 "왜 없어졌나" 를 아무도 답할 수 없다.
- *
- * `at` 를 주지 않으면 **판단하지 않는다**(`undefined`). 모르는 시각으로 폐기를 단정하면, 시각을 안 넘긴
- * 소비처 전부가 자원을 잃는다. 파싱 불가한 시각도 같다 — 짐작해 고치지 않는다.
- */
-export function effectivityAt(p, at) {
+export function effectivityAt(p, at, opts) {
     if (!p || !at)
         return undefined;
     const atMs = parsedMs(at);
@@ -396,7 +386,7 @@ export function effectivityAt(p, at) {
     if (Number.isFinite(from) && atMs < from)
         return 'not-yet';
     const to = p.effectiveEnd ? parsedMs(p.effectiveEnd) : NaN;
-    if (Number.isFinite(to) && atMs > to)
+    if (Number.isFinite(to) && (opts?.end === 'exclusive' ? atMs >= to : atMs > to))
         return 'expired';
     return undefined;
 }

package/dist/counterfactual.d.ts

@@ -1,4 +1,4 @@
-import type { Command, CommandAck, ScenarioControl, StateSnapshot } from './contract.ts';
+import type { Command, CommandAck, ScenarioControl, StateSnapshot } from '@operato/operations-contract';
 import { type StateDivergence } from './divergence.ts';
 /** fork·구동·행위 가능한 트윈(FlowEngine 이 만족). */
 export interface CounterfactualTwin {

package/dist/divergence.d.ts

@@ -1,4 +1,4 @@
-import type { StateSnapshot } from './contract.ts';
+import type { StateSnapshot } from '@operato/operations-contract';
 export interface FieldDiff<T> {
     id: string;
     predicted: T | undefined;

package/dist/divergence.js

@@ -5,7 +5,7 @@
  * 상태를 같은 시점에 비교해 **드리프트(모델과 현실의 이탈)** 를 탐지한다. 발산 = 이상/개입 신호.
  * (fork 로 예측 → 관측으로 실제 → 여기서 대조. execution-model.md 시뮬↔모니터링 커플링.)
  */
-import { itemKeyOf } from "./contract.js";
+import { itemKeyOf } from '@operato/operations-contract';
 function diffBy(predicted, actual, idOf, valOf) {
     const p = new Map(predicted.map(e => [idOf(e), valOf(e)]));
     const a = new Map(actual.map(e => [idOf(e), valOf(e)]));

package/dist/ems-kernel.d.ts

@@ -1,6 +1,6 @@
 import { FlowEngine } from './flow-engine.ts';
 import { type AllocationPolicy } from './allocation-policy.ts';
-import { type CanonicalEnvelope, type DemandWindowState, type EnergyState, type StateSnapshot, type Attention, type StructureShift, type TwinModelDef } from './contract.ts';
+import { type CanonicalEnvelope, type DemandWindowState, type EnergyState, type StateSnapshot, type Attention, type StructureShift, type TwinModelDef } from '@operato/operations-contract';
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export declare const DEMAND_WINDOW_MS: number;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */

package/dist/ems-kernel.js

@@ -27,10 +27,12 @@
  */
 import { FlowEngine } from "./flow-engine.js";
 /* 기간 사실의 이름은 유입 문과 한 규칙이다(§`periodFactId`). */
-import { periodFactId } from "./energy-ingest.js";
+import { periodFactId } from '@operato/operations-contract';
+/* 「이 시각에 유효한가」는 커널에 규칙이 한 벌이다 — 선언 축도 그것을 쓴다. */
+import { effectivityAt } from '@operato/operations-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
-import { CMD, ENERGY_EVENT, minuteOfDayAt, localDayIndexAt, localDayStartMs } from "./contract.js";
-import { EMS_PROPERTY, METER_DIRECTION, electricalUpstreamOf, generationFractionAt } from "./ems-profile.js";
+import { CMD, ENERGY_EVENT, minuteOfDayAt, localDayIndexAt, localDayStartMs } from '@operato/operations-contract';
+import { EMS_PROPERTY, METER_DIRECTION, electricalUpstreamOf, generationFractionAt } from '@operato/operations-contract';
 /** 수요 구간 — 요금의 알갱이다. 15분은 한국·다수 요금제의 최대수요 산정 단위다. */
 export const DEMAND_WINDOW_MS = 15 * 60 * 1000;
 /** 그 시각이 속한 구간의 시작 — 벽시계 경계(00·15·30·45분)에 맞춘다. */
@@ -1749,22 +1751,30 @@ function putDeclaration(list, d) {
     return next.length > 24 ? next.slice(next.length - 24) : next;
 }
 /**
- * **이 시각에 유효한 선언** — 시작했고 아직 끝나지 않은 것.
+ * **이 시각에 유효한 선언** — 판정은 커널의 한 규칙이 한다(§`effectivityAt`).
+ *
+ * 여기서 하는 일은 **고르는 것**뿐이다. 「유효한가」를 여기서 다시 판정하면 규칙이 두 벌이 되고,
+ * 한쪽만 고쳐지는 날이 온다. 실제로 이 함수는 처음에 자기 판정을 들고 있었다.
+ *
+ * 선언은 **빈틈없이 이어진다** — 8월 주기가 끝나는 순간이 9월 주기가 시작하는 순간이다. 그래서 끝을
+ * 포함하지 않는다(`end: 'exclusive'`). 포함하면 그 한 순간에 두 단가가 동시에 유효해진다.
  *
  * 유효한 것이 없으면 답하지 않는다. 가장 가까운 것을 골라 주지 않는다 — 아직 시작하지 않은 단가로
- * 오늘을 계산하거나, 이미 끝난 단가를 지금 것인 양 쓰게 된다. 둘 다 오류 없이 틀린 값을 만든다.
+ * 오늘을 계산하거나 이미 끝난 단가를 지금 것인 양 쓰게 된다. 둘 다 오류 없이 틀린 값을 만든다.
  *
  * 구간이 겹치면 **나중에 시작한 것**이 이긴다(더 좁게 정한 선언이 앞선다).
  */
 function inEffectAt(list, atMs) {
+    if (!list?.length)
+        return undefined;
+    const at = new Date(atMs).toISOString();
     let best;
     let bestFrom = -Infinity;
-    for (const d of list ?? []) {
-        const from = Date.parse(String(d.from));
-        const to = Date.parse(String(d.to));
-        if (!Number.isFinite(from) || !Number.isFinite(to))
+    for (const d of list) {
+        if (effectivityAt({ effectiveStart: d.from, effectiveEnd: d.to }, at, { end: 'exclusive' }) !== undefined)
             continue;
-        if (atMs < from || atMs >= to)
+        const from = Date.parse(String(d.from));
+        if (!Number.isFinite(from))
             continue;
         if (from > bestFrom) {
             best = d;

package/dist/event-journal.d.ts

@@ -1,4 +1,4 @@
-import type { TwinModelDef, CanonicalEnvelope, StructureShift } from './contract.ts';
+import type { TwinModelDef, CanonicalEnvelope, StructureShift } from '@operato/operations-contract';
 import { type ProjectedState, type ReducerCheckpoint } from './state-projector.ts';
 /** 저장된 기록을 처리할 것 — 도메인 커널 또는 `StateProjector`. 계약은 넷뿐이다. */
 export interface JournalProjector {

package/dist/flow-engine.d.ts

@@ -1,12 +1,12 @@
-import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, TaskStatus, StructureShift, IdentityGroundingView, IdentityDeclaration, TestSpecificationCriterion, LocationObservation } from './contract.ts';
-import type { VocabularyElement } from './master-data.ts';
+import type { TestResult, ISOTime, MaterialQuantity, WorkCalendarEntry, EffectivePeriod, Effectivity, OffCalendarReason, ResourceProperty, ResourceClassDef, MaterialDefinition, Attention, TwinModelDef, CanonicalEnvelope, Command, CommandAck, EventHandler, EquipmentMotion, OeeMetrics, AssetState, GeneratorSpec, InterventionOutcome, OrderState, PersonState, ScenarioControl, ScenarioOverride, StateSnapshot, TwinKernel, Unsubscribe, LocationState, ItemState, EquipmentState, OrderStatusDelta, TaskState, TaskStatus, StructureShift, IdentityGroundingView, IdentityDeclaration, TestSpecificationCriterion, LocationObservation } from '@operato/operations-contract';
+import type { VocabularyElement } from '@operato/operations-contract';
 import type { ReducerCheckpoint } from './observed-reducer.ts';
-import type { EpcisEvent, BizTransactionElement } from './epcis.ts';
+import type { EpcisEvent, BizTransactionElement } from '@operato/operations-contract';
 import type { AllocationPolicy, SlotView } from './allocation-policy.ts';
 import type { DurationEstimator, DurationContext } from './duration-estimator.ts';
-import type { OperationDef, IsoDuration, OpMaterialSpecification } from './domain-definition.ts';
-import { type CapacityAnalysis } from './capacity.ts';
-import { type CommittedDemand, type OperationsCapabilityReport } from './operations-capability.ts';
+import type { OperationDef, IsoDuration, OpMaterialSpecification } from '@operato/operations-contract';
+import { type CapacityAnalysis } from '@operato/operations-contract';
+import { type CommittedDemand, type OperationsCapabilityReport } from '@operato/operations-contract';
 export interface FlowLocation {
     id: string;
     type: string;

package/dist/flow-engine.js

@@ -9,17 +9,17 @@
  * 통합 타입은 도메인 필드를 옵셔널로 넓혀(FlowItem.gtin?, FlowOrder.shipmentEpc? 등) 두 도메인을 담는다.
  * (roadmap Phase5 발견 → 추출. [[project_flow_single_base_vision]] FlowLocation 단일 base 방향과 정합.)
  */
-import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf, outsideLimit } from "./contract.js";
+import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf, outsideLimit } from '@operato/operations-contract';
 import { ObservedReducer } from "./observed-reducer.js";
 /* 주체를 정하는 규칙은 유입 문과 한 벌이다 — 두 곳에 적으면 한쪽만 고쳐진다. */
-import { resolveSubject } from "./energy-ingest.js";
-import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri, gdtiUri } from "./epcis.js";
-import { OP_PARAM } from "./domain-definition.js";
-import { parseIsoDuration } from "./iso-duration.js";
-import { analyzeCapacity } from "./capacity.js";
-import { operationsCapabilityOf } from "./operations-capability.js";
+import { resolveSubject } from '@operato/operations-contract';
+import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri, gdtiUri } from '@operato/operations-contract';
+import { OP_PARAM } from '@operato/operations-contract';
+import { parseIsoDuration } from '@operato/operations-contract';
+import { analyzeCapacity } from '@operato/operations-contract';
+import { operationsCapabilityOf } from '@operato/operations-contract';
 /* 에너지 상태 필드는 **능력 선언에서 뽑는다** — 손으로 적으면 능력에 필드를 더한 날 스냅샷이 빠진다. */
-import { stateFieldsOf } from "./capability.js";
+import { stateFieldsOf } from '@operato/operations-contract';
 const BASE_EPOCH = Date.parse('2026-01-01T00:00:00Z');
 /**
  * 선언한 유효 기간만 뽑는다 — 마스터가 말하지 않으면 필드를 만들지 않는다.

package/dist/forecast.d.ts

@@ -1,4 +1,4 @@
-import type { ScenarioControl, ScenarioDef, StateSnapshot } from './contract.ts';
+import type { ScenarioControl, ScenarioDef, StateSnapshot } from '@operato/operations-contract';
 /** fork·시나리오 구동 가능한 트윈(FlowEngine 이 만족). */
 export interface ForecastTwin {
     getSnapshot(): StateSnapshot;

package/dist/index.d.ts

@@ -1,39 +1,40 @@
-export * from './contract.ts';
-export * from './scenario-validate.ts';
-export * from './domain-definition.ts';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from './counterfactual.ts';
 export * from './forecast.ts';
 export * from './twin-observer.ts';
 export * from './event-journal.ts';
-export * from './master-data.ts';
+export * from '@operato/operations-contract';
 export * from './divergence.ts';
-export * from './epcis.ts';
-export * from './wms-profile.ts';
-export * from './ems-profile.ts';
-export * from './capability.ts';
-export * from './domain-catalog.ts';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from './allocation-policy.ts';
 export * from './duration-estimator.ts';
-export * from './iso-duration.ts';
+export * from '@operato/operations-contract';
 export * from './observed-reducer.ts';
 export * from './state-projector.ts';
 export * from './task-fold.ts';
 export * from './job-response.ts';
-export * from './face2-adapter.ts';
+export * from '@operato/operations-contract';
 export * from './runtime.ts';
-export * from './yms-profile.ts';
-export * from './mes-profile.ts';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from './flow-engine.ts';
-export * from './capacity.ts';
-export * from './operations-capability.ts';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export { WmsKernel } from './kernel.ts';
 export { YmsKernel } from './yms-kernel.ts';
 export { MesKernel } from './mes-kernel.ts';
 export { EmsKernel, DEMAND_WINDOW_MS, demandWindowStart } from './ems-kernel.ts';
-export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from './energy-ingest.ts';
-export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from './operational-ingest.ts';
-export type { OperationalKind, OperationalRecord, OperationalIngestOptions } from './operational-ingest.ts';
+export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from '@operato/operations-contract';
+export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from '@operato/operations-contract';
+export type { OperationalKind, OperationalRecord, OperationalIngestOptions } from '@operato/operations-contract';
 export { attributeEnergy, electricityCost, energyIntensity, energyOfWindows } from './energy-attribution.ts';
 export type { AttributionBasis, AttributionResult, ElectricityCost, EnergyConsumer, EnergyPool, EnergyShare, IntensityInput, IntensityResult, IntensityDenominator, TariffDeclaration, WeightKind, WindowedEnergy } from './energy-attribution.ts';
-export type { EnergyRecord, EnergyEquipmentRecord, EnergyGenerationRecord, EnergyUsagePeriodRecord, EnergyBillRecord, EnergyTariffBasisRecord, EnergyGenerationPriceRecord, EnergyGenerationPeriodRecord, EnergyIngestOptions, EnergyIngestResult } from './energy-ingest.ts';
-export * from './vocabulary.ts';
+export type { EnergyRecord, EnergyEquipmentRecord, EnergyGenerationRecord, EnergyUsagePeriodRecord, EnergyBillRecord, EnergyTariffBasisRecord, EnergyGenerationPriceRecord, EnergyGenerationPeriodRecord, EnergyIngestOptions, EnergyIngestResult } from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export { ClassMasterTable } from './class-master-table.ts';

package/dist/index.js

@@ -1,38 +1,39 @@
-export * from "./contract.js";
-export * from "./scenario-validate.js";
-export * from "./domain-definition.js";
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from "./counterfactual.js";
 export * from "./forecast.js";
 export * from "./twin-observer.js";
 export * from "./event-journal.js";
-export * from "./master-data.js";
+export * from '@operato/operations-contract';
 export * from "./divergence.js";
-export * from "./epcis.js";
-export * from "./wms-profile.js";
-export * from "./ems-profile.js";
-export * from "./capability.js";
-export * from "./domain-catalog.js";
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from "./allocation-policy.js";
 export * from "./duration-estimator.js";
-export * from "./iso-duration.js";
+export * from '@operato/operations-contract';
 export * from "./observed-reducer.js";
 export * from "./state-projector.js";
 export * from "./task-fold.js";
 export * from "./job-response.js";
-export * from "./face2-adapter.js";
+export * from '@operato/operations-contract';
 export * from "./runtime.js";
-export * from "./yms-profile.js";
-export * from "./mes-profile.js";
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export * from "./flow-engine.js";
-export * from "./capacity.js";
-export * from "./operations-capability.js";
+export * from '@operato/operations-contract';
+export * from '@operato/operations-contract';
 export { WmsKernel } from "./kernel.js";
 export { YmsKernel } from "./yms-kernel.js";
 export { MesKernel } from "./mes-kernel.js";
 export { EmsKernel, DEMAND_WINDOW_MS, demandWindowStart } from "./ems-kernel.js";
-export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from "./energy-ingest.js";
+export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from '@operato/operations-contract';
 /* 운영 사실의 문 — 리듀서가 다루는 여섯이 들어오는 자리(미러가 시뮬보다 가난하지 않게). */
-export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from "./operational-ingest.js";
+export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from '@operato/operations-contract';
 export { attributeEnergy, electricityCost, energyIntensity, energyOfWindows } from "./energy-attribution.js";
 /* 에너지 상태 타입은 **계약**에 있다(상태의 모양은 계약이다) — contract 의 `export *` 가 이미 낸다. */
-export * from "./vocabulary.js";
+export * from '@operato/operations-contract';
+export { ClassMasterTable } from "./class-master-table.js";

package/dist/job-response.d.ts

@@ -1,4 +1,4 @@
-import type { ISOTime } from './contract.ts';
+import type { ISOTime } from '@operato/operations-contract';
 import { type TaskDeltaRow } from './task-fold.ts';
 /** 표준 `JobState` — 우리 작업 상태를 표준 낱말로 옮긴다. */
 export type JobState = 'ready' | 'running' | 'completed';

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { Command, CommandAck, GeneratorSpec } from './contract.ts';
+import type { Command, CommandAck, GeneratorSpec } from '@operato/operations-contract';
 import type { AllocationPolicy } from './allocation-policy.ts';
 import { FlowEngine } from './flow-engine.ts';
 import type { FlowOrder, FlowTask } from './flow-engine.ts';

package/dist/kernel.js

@@ -5,13 +5,13 @@
  * 입고: 도착 → receiving(Txn PO + Agg 팔레트←케이스 + Object) → putaway → storing.
  * 출고: SO 오더 → 할당(Txn SO) → pick(bin→staging) → picking → packing(Agg 화물←팔레트) → staging → shipping(DELETE).
  */
-import { CMD } from "./contract.js";
+import { CMD } from '@operato/operations-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
 import { FlowEngine } from "./flow-engine.js";
 import { planMakeToOrder } from "./make-to-order.js";
-import { BIZSTEP, BTT } from "./wms-profile.js";
-import { DISP, ILMD_ATTR, aggregationEvent, objectEvent, transactionEvent } from "./epcis.js";
-import { subLotIdOf, itemKeyOf } from "./contract.js";
+import { BIZSTEP, BTT } from '@operato/operations-contract';
+import { DISP, ILMD_ATTR, aggregationEvent, objectEvent, transactionEvent } from '@operato/operations-contract';
+import { subLotIdOf, itemKeyOf } from '@operato/operations-contract';
 const TRAVEL_MS = 30_000;
 const SHELF_MS = 30 * 24 * 3_600_000; // 기본 유통기한(30일)
 const SHELF_JITTER_MS = 5 * 24 * 3_600_000; // 로트별 만료 편차(FEFO 가 FIFO 와 갈리게)

package/dist/make-to-order.d.ts

@@ -1,4 +1,4 @@
-import type { OperationDef } from './domain-definition.ts';
+import type { OperationDef } from '@operato/operations-contract';
 /** 이 판단이 보는 재고 한 줄 — 무엇이 어디에 얼마나, 팔 수 있나. */
 export interface StockLine {
     /** 품목 식별자(GTIN). */

package/dist/mes-kernel.d.ts

@@ -1,8 +1,8 @@
-import type { GeneratorSpec, Command, CommandAck, ProductionSpec, TwinModelDef, IdentityGroundingView, Attention } from './contract.ts';
+import type { GeneratorSpec, Command, CommandAck, ProductionSpec, TwinModelDef, IdentityGroundingView, Attention } from '@operato/operations-contract';
 import type { AllocationPolicy } from './allocation-policy.ts';
 import { FlowEngine } from './flow-engine.ts';
 import type { FlowOrder, FlowTask } from './flow-engine.ts';
-import { type OpMaterialSpecification } from './domain-definition.ts';
+import { type OpMaterialSpecification } from '@operato/operations-contract';
 export declare class MesKernel extends FlowEngine {
     private wipSeq;
     private prodSeq;
@@ -60,7 +60,7 @@ export declare class MesKernel extends FlowEngine {
      * 모델 자리(§`TwinModelDef.identity`)로 옮기면 이 override 는 사라진다. 두 자리를 동시에 읽는 것이
      * 아니라 **하나를 고르는** 것이므로 규칙이 갈리지 않는다.
      */
-    protected identityDeclaration(): import("./contract.ts").IdentityDeclaration | undefined;
+    protected identityDeclaration(): import("@operato/operations-contract").IdentityDeclaration | undefined;
     protected identityGroundingView(): IdentityGroundingView;
     /**
      * 선언이 말하는 자리 타입이 **이 트윈에 있나** — 로드 시점에 한 번, 모아서 말한다 (2026-08-20).

package/dist/mes-kernel.js

@@ -8,12 +8,12 @@
  *  ③ 셋업/체인지오버 = work-center 가 제품 전환 시 셋업(changeoverKey=제품 gtin) → OEE Availability.
  *  ④ OEE = base 가 설비(설비)별 계측(가동/셋업/기아/품질). cut=cutter·weld=welder 이종 자원.
  */
-import { identityGroundingOf } from "./contract.js";
+import { identityGroundingOf } from '@operato/operations-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
 import { FlowEngine } from "./flow-engine.js";
-import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass, bizTransactionUri } from "./epcis.js";
-import { MES_BIZSTEP, BTT_PRODORDER, sgtinUri } from "./mes-profile.js";
-import { OP_PARAM } from "./domain-definition.js";
+import { DISP, objectEvent, transactionEvent, gdtiUri, sgtinClass, bizTransactionUri } from '@operato/operations-contract';
+import { MES_BIZSTEP, BTT_PRODORDER, sgtinUri } from '@operato/operations-contract';
+import { OP_PARAM } from '@operato/operations-contract';
 /* 아래 셋은 **기본값**이다 — 명세(OperationDef.duration·parameters)가 있으면 그 값이 이긴다.
  * 이름에 DEFAULT 를 붙인 이유: 예전에는 이것이 유일한 값이어서 "현장 명세" 와 구별되지 않았고,
  * 그 상수가 수율 판단(주목 신호)까지 만들어 냈다. 무엇을 기본값으로 굴렸는지는 specCoverage() 가 밝힌다. */

package/dist/observed-reducer.d.ts

@@ -1,5 +1,5 @@
-import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift } from './contract.ts';
-import { type VocabularyElement } from './master-data.ts';
+import type { AssetState, TestResult, MaterialQuantity, TwinModelDef, CanonicalEnvelope, LocationState, ItemState, LocationObservation, EquipmentState, PersonState, TaskState, OrderState, StructureShift } from '@operato/operations-contract';
+import { type VocabularyElement } from '@operato/operations-contract';
 interface ProjItem {
     epc: string;
     /** 로트의 부분(표준 MaterialSubLot.ID) — 비직렬 로트가 자리마다 갈릴 때만. */

package/dist/observed-reducer.js

@@ -19,9 +19,11 @@
  *  - 운영 델타(task/equipment/order.status) → tasks·equipment·orders (EPCIS 로 재구성 불가한 절반)
  * 마스터(로케이션)는 board 초기화 + applyMaster 로 갱신(마스터 동기).
  */
-import { OP_EVENT, capabilityOf, itemKeyOf, judgeAgainstSpec, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from "./contract.js";
-import { ILMD_ATTR, parseEpc } from "./epcis.js";
-import { ClassMasterTable, expiryFromAttributes, lotFromAttributes } from "./master-data.js";
+import { OP_EVENT, capabilityOf, itemKeyOf, judgeAgainstSpec, requiredTestsFor, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, effectivityAt, offCalendarAt, offCalendarReasonAt, activeShiftAt } from '@operato/operations-contract';
+import { ILMD_ATTR, parseEpc } from '@operato/operations-contract';
+import { expiryFromAttributes, lotFromAttributes } from '@operato/operations-contract';
+/* 클래스 마스터 표는 상태를 들므로 커널에 있다(§`class-master-table`). */
+import { ClassMasterTable } from "./class-master-table.js";
 /**
  * 투영이 들고 있는 물품 — **계약(ItemState)을 축소하지 않는다.**
  *

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { CanonicalEnvelope, Command, CommandAck, ScenarioControl, StateSnapshot, TwinKernel } from './contract.ts';
+import type { CanonicalEnvelope, Command, CommandAck, ScenarioControl, StateSnapshot, TwinKernel } from '@operato/operations-contract';
 export type SubscriptionMessage = {
     kind: 'snapshot';
     revision: number;

package/dist/task-fold.d.ts

@@ -1,4 +1,4 @@
-import type { TaskStatusDelta } from './contract.ts';
+import type { TaskStatusDelta } from '@operato/operations-contract';
 /**
  * 되읽을 저널 한 줄 — 필요한 것만.
  *

package/dist/twin-observer.d.ts

@@ -1,4 +1,4 @@
-import type { StateSnapshot } from './contract.ts';
+import type { StateSnapshot } from '@operato/operations-contract';
 import { type StateDivergence } from './divergence.ts';
 /** 관찰 대상 = fork 가능한 트윈(FlowEngine 이 만족). */
 export interface ObservableTwin {

package/dist/yms-kernel.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorSpec } from './contract.ts';
+import type { GeneratorSpec } from '@operato/operations-contract';
 import type { AllocationPolicy } from './allocation-policy.ts';
 import { FlowEngine } from './flow-engine.ts';
 import type { FlowOrder, FlowTask } from './flow-engine.ts';

package/dist/yms-kernel.js

@@ -15,11 +15,11 @@
  *   - drop(기본): 트레일러를 야드 슬롯에 내려놓고(주차) 창 도래 시 호슬러가 도크로 pull. 야드 버퍼 사용.
  *   - live: 게이트에서 대기하다 창 도래 시 도크로 직행(야드 미경유). 게이트/도크를 더 오래 점유.
  */
-import { itemKeyOf } from "./contract.js";
+import { itemKeyOf } from '@operato/operations-contract';
 import { firstFitPolicy } from "./allocation-policy.js";
 import { FlowEngine } from "./flow-engine.js";
-import { DISP, objectEvent, transactionEvent } from "./epcis.js";
-import { YARD_BIZSTEP, BTT_DELIVERY } from "./yms-profile.js";
+import { DISP, objectEvent, transactionEvent } from '@operato/operations-contract';
+import { YARD_BIZSTEP, BTT_DELIVERY } from '@operato/operations-contract';
 const TRAVEL_MS = 20_000; // 야드 이동
 const DWELL_MS = 30_000; // 도크 체류(상·하차) — depart 이동에 folded
 const WINDOW_DELAY_MS = 40_000; // 도착 후 어포인트먼트 창까지(early arrival → 대기)