@operato/twin-kernel 0.7.87 → 0.7.89

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 가 세 자원에 똑같이 정의한 한 모양.
  *
@@ -2041,6 +2061,19 @@ export interface EnergyState {
      * 청구서보다 이쪽이 먼저다: 청구서는 끝난 기간의 정산이고 이것은 지금 적용되는 값이다.
      */
     tariffBasis?: EnergyTariffBasisData;
+    /**
+     * **선언된 요금 기준들** — 유효 구간별. `tariffBasis` 는 이 중 지금 유효한 것이다.
+     *
+     * ── 왜 여럿을 드나 (2026-08-30) ──────────────────────────────────────────
+     * 선언은 **예정될 수 있다.** 한전은 다음 달 요금을 미리 공표한다. 하나만 들면 9월 선언이 들어오는
+     * 순간 8월 선언을 덮어써서 **오늘 요금이 다음 달 단가로 계산된다.** 오류는 나지 않는다.
+     *
+     * 처음에는 예정된 선언을 유입에서 거부해 이 상황을 막았다. 그것은 정상적인 사실을 막는 것이라,
+     * 담을 자리를 만들고 거부를 풀었다.
+     *
+     * 고르는 규칙은 **커널에 한 벌만 둔다.** 읽는 쪽이 각자 고르면 화면마다 다른 요금이 나온다.
+     */
+    tariffBasisSchedule?: EnergyTariffBasisData[];
     /**
      * 이 트윈의 **발전 정격**과 그 근거 — 이용률의 분모(§ `generationRated`).
      *
@@ -2056,8 +2089,12 @@ export interface EnergyState {
      * 마지막으로 받은 **발전 단가** — 이 기간에 낸 전기 1kWh 의 값.
      *
      * 창 밖의 단가도 이 창에 적용될 수 있어(단가는 기간마다 정해진다) 상태로 이어 간다.
+     *
+     * 예정된 단가는 `generationPriceSchedule` 에 함께 든다 — 이 칸은 **지금 유효한 것**이다.
      */
     generationPrice?: EnergyGenerationPriceData;
+    /** **선언된 발전 단가들** — 유효 구간별. 예정된 것을 담는다(§`tariffBasisSchedule`). */
+    generationPriceSchedule?: EnergyGenerationPriceData[];
     /**
      * 이 청구 주기의 **최고 수요** — 기본요금이 이 값으로 다시 정해진다.
      *

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/ems-kernel.d.ts

@@ -133,6 +133,13 @@ export declare class EmsKernel extends FlowEngine {
      * 새것을 쓴다 — 사업자가 그 주기의 기준을 고칠 수 있다.
      */
     private applyTariffBasis;
+    /**
+     * 시계가 선언의 경계를 넘으면 **지금 유효한 선언이 바뀐다.**
+     *
+     * 표본이 들어올 때만 다시 고르면, 9월 1일 0시에 단가가 바뀌었는데 다음 표본이 올 때까지 8월 단가로
+     * 계산한다. 태양광은 밤에 표본이 없어 그 간격이 길다.
+     */
+    protected refreshDeclarationsInEffect(nowMs: number): void;
     /**
      * 청구서를 상태에 둔다 — **우리 계산을 덮지 않는다.**
      *
@@ -221,8 +228,12 @@ export declare class EmsKernel extends FlowEngine {
     private lastBill?;
     /** 마지막으로 받은 요금 기준 — 이 주기에 적용되는 요금적용전력과 단가. */
     private tariffBasis?;
+    /** 선언된 요금 기준들 — 예정된 것을 포함한다(§`EnergyState.tariffBasisSchedule`). */
+    private tariffBasisSchedule?;
     /** 마지막으로 받은 발전 단가 — 이 기간에 낸 전기 1kWh 의 값. */
     private generationPrice?;
+    /** 선언된 발전 단가들 — 예정된 것을 포함한다. */
+    private generationPriceSchedule?;
     /**
      * 이 청구 주기의 **최고 수요** — 기본요금이 이 값으로 다시 정해진다.
      *

package/dist/ems-kernel.js

@@ -28,6 +28,8 @@
 import { FlowEngine } from "./flow-engine.js";
 /* 기간 사실의 이름은 유입 문과 한 규칙이다(§`periodFactId`). */
 import { periodFactId } from "./energy-ingest.js";
+/* 「이 시각에 유효한가」는 커널에 규칙이 한 벌이다 — 선언 축도 그것을 쓴다. */
+import { effectivityAt } from "./contract.js";
 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";
@@ -354,13 +356,8 @@ export class EmsKernel extends FlowEngine {
         const d = envelope.data;
         if (!d?.from || !d?.to)
             return;
-        const fromMs = Date.parse(String(d.from));
-        if (!Number.isFinite(fromMs))
-            return;
-        const priorFromMs = Date.parse(String(this.generationPrice?.from ?? ''));
-        if (Number.isFinite(priorFromMs) && fromMs < priorFromMs)
-            return;
-        this.generationPrice = { ...d };
+        this.generationPriceSchedule = putDeclaration(this.generationPriceSchedule, d);
+        this.generationPrice = inEffectAt(this.generationPriceSchedule, this.nowMs());
         this.revision++;
     }
     /**
@@ -373,15 +370,25 @@ export class EmsKernel extends FlowEngine {
         const d = envelope.data;
         if (!d?.from || !d?.to)
             return;
-        const fromMs = Date.parse(String(d.from));
-        if (!Number.isFinite(fromMs))
-            return;
-        const priorFromMs = Date.parse(String(this.tariffBasis?.from ?? ''));
-        if (Number.isFinite(priorFromMs) && fromMs < priorFromMs)
-            return;
-        this.tariffBasis = { ...d };
+        this.tariffBasisSchedule = putDeclaration(this.tariffBasisSchedule, d);
+        this.tariffBasis = inEffectAt(this.tariffBasisSchedule, this.nowMs());
         this.revision++;
     }
+    /**
+     * 시계가 선언의 경계를 넘으면 **지금 유효한 선언이 바뀐다.**
+     *
+     * 표본이 들어올 때만 다시 고르면, 9월 1일 0시에 단가가 바뀌었는데 다음 표본이 올 때까지 8월 단가로
+     * 계산한다. 태양광은 밤에 표본이 없어 그 간격이 길다.
+     */
+    refreshDeclarationsInEffect(nowMs) {
+        const tariff = inEffectAt(this.tariffBasisSchedule, nowMs);
+        const price = inEffectAt(this.generationPriceSchedule, nowMs);
+        if (tariff !== this.tariffBasis || price !== this.generationPrice) {
+            this.tariffBasis = tariff;
+            this.generationPrice = price;
+            this.revision++;
+        }
+    }
     /**
      * 청구서를 상태에 둔다 — **우리 계산을 덮지 않는다.**
      *
@@ -713,8 +720,12 @@ export class EmsKernel extends FlowEngine {
     lastBill;
     /** 마지막으로 받은 요금 기준 — 이 주기에 적용되는 요금적용전력과 단가. */
     tariffBasis;
+    /** 선언된 요금 기준들 — 예정된 것을 포함한다(§`EnergyState.tariffBasisSchedule`). */
+    tariffBasisSchedule;
     /** 마지막으로 받은 발전 단가 — 이 기간에 낸 전기 1kWh 의 값. */
     generationPrice;
+    /** 선언된 발전 단가들 — 예정된 것을 포함한다. */
+    generationPriceSchedule;
     /**
      * 이 청구 주기의 **최고 수요** — 기본요금이 이 값으로 다시 정해진다.
      *
@@ -1599,6 +1610,8 @@ export class EmsKernel extends FlowEngine {
          * 계량은 이미 시계로 마감한다(`closeDue`). 한 커널 안에서 규칙이 두 벌일 이유가 없다.
          */
         this.closeGenerationPeriodsDue(at);
+        /* 시계가 선언의 경계를 넘으면 지금 유효한 선언이 바뀐다 — 표본을 기다리지 않는다. */
+        this.refreshDeclarationsInEffect(at);
         /* 틱 길이를 함께 넘긴다 — 방전량을 에너지로 바꿀 때 필요하다(필드로 숨기면 어디서 온 값인지 흐려진다). */
         this.deriveLoad(at, dtMs);
         this.closeDue(at);
@@ -1657,10 +1670,21 @@ export class EmsKernel extends FlowEngine {
         /* 청구서도 이어받는다 — 재기동마다 사라지면 우리 계산과 견줄 기준이 없어진다. */
         if (e.lastBill?.from && e.lastBill?.to)
             this.lastBill = { ...e.lastBill };
+        /*
+         * 선언은 **목록째** 이어받는다 — 예정된 것이 사라지면 재기동 뒤에 시행일이 와도 옛 단가를 쓴다.
+         * 이어받은 뒤 지금 시각으로 다시 고른다: 멈춰 있는 동안 시행일이 지났을 수 있다.
+         */
+        if (Array.isArray(e.tariffBasisSchedule))
+            this.tariffBasisSchedule = e.tariffBasisSchedule.map(d => ({ ...d }));
+        if (Array.isArray(e.generationPriceSchedule))
+            this.generationPriceSchedule = e.generationPriceSchedule.map(d => ({ ...d }));
         if (e.tariffBasis?.from && e.tariffBasis?.to)
             this.tariffBasis = { ...e.tariffBasis };
         if (e.generationPrice?.from && e.generationPrice?.to)
             this.generationPrice = { ...e.generationPrice };
+        if (this.tariffBasisSchedule?.length || this.generationPriceSchedule?.length) {
+            this.refreshDeclarationsInEffect(this.nowMs());
+        }
         /* 이 주기의 최고도 이어받는다 — 재기동마다 0 으로 돌아가면 이미 넘은 것을 못 넘었다고 말한다. */
         if (Number.isFinite(Number(e.demandHigh?.kW)) && e.demandHigh?.since)
             this.demandHigh = { ...e.demandHigh };
@@ -1691,6 +1715,14 @@ export class EmsKernel extends FlowEngine {
             ...(this.lastBill ? { lastBill: { ...this.lastBill } } : {}),
             ...(this.tariffBasis ? { tariffBasis: { ...this.tariffBasis } } : {}),
             ...(this.generationPrice ? { generationPrice: { ...this.generationPrice } } : {}),
+            /*
+             * **예정된 선언도 함께 낸다.** 지금 유효한 것만 이어받으면, 재기동한 뒤 9월이 되어도 8월 단가로
+             * 계산한다 — 9월 선언이 어디에도 남아 있지 않기 때문이다. 오늘 이 부류를 세 번 겪었다.
+             */
+            ...(this.tariffBasisSchedule?.length ? { tariffBasisSchedule: this.tariffBasisSchedule.map(d => ({ ...d })) } : {}),
+            ...(this.generationPriceSchedule?.length
+                ? { generationPriceSchedule: this.generationPriceSchedule.map(d => ({ ...d })) }
+                : {}),
             ...(() => {
                 const r = this.generationRated();
                 return r ? { generationRated: r } : {};
@@ -1705,3 +1737,49 @@ export class EmsKernel extends FlowEngine {
         return { ...snap, energy };
     }
 }
+/**
+ * 선언 하나를 목록에 넣는다 — **같은 유효 구간이면 새것이 이긴다.**
+ *
+ * 사업자가 그 주기의 기준을 고칠 수 있다. 같은 구간에 두 선언이 남으면 어느 것이 맞는지 말할 수 없다.
+ *
+ * 목록은 시작 시각 순으로 두고 **24개까지** 든다. 선언은 주기마다 하나이므로 24개면 두 해치다 —
+ * 그보다 오래된 것은 지난 기록에서 읽는다(상태는 「지금」을 위한 것이다).
+ */
+function putDeclaration(list, d) {
+    const rest = (list ?? []).filter(x => !(x.from === d.from && x.to === d.to));
+    const next = [...rest, { ...d }].sort((a, b) => Date.parse(a.from) - Date.parse(b.from));
+    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) {
+        if (effectivityAt({ effectiveStart: d.from, effectiveEnd: d.to }, at, { end: 'exclusive' }) !== undefined)
+            continue;
+        const from = Date.parse(String(d.from));
+        if (!Number.isFinite(from))
+            continue;
+        if (from > bestFrom) {
+            best = d;
+            bestFrom = from;
+        }
+    }
+    return best;
+}

package/dist/energy-ingest.js

@@ -503,11 +503,6 @@ export function ingestEnergyGenerationPriceRecords(records, opts) {
             continue;
         }
         const data = { from: span.from, to: span.to, unitPrice, currency };
-        const futureError = futureFactError(span.from, opts);
-        if (futureError) {
-            rejected.push({ record: r, errors: [futureError] });
-            continue;
-        }
         accepted.push({
             eventId: periodFactId(opts.tenantId, ENERGY_EVENT.generationPrice, '', span.from, span.to),
             eventType: ENERGY_EVENT.generationPrice,
@@ -573,11 +568,6 @@ export function ingestEnergyTariffBasisRecords(records, opts) {
             ...(demandChargePerKW !== undefined ? { demandChargePerKW } : {}),
             ...(currency ? { currency } : {})
         };
-        const futureError = futureFactError(span.from, opts);
-        if (futureError) {
-            rejected.push({ record: r, errors: [futureError] });
-            continue;
-        }
         accepted.push({
             eventId: periodFactId(opts.tenantId, ENERGY_EVENT.tariffBasis, '', span.from, span.to),
             eventType: ENERGY_EVENT.tariffBasis,
@@ -633,8 +623,13 @@ export function isEnergyBillRecord(record) {
  * 지난 기록 채우기는 이미 이 판단을 하고 있었다(§`judgeBackfill`). 라이브 문에만 없어서 **한 종류에
  * 규칙이 두 벌**이었다. 같은 사실이 어느 문으로 들어오느냐에 따라 받아지기도 하고 거절되기도 했다.
  *
- * 기준 선언(요금 기준·발전 단가)은 기간이 미래로 뻗어도 된다 — 그쪽은 사건 시각이 **기간의 시작**이라
- * 이 판정에 걸리지 않는다. 앞으로 이렇게 매기겠다는 선언은 오늘 성립한다.
+ * ── 기준 선언은 이 판정을 받지 않는다 (2026-08-30, 두 번째 판단) ────────────
+ * 요금 기준·발전 단가는 **예정될 수 있다.** 한전은 다음 달 요금을 미리 공표하고, 공정 조건도 시행일을
+ * 앞두고 정해진다. 「9월부터 이 단가」는 오늘 성립하는 사실이다.
+ *
+ * 처음에는 이 둘도 거부했다. 그러면 정상적인 사실이 막힌다. 받되, **예정된 선언이 지금 것을 덮지 않게**
+ * 커널이 유효 구간으로 고른다(§`EnergyState.tariffBasisSchedule`). 받아 놓고 아무 데나 쓰면
+ * 오늘 요금이 다음 달 단가로 계산된다 — 그것이 이 문을 열기 전에 먼저 만들어야 했던 자리다.
  */
 function futureFactError(eventTime, opts) {
     const nowText = opts.nowISO ?? opts.defaultEventTime;

package/dist-cjs/index.cjs

@@ -366,14 +366,14 @@ function judgeAgainstSpec(spec, result) {
   }
   return allJudged ? "pass" : void 0;
 }
-function effectivityAt(p, at) {
+function effectivityAt(p, at, opts) {
   if (!p || !at) return void 0;
   const atMs = parsedMs(at);
   if (!Number.isFinite(atMs)) return void 0;
   const from = p.effectiveStart ? parsedMs(p.effectiveStart) : NaN;
   if (Number.isFinite(from) && atMs < from) return "not-yet";
   const to = p.effectiveEnd ? parsedMs(p.effectiveEnd) : NaN;
-  if (Number.isFinite(to) && atMs > to) return "expired";
+  if (Number.isFinite(to) && (opts?.end === "exclusive" ? atMs >= to : atMs > to)) return "expired";
   return void 0;
 }
 var PARSED_MAX = 64;
@@ -2862,11 +2862,6 @@ function ingestEnergyGenerationPriceRecords(records, opts) {
       continue;
     }
     const data = { from: span.from, to: span.to, unitPrice, currency };
-    const futureError = futureFactError(span.from, opts);
-    if (futureError) {
-      rejected.push({ record: r, errors: [futureError] });
-      continue;
-    }
     accepted.push({
       eventId: periodFactId(opts.tenantId, ENERGY_EVENT.generationPrice, "", span.from, span.to),
       eventType: ENERGY_EVENT.generationPrice,
@@ -2912,11 +2907,6 @@ function ingestEnergyTariffBasisRecords(records, opts) {
       ...demandChargePerKW !== void 0 ? { demandChargePerKW } : {},
       ...currency ? { currency } : {}
     };
-    const futureError = futureFactError(span.from, opts);
-    if (futureError) {
-      rejected.push({ record: r, errors: [futureError] });
-      continue;
-    }
     accepted.push({
       eventId: periodFactId(opts.tenantId, ENERGY_EVENT.tariffBasis, "", span.from, span.to),
       eventType: ENERGY_EVENT.tariffBasis,
@@ -8673,11 +8663,8 @@ var EmsKernel = class extends FlowEngine {
   applyGenerationPrice(envelope) {
     const d = envelope.data;
     if (!d?.from || !d?.to) return;
-    const fromMs = Date.parse(String(d.from));
-    if (!Number.isFinite(fromMs)) return;
-    const priorFromMs = Date.parse(String(this.generationPrice?.from ?? ""));
-    if (Number.isFinite(priorFromMs) && fromMs < priorFromMs) return;
-    this.generationPrice = { ...d };
+    this.generationPriceSchedule = putDeclaration(this.generationPriceSchedule, d);
+    this.generationPrice = inEffectAt(this.generationPriceSchedule, this.nowMs());
     this.revision++;
   }
   /**
@@ -8689,13 +8676,25 @@ var EmsKernel = class extends FlowEngine {
   applyTariffBasis(envelope) {
     const d = envelope.data;
     if (!d?.from || !d?.to) return;
-    const fromMs = Date.parse(String(d.from));
-    if (!Number.isFinite(fromMs)) return;
-    const priorFromMs = Date.parse(String(this.tariffBasis?.from ?? ""));
-    if (Number.isFinite(priorFromMs) && fromMs < priorFromMs) return;
-    this.tariffBasis = { ...d };
+    this.tariffBasisSchedule = putDeclaration(this.tariffBasisSchedule, d);
+    this.tariffBasis = inEffectAt(this.tariffBasisSchedule, this.nowMs());
     this.revision++;
   }
+  /**
+   * 시계가 선언의 경계를 넘으면 **지금 유효한 선언이 바뀐다.**
+   *
+   * 표본이 들어올 때만 다시 고르면, 9월 1일 0시에 단가가 바뀌었는데 다음 표본이 올 때까지 8월 단가로
+   * 계산한다. 태양광은 밤에 표본이 없어 그 간격이 길다.
+   */
+  refreshDeclarationsInEffect(nowMs) {
+    const tariff = inEffectAt(this.tariffBasisSchedule, nowMs);
+    const price = inEffectAt(this.generationPriceSchedule, nowMs);
+    if (tariff !== this.tariffBasis || price !== this.generationPrice) {
+      this.tariffBasis = tariff;
+      this.generationPrice = price;
+      this.revision++;
+    }
+  }
   /**
    * 청구서를 상태에 둔다 — **우리 계산을 덮지 않는다.**
    *
@@ -8914,8 +8913,12 @@ var EmsKernel = class extends FlowEngine {
   lastBill;
   /** 마지막으로 받은 요금 기준 — 이 주기에 적용되는 요금적용전력과 단가. */
   tariffBasis;
+  /** 선언된 요금 기준들 — 예정된 것을 포함한다(§`EnergyState.tariffBasisSchedule`). */
+  tariffBasisSchedule;
   /** 마지막으로 받은 발전 단가 — 이 기간에 낸 전기 1kWh 의 값. */
   generationPrice;
+  /** 선언된 발전 단가들 — 예정된 것을 포함한다. */
+  generationPriceSchedule;
   /**
    * 이 청구 주기의 **최고 수요** — 기본요금이 이 값으로 다시 정해진다.
    *
@@ -9552,6 +9555,7 @@ var EmsKernel = class extends FlowEngine {
     super.tick(dtMs);
     const at = this.nowMs();
     this.closeGenerationPeriodsDue(at);
+    this.refreshDeclarationsInEffect(at);
     this.deriveLoad(at, dtMs);
     this.closeDue(at);
   }
@@ -9591,8 +9595,13 @@ var EmsKernel = class extends FlowEngine {
     }
     if (Number.isFinite(e.unclosedGenerationPeriods)) this.unclosedGenerationPeriods = Number(e.unclosedGenerationPeriods);
     if (e.lastBill?.from && e.lastBill?.to) this.lastBill = { ...e.lastBill };
+    if (Array.isArray(e.tariffBasisSchedule)) this.tariffBasisSchedule = e.tariffBasisSchedule.map((d) => ({ ...d }));
+    if (Array.isArray(e.generationPriceSchedule)) this.generationPriceSchedule = e.generationPriceSchedule.map((d) => ({ ...d }));
     if (e.tariffBasis?.from && e.tariffBasis?.to) this.tariffBasis = { ...e.tariffBasis };
     if (e.generationPrice?.from && e.generationPrice?.to) this.generationPrice = { ...e.generationPrice };
+    if (this.tariffBasisSchedule?.length || this.generationPriceSchedule?.length) {
+      this.refreshDeclarationsInEffect(this.nowMs());
+    }
     if (Number.isFinite(Number(e.demandHigh?.kW)) && e.demandHigh?.since) this.demandHigh = { ...e.demandHigh };
   }
   getSnapshot() {
@@ -9617,6 +9626,12 @@ var EmsKernel = class extends FlowEngine {
       ...this.lastBill ? { lastBill: { ...this.lastBill } } : {},
       ...this.tariffBasis ? { tariffBasis: { ...this.tariffBasis } } : {},
       ...this.generationPrice ? { generationPrice: { ...this.generationPrice } } : {},
+      /*
+       * **예정된 선언도 함께 낸다.** 지금 유효한 것만 이어받으면, 재기동한 뒤 9월이 되어도 8월 단가로
+       * 계산한다 — 9월 선언이 어디에도 남아 있지 않기 때문이다. 오늘 이 부류를 세 번 겪었다.
+       */
+      ...this.tariffBasisSchedule?.length ? { tariffBasisSchedule: this.tariffBasisSchedule.map((d) => ({ ...d })) } : {},
+      ...this.generationPriceSchedule?.length ? { generationPriceSchedule: this.generationPriceSchedule.map((d) => ({ ...d })) } : {},
       ...(() => {
         const r = this.generationRated();
         return r ? { generationRated: r } : {};
@@ -9629,6 +9644,27 @@ var EmsKernel = class extends FlowEngine {
     return { ...snap, energy };
   }
 };
+function putDeclaration(list, d) {
+  const rest = (list ?? []).filter((x) => !(x.from === d.from && x.to === d.to));
+  const next = [...rest, { ...d }].sort((a, b) => Date.parse(a.from) - Date.parse(b.from));
+  return next.length > 24 ? next.slice(next.length - 24) : next;
+}
+function inEffectAt(list, atMs) {
+  if (!list?.length) return void 0;
+  const at = new Date(atMs).toISOString();
+  let best;
+  let bestFrom = -Infinity;
+  for (const d of list) {
+    if (effectivityAt({ effectiveStart: d.from, effectiveEnd: d.to }, at, { end: "exclusive" }) !== void 0) continue;
+    const from = Date.parse(String(d.from));
+    if (!Number.isFinite(from)) continue;
+    if (from > bestFrom) {
+      best = d;
+      bestFrom = from;
+    }
+  }
+  return best;
+}
 
 // src/event-journal.ts
 var DOMAIN_KERNELS = { wms: WmsKernel, yms: YmsKernel, mes: MesKernel, ems: EmsKernel };

package/package.json

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