@operato/twin-kernel 0.6.14 → 0.7.1

package/dist-cjs/index.cjs

@@ -27,11 +27,18 @@ __export(index_exports, {
   CAPABILITY_KEYS: () => CAPABILITY_KEYS,
   CBV_BIZSTEP: () => CBV_BIZSTEP,
   CMD: () => CMD,
+  DEMAND_WINDOW_MS: () => DEMAND_WINDOW_MS,
   DISP: () => DISP,
   DOMAIN_CATALOG: () => DOMAIN_CATALOG,
   DOMAIN_SYSTEMS: () => DOMAIN_SYSTEMS,
+  EMS_EQUIPMENT_TYPES: () => EMS_EQUIPMENT_TYPES,
+  EMS_LOCATION_TYPES: () => EMS_LOCATION_TYPES,
+  EMS_PROPERTY: () => EMS_PROPERTY,
+  EMS_TYPES: () => EMS_TYPES,
+  ENERGY_EVENT: () => ENERGY_EVENT,
   EPCIS_CONTEXT: () => EPCIS_CONTEXT,
   EQUIPMENT_LEVEL: () => EQUIPMENT_LEVEL,
+  EmsKernel: () => EmsKernel,
   EventJournal: () => EventJournal,
   FlowEngine: () => FlowEngine,
   GUARD_PRAGMA: () => GUARD_PRAGMA,
@@ -70,6 +77,9 @@ __export(index_exports, {
   activeShiftOf: () => activeShiftOf,
   aggregationEvent: () => aggregationEvent,
   analyzeCapacity: () => analyzeCapacity,
+  attributeEnergy: () => attributeEnergy,
+  axesOfSystem: () => axesOfSystem,
+  axisAppliesTo: () => axisAppliesTo,
   axisInfo: () => axisInfo,
   axisSource: () => axisSource,
   capabilitiesForType: () => capabilitiesForType,
@@ -80,10 +90,13 @@ __export(index_exports, {
   constantDuration: () => constantDuration,
   conversionFactorOf: () => conversionFactorOf,
   counterfactualAt: () => counterfactualAt,
+  demandWindowStart: () => demandWindowStart,
   deriveAttentions: () => deriveAttentions,
   documentPath: () => documentPath,
   dueStatusOf: () => dueStatusOf,
   effectivityAt: () => effectivityAt,
+  energyIntensity: () => energyIntensity,
+  energyOfWindows: () => energyOfWindows,
   fefoPolicy: () => fefoPolicy,
   firstFitPolicy: () => firstFitPolicy,
   foldJobResponses: () => foldJobResponses,
@@ -94,9 +107,12 @@ __export(index_exports, {
   inWorkCalendar: () => inWorkCalendar,
   inWorkCalendarAt: () => inWorkCalendarAt,
   ingest: () => ingest,
+  ingestEnergyRecords: () => ingestEnergyRecords,
+  isEnergyRecord: () => isEnergyRecord,
   isEquipmentLevel: () => isEquipmentLevel,
   isoDurationHours: () => isoDurationHours,
   itemKeyOf: () => itemKeyOf,
+  levelOfLocationType: () => levelOfLocationType,
   lgtinClass: () => lgtinClass,
   locationStatusOf: () => locationStatusOf,
   mapRecord: () => mapRecord,
@@ -167,7 +183,7 @@ var EQUIPMENT_LEVEL = [
 function isEquipmentLevel(v) {
   return typeof v === "string" && EQUIPMENT_LEVEL.includes(v);
 }
-function hierarchyOf(s) {
+function hierarchyOf(s, levelOfType) {
   const push = (m, k, v) => {
     const cur = m.get(k);
     if (cur) cur.push(v);
@@ -210,7 +226,7 @@ function hierarchyOf(s) {
     return out;
   };
   const typeOf = new Map(s.locations.map((n) => [n.id, n.type]));
-  const levelOf = new Map(s.locations.map((n) => [n.id, n.level]));
+  const levelOf = new Map(s.locations.map((n) => [n.id, n.level ?? (n.type ? levelOfType?.(n.type) : void 0)]));
   return {
     childrenOf: (id) => [...kids.get(id) ?? []],
     ancestorsOf,
@@ -455,7 +471,7 @@ var OP_EVENT = {
    *
    * 다른 파생 상태는 상태에서 다시 계산된다(주목 신호 자체가 그렇다). 그런데 "누가 이것을 봤다" 는
    * 계산으로 되살릴 수 없다. 저널에 남기지 않으면 재기동하면 확인해 둔 신호가 다시 빨개지고,
-   * 과거를 되짚어도 그때 무엇을 확인했는지 알 수 없다 — 저널이 현실을 불완전하게 담는 자리였다.
+   * 과거를 다시 계산해도 그때 무엇을 확인했는지 알 수 없다 — 저널이 현실을 불완전하게 담는 자리였다.
    */
   /*
    * 값이 커맨드(`CMD.attentionAck='attention.ack'`)와 겹치지 않게 **과거형**으로 둔다 — 커맨드는
@@ -464,6 +480,35 @@ var OP_EVENT = {
    */
   attentionAck: "attention.acked"
 };
+var ENERGY_EVENT = {
+  /** 계량 도착 — 그 시점의 유효전력·누적량. 15분 수요 구간에 누적된다. */
+  measured: "energy.measured",
+  /** 수요 구간 마감 — 그 구간의 최대 수요가 확정된다(요금의 단위). */
+  demandWindow: "energy.demand.window",
+  /**
+   * 피크 경신 — 월 최대 수요가 갱신됐다.
+   *
+   * 구간 마감에서 파생되지만 **사실로 남긴다**: 요금의 근거이고, 나중에 "언제 무엇 때문에 올랐나" 를
+   * 물을 때 파생으로는 답할 수 없다(그 순간의 부하 구성이 사라진다).
+   */
+  peak: "energy.peak",
+  /** 요금 구간 전환 — 경부하·중간부하·최대부하. 달력이 아니라 사건이다(계절제·특례로 바뀐다). */
+  tariffShift: "energy.tariff.shift",
+  /** 발전(PV 등) — 역송을 포함한다(음의 소비가 아니라 별개 사실이다). */
+  generated: "energy.generated",
+  /** 저장(ESS 충전). */
+  stored: "energy.stored",
+  /** 방전(ESS). 충전과 나눈다 — 손실·수명 판단이 둘을 구별해야 한다. */
+  discharged: "energy.discharged",
+  /**
+   * 수요 제어 제안 — **제안이지 명령이 아니다.**
+   *
+   * 이 트윈은 차단·투입을 하지 않는다(안전 계통은 범위 밖: `ems.md` §1). 이대로면 계약을 넘는다는
+   * 판단과 무엇을 줄이면 되는지를 낼 뿐이고, 집행은 사람과 그 시스템의 몫이다. 이름을 `suggested`
+   * 로 둔 이유가 그것이다 — 저널만 보고도 "우리가 끈 것이 아니다" 를 알 수 있어야 한다.
+   */
+  drSuggested: "energy.dr.suggested"
+};
 var CMD = {
   orderHold: "order.hold",
   orderResume: "order.resume",
@@ -978,11 +1023,13 @@ var ObservedReducer = class {
   revision = 0;
   /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
   corrections = [];
+  /** 반영하지 못한 사건의 종류별 집계 — 원문은 쌓지 않는다(저널에 이미 있다). */
+  unhandled = /* @__PURE__ */ new Map();
   /**
    * 자원별 **교대 선언** — 미러가 "지금 근무 중인가" 를 스스로 판정하기 위한 재료.
    *
    * 상태(`EquipmentState`)에 넣지 않는다: 시뮬 스냅샷도 이것을 내보내지 않으므로 넣으면 두 구동이
-   * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
+   * 어긋난다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
    */
   shifts = /* @__PURE__ */ new Map();
   /**
@@ -1005,14 +1052,14 @@ var ObservedReducer = class {
     for (const a of readBoardAssets(model)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...a.testResults ? { testResults: a.testResults } : {}, ...effectiveOf(a) });
   }
   /**
-   * **구조를 갈아탄다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
+   * **구조를 전환한다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
    *
    * 공장은 바뀐다. 도장 부스를 넷 더 놓고, 라인을 하나 접는다. 그런데 지금까지는 구조가 바뀌면
    * **그 트윈의 저널을 통째로 지우는 것**이 유일한 길이었다 — 안 지우면 옛 이벤트를 새 공장에 대고
    * 접게 되어 이력이 거짓말을 한다. 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
    *
    * 셋째 길이 이것이다: 이벤트가 **자기 구조를 달고** 다니고, 재생은 구조가 바뀌는 지점에서 여기를
-   * 불러 갈아탄 뒤 이어 접는다. 그러면 "그때 그 공장의 사실" 로 계속 읽힌다.
+   * 불러 전환한 뒤 이어 접는다. 그러면 "그때 그 공장의 사실" 로 계속 읽힌다.
    *
    * ── 무엇을 지키고 무엇을 버리는가 ───────────────────────────────────────
    * **관측은 지킨다** — 물품·오더·작업·집합은 구조와 무관한 사실이다(팔레트는 부스를 늘려도 그대로다).
@@ -1131,7 +1178,7 @@ var ObservedReducer = class {
   /**
    * **미러의 "지금"** — 지금까지 들은 것 중 가장 늦은 발생 시각.
    *
-   * 미러는 스스로 시간을 굴리지 않지만, 시각으로만 일어나는 사실(유효 기간 만료)을 판정하려면 기준이
+   * 미러는 스스로 시간을 진행시키지 않지만, 시각으로만 일어나는 사실(유효 기간 만료)을 판정하려면 기준이
    * 필요하다. 미러의 정직한 기준은 **"내가 마지막으로 들은 시점"** 이다. 아무것도 못 들었으면
    * 판정하지 않는다(모르면 단정하지 않는다).
    */
@@ -1248,7 +1295,20 @@ var ObservedReducer = class {
         });
         break;
       }
+      default:
+        this.noteUnhandled(e);
+    }
+  }
+  /** 반영하지 못한 사건을 종류별로 센다 — 처음·마지막 시각을 함께 남겨 「언제부터」에 답한다. */
+  noteUnhandled(e) {
+    const at = Date.parse(String(e.eventTime ?? ""));
+    const cur = this.unhandled.get(e.eventType) ?? { count: 0 };
+    cur.count++;
+    if (Number.isFinite(at)) {
+      if (cur.firstAtMs === void 0 || at < cur.firstAtMs) cur.firstAtMs = at;
+      if (cur.lastAtMs === void 0 || at > cur.lastAtMs) cur.lastAtMs = at;
     }
+    this.unhandled.set(e.eventType, cur);
   }
   applyEpcis(ev, envelope) {
     if (ev.errorDeclaration) {
@@ -1351,7 +1411,7 @@ var ObservedReducer = class {
        *
        * **한 항목뿐이면 담지 않는다.** 그 하나는 `qty`/`uom` 이 이미 무손실로 들고 있고, 1개짜리
        * 배열을 더 두면 같은 사실이 두 곳에 생긴다(그리고 시뮬은 그 배열을 만들지 않아 두 구동이
-       * 갈라진다 — 적합성 하네스가 실제로 잡았다). `quantities` 의 뜻은 **추가 단위**다.
+       * 어긋난다 — 적합성 하네스가 실제로 잡았다). `quantities` 의 뜻은 **추가 단위**다.
        * 읽을 때는 단위를 가리지 않는 `quantityIn` 을 쓴다(단일이든 복수든 같은 답).
        */
       quantities: (() => {
@@ -1439,6 +1499,7 @@ var ObservedReducer = class {
     return {
       revision: this.revision,
       ...this.corrections.length ? { corrections: this.corrections.map((c) => ({ ...c })) } : {},
+      ...this.unhandled.size ? { unhandled: [...this.unhandled.entries()].map(([eventType, v]) => ({ eventType, ...v })).sort((a, b) => b.count - a.count) } : {},
       locations: [...this.master.values()].map((n) => {
         const occupancy = occ.get(n.id) ?? 0;
         const status = locationStatusOf({ occupancy, capacity: n.capacity });
@@ -1525,14 +1586,148 @@ var BTT = {
   so: "urn:epcglobal:cbv:btt:so"
 };
 var WMS_LOCATION_TYPES = ["dock", "storage", "staging", "dock-ship", "vas-station"];
+var WMS_LOCATION_LEVEL = {
+  dock: "StorageZone",
+  storage: "StorageUnit",
+  staging: "StorageZone",
+  "dock-ship": "StorageZone",
+  "vas-station": "WorkCell"
+};
 var WMS_TYPES = [
-  ...WMS_LOCATION_TYPES.filter((k) => k !== "vas-station").map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
-  { key: "vas-station", role: "location", label: "twin.type.vas-station", standardClass: { epcis: "bizLocation", isa95: "WorkCenter" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable", "processable"] },
+  ...WMS_LOCATION_TYPES.filter((k) => k !== "vas-station").map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, level: WMS_LOCATION_LEVEL[k], capabilities: ["storable"] })),
+  { key: "vas-station", role: "location", label: "twin.type.vas-station", standardClass: { epcis: "bizLocation", isa95: "WorkCenter" }, identity: { scheme: "gs1:SGLN" }, level: WMS_LOCATION_LEVEL["vas-station"], capabilities: ["storable", "processable"] },
   { key: "forklift", role: "equipment", label: "twin.type.forklift", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] },
   /** 유통가공 작업자·작업대 설비 — 가공을 수행하는 능동 자원(ISA-95 `Equipment`). */
   { key: "packer", role: "equipment", label: "twin.type.packer", standardClass: { epcis: "object", isa95: "Equipment" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
+// src/ems-profile.ts
+var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
+var EMS_EQUIPMENT_TYPES = ["meter", "breaker", "pv-array", "battery", "utility", "curtailable-load"];
+var EMS_PROPERTY = {
+  /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
+  contractKW: "contract.kW"
+};
+var EMS_TYPES = [
+  /* ── 자리: 전기적 구간 ─────────────────────────────────────────────────── */
+  {
+    key: "incoming",
+    role: "location",
+    /* 전기 계통의 구간은 **설비 계층의 단이 아니다** — 표준의 탈출구(`Other`)를 쓴다(아래 주석). */
+    level: "Other",
+    label: "twin.type.incoming",
+    /* 수전 지점 — 계약전력이 걸리는 자리이고, 요금의 근거가 되는 수요는 여기서 잰다.
+       ISO 50001 의 「에너지 유입」 경계이기도 하다(조직의 에너지 검토가 여기서 시작한다). */
+    standardClass: { iec61850: "MMTR", iso50001: "EnergyInput" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["metered"]
+  },
+  {
+    key: "feeder",
+    role: "location",
+    /* 전기 계통의 구간은 **설비 계층의 단이 아니다** — 표준의 탈출구(`Other`)를 쓴다(아래 주석). */
+    level: "Other",
+    label: "twin.type.feeder",
+    /* 분기 회로 — 부하 분해의 단위. 계약전력의 하위 배분이 여기서 정해진다. */
+    standardClass: { iec61850: "Feeder", iso50001: "EnergyUse" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["metered"]
+  },
+  {
+    key: "submeter-zone",
+    role: "location",
+    /* 전기 계통의 구간은 **설비 계층의 단이 아니다** — 표준의 탈출구(`Other`)를 쓴다(아래 주석). */
+    level: "Other",
+    label: "twin.type.submeter-zone",
+    /*
+     * 구역 계량 — 여러 부하를 한 계량기로 묶어 재는 자리(공조·조명처럼 개별 계량이 없는 것들).
+     *
+     * ISO 50001 의 **SEU**(유의 에너지 사용처)가 대개 이 알갱이다. 개별 설비까지 재지 못하는 현장이
+     * 많고, 그것을 「모른다」로 두는 대신 **묶음으로 아는 것**이 정직하다.
+     */
+    standardClass: { iec61850: "MMXU", iso50001: "SEU" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["metered"]
+  },
+  /* ── 설비: 계량 지점과 에너지 자원 ──────────────────────────────────────── */
+  {
+    key: "meter",
+    role: "equipment",
+    label: "twin.type.meter",
+    /* 계량기 — 측정 논리 노드(MMXU=측정단위, MMTR=적산). 자산으로도 하나다(ISO 55000). */
+    standardClass: { iec61850: "MMXU", iso55000: "Asset", iso50001: "MeasurementPoint" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["metered", "operable"]
+  },
+  {
+    key: "breaker",
+    role: "equipment",
+    label: "twin.type.breaker",
+    /*
+     * 차단기 — IEC 61850 `XCBR`. **우리는 이것을 조작하지 않는다**(안전 계통은 범위 밖: ems.md §1).
+     * 상태를 읽어 계통 구성을 알 뿐이다 — 그래서 능력은 `operable` 만이고 `curtailable` 이 아니다.
+     */
+    standardClass: { iec61850: "XCBR", iso55000: "Asset" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["operable"]
+  },
+  {
+    key: "pv-array",
+    role: "equipment",
+    label: "twin.type.pv-array",
+    /* 태양광 어레이 — IEC 61850-7-420(분산자원)의 `DPVA`. 발전과 계량은 다른 능력이다. */
+    standardClass: { iec61850: "DPVA", iso55000: "Asset", iso50001: "RenewableSupply" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["generating", "metered", "operable"]
+  },
+  {
+    key: "battery",
+    role: "equipment",
+    label: "twin.type.battery",
+    /* 축전지(ESS) — `ZBAT`. 충전·방전을 나눠 재고, 저장은 보관(`storable`)이 아니다(물건이 아니다). */
+    standardClass: { iec61850: "ZBAT", iso55000: "Asset" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["storing", "metered", "operable"]
+  },
+  {
+    key: "utility",
+    role: "equipment",
+    label: "twin.type.utility",
+    /*
+     * 공통 설비 — 공조·컴프레서·칠러·조명·폐수처리처럼 **어느 공정에도 귀속되지 않는** 소비처.
+     *
+     * ── 왜 따로 있나 (2026-08-14) ────────────────────────────────────────────
+     * 물류·생산 트윈에서 이런 것들은 **설비가 아니다**(공정에 매핑되지 않으므로 자원 축에 없다).
+     * 그런데 에너지에서는 소비의 절반을 차지하고 감축 후보 1순위다 — 담을 자리가 반드시 있어야 한다.
+     *
+     * 처음에는 `curtailable-load` 하나로 받으려 했다. 그런데 그 이름은 **「줄일 수 있다」고 주장**한다:
+     * 폐수처리·방폭 환기·서버실 냉방은 공통이지만 줄일 수 없고, 그것을 감축 가능으로 두면 트윈이
+     * 「이걸 줄이면 됩니다」라는 거짓 제안을 한다. 공통성과 감축 가능성은 **다른 축**이다.
+     *
+     * 표준: IEC 61850 에 「공통 설비」라는 논리 노드는 없다(설비 종류마다 다른 노드다) — 비운다.
+     * ISO 50001 의 SEU 는 이 부류를 가장 많이 가리킨다(유의 에너지 사용처).
+     */
+    standardClass: { iso50001: "SEU", iso55000: "Asset" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["metered", "operable"]
+  },
+  {
+    key: "curtailable-load",
+    role: "equipment",
+    label: "twin.type.curtailable-load",
+    /*
+     * 감축 가능 부하 — 줄일 수 있는 소비처(공조·충전기·비상시 미가동 라인).
+     *
+     * 표준에 이 이름은 없다: IEC 61850 은 설비를 종류로 부르고 「감축 가능」은 **운영 정책**이다.
+     * 그래서 `iec61850` 칸을 비우고 ISO 50001 의 SEU 로만 대응한다 — 억지로 논리 노드를 적으면
+     * 적합성 표가 거짓을 말한다.
+     */
+    standardClass: { iso50001: "SEU" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["curtailable", "metered", "operable"]
+  }
+];
+
 // src/capability.ts
 var CAPABILITIES = {
   operable: {
@@ -1571,9 +1766,49 @@ var CAPABILITIES = {
     semantics: "\uC624\uB354/\uC544\uC774\uD15C \uC0DD\uC560 \uCD94\uC801 \u2014 \uC0DD\uC560\uB2E8\uACC4(\uB3C4\uBA54\uC778 \uB77C\uBCA8, \uBB34\uBC29\uC5B8)\xB7\uC9C4\uD589\xB7\uBCF4\uB958.",
     stateFields: ["lifecycle", "progress", "held"],
     results: ["lifecycleChanged"]
+  },
+  /*
+   * ── 에너지 능력 넷 ──────────────────────────────────────────────────────
+   * 상태 필드는 기존 능력과 **직교**한다(원칙 ②) — 어느 필드도 두 능력에 겹치지 않는다.
+   * 계량은 `operable`(가동 상태)과도 직교한다: 도는 것과 재는 것은 다른 사실이고, 멈춘 설비도
+   * 대기전력을 쓴다.
+   */
+  metered: {
+    key: "metered",
+    label: "twin.capability.metered",
+    semantics: "\uC790\uAE30 \uC18C\uBE44\uB97C \uC7B0\uB2E4 \u2014 \uC720\uD6A8\uC804\uB825\xB7\uB204\uC801\uB7C9\xB7\uC5ED\uB960. \uAC12\uC774 \uC5C6\uC73C\uBA74 \uBAA8\uB974\uB294 \uAC83\uC774\uB2E4(0 \uC774 \uC544\uB2C8\uB2E4).",
+    stateFields: ["kW", "kWh", "powerFactor"],
+    models: ["MeteredState"],
+    results: ["measured"]
+  },
+  curtailable: {
+    key: "curtailable",
+    label: "twin.capability.curtailable",
+    semantics: "\uC904\uC77C \uC218 \uC788\uB2E4 \u2014 \uCD5C\uC18C \uC720\uC9C0 \uC544\uB798\uB85C\uB294 \uB0B4\uB9AC\uC9C0 \uC54A\uB294\uB2E4. \uD310\uC815\uB9CC \uD558\uACE0 \uC9D1\uD589\uC740 \uC0AC\uB78C\uACFC \uADF8 \uC2DC\uC2A4\uD15C\uC758 \uBAAB\uC774\uB2E4.",
+    stateFields: ["curtailable", "minKW"],
+    models: ["CurtailableState"],
+    invariants: ["minKW >= 0"],
+    results: ["drSuggested"]
+  },
+  generating: {
+    key: "generating",
+    label: "twin.capability.generating",
+    semantics: "\uC804\uAE30\uB97C \uB9CC\uB4E0\uB2E4 \u2014 \uC5ED\uC1A1\uC740 \uC18C\uBE44\uC758 \uC74C\uC218\uAC00 \uC544\uB2C8\uB77C \uBCC4\uAC1C \uC0AC\uC2E4\uC774\uB2E4.",
+    stateFields: ["generatedKW", "exportKW"],
+    models: ["GeneratingState"],
+    results: ["generated"]
+  },
+  storing: {
+    key: "storing",
+    label: "twin.capability.storing",
+    semantics: "\uB2F4\uACE0 \uB0B8\uB2E4 \u2014 \uCDA9\uC804\uACFC \uBC29\uC804\uC744 \uB098\uB208\uB2E4(\uC190\uC2E4\xB7\uC218\uBA85 \uD310\uB2E8\uC774 \uB458\uC744 \uAD6C\uBCC4\uD574\uC57C \uD55C\uB2E4).",
+    stateFields: ["soc", "chargeKW", "dischargeKW"],
+    models: ["StoringState"],
+    invariants: ["0 <= soc <= 100"],
+    results: ["stored", "discharged"]
   }
 };
-var CAPABILITY_KEYS = ["operable", "storable", "mobile", "processable", "trackable"];
+var CAPABILITY_KEYS = ["operable", "storable", "mobile", "processable", "trackable", "metered", "curtailable", "generating", "storing"];
 function stateFieldsOf(caps) {
   const out = /* @__PURE__ */ new Set();
   for (const c of caps) for (const f of CAPABILITIES[c]?.stateFields ?? []) out.add(f);
@@ -1598,8 +1833,14 @@ function graiUri(companyPrefix, assetType, serial) {
   return `urn:epc:id:grai:${companyPrefix}.${assetType}.${String(serial).padStart(6, "0")}`;
 }
 var YMS_LOCATION_TYPES = ["gate", "yard-slot", "dock-door", "staging"];
+var YMS_LOCATION_LEVEL = {
+  gate: "Other",
+  "yard-slot": "StorageUnit",
+  "dock-door": "StorageUnit",
+  staging: "StorageZone"
+};
 var YMS_TYPES = [
-  ...YMS_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  ...YMS_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, level: YMS_LOCATION_LEVEL[k], capabilities: ["storable"] })),
   { key: "hostler", role: "equipment", label: "twin.type.hostler", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
 ];
 
@@ -1625,8 +1866,16 @@ var MES_LOCATION_CLS = {
   "assembly-line": { isa95: "WorkCenter", epcis: "bizLocation" },
   "fg-store": { epcis: "bizLocation" }
 };
+var MES_LOCATION_LEVEL = {
+  "raw-store": "StorageZone",
+  "cut-station": "WorkCell",
+  "weld-station": "WorkCell",
+  "paint-booth": "WorkCell",
+  "assembly-line": "ProductionLine",
+  "fg-store": "StorageZone"
+};
 var MES_TYPES = [
-  ...MES_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: MES_LOCATION_CLS[k] ?? {}, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  ...MES_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: MES_LOCATION_CLS[k] ?? {}, identity: { scheme: "gs1:SGLN" }, level: MES_LOCATION_LEVEL[k], capabilities: ["storable"] })),
   { key: "cutter", role: "equipment", label: "twin.type.cutter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
   { key: "welder", role: "equipment", label: "twin.type.welder", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
   { key: "painter", role: "equipment", label: "twin.type.painter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
@@ -1639,8 +1888,10 @@ var DOMAIN_CATALOG = {
   // label 은 언어 중립 i18n 키(twin.system.<code>) — 사람 언어는 표현계층이 렌더(L2).
   wms: { system: "wms", label: "twin.system.wms", types: WMS_TYPES, locationTypes: locationKeys(WMS_TYPES) },
   yms: { system: "yms", label: "twin.system.yms", types: YMS_TYPES, locationTypes: locationKeys(YMS_TYPES) },
-  mes: { system: "mes", label: "twin.system.mes", types: MES_TYPES, locationTypes: locationKeys(MES_TYPES) }
+  mes: { system: "mes", label: "twin.system.mes", types: MES_TYPES, locationTypes: locationKeys(MES_TYPES) },
+  ems: { system: "ems", label: "twin.system.ems", types: EMS_TYPES, locationTypes: locationKeys(EMS_TYPES) }
 };
+var LOGISTICS = ["wms", "yms", "mes"];
 var TWIN_AXES = [
   {
     axis: "locations",
@@ -1663,7 +1914,8 @@ var TWIN_AXES = [
     path: "persons",
     label: "twin.axis.persons",
     kind: "instance",
-    standardClass: { isa95: "Person" }
+    standardClass: { isa95: "Person" },
+    systems: LOGISTICS
   },
   {
     axis: "assets",
@@ -1677,7 +1929,8 @@ var TWIN_AXES = [
     path: "personnelClasses",
     label: "twin.axis.personnelClasses",
     kind: "class",
-    standardClass: { isa95: "PersonnelClass" }
+    standardClass: { isa95: "PersonnelClass" },
+    systems: LOGISTICS
   },
   {
     axis: "equipmentClasses",
@@ -1698,28 +1951,32 @@ var TWIN_AXES = [
     path: "materialDefinitions",
     label: "twin.axis.materialDefinitions",
     kind: "class",
-    standardClass: { isa95: "MaterialDefinition" }
+    standardClass: { isa95: "MaterialDefinition" },
+    systems: LOGISTICS
   },
   {
     axis: "materialClasses",
     path: "materialClasses",
     label: "twin.axis.materialClasses",
     kind: "class",
-    standardClass: { isa95: "MaterialClass" }
+    standardClass: { isa95: "MaterialClass" },
+    systems: LOGISTICS
   },
   {
     axis: "operations",
     path: "operations",
     label: "twin.axis.operations",
     kind: "spec",
-    standardClass: { isa95: "OperationsSegment" }
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
   },
   {
     axis: "productionSpec",
     path: "productionSpec",
     label: "twin.axis.productionSpec",
     kind: "spec",
-    standardClass: { isa95: "OperationsSegment" }
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
   },
   /*
    * 아래 셋은 저장상 `productionSpec.definition` 안에 있지만 **개념으로는 1급**이다.
@@ -1732,21 +1989,24 @@ var TWIN_AXES = [
     path: "productionSpec.definition.recipes",
     label: "twin.axis.recipes",
     kind: "spec",
-    standardClass: { isa95: "OperationsSegment" }
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
   },
   {
     axis: "routes",
     path: "productionSpec.definition.routes",
     label: "twin.axis.routes",
     kind: "spec",
-    standardClass: { isa95: "OperationsSegment" }
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
   },
   {
     axis: "materials",
     path: "productionSpec.definition.materials",
     label: "twin.axis.materials",
     kind: "class",
-    standardClass: { isa95: "MaterialDefinition" }
+    standardClass: { isa95: "MaterialDefinition" },
+    systems: LOGISTICS
   },
   /*
    * 시험 명세 — **자원 아홉 종류가 가리키는 대상.**
@@ -1786,7 +2046,8 @@ var TWIN_AXES = [
     kind: "instance",
     source: "state",
     historical: true,
-    standardClass: { isa95: "OperationsRequest", epcis: "TransactionEvent" }
+    standardClass: { isa95: "OperationsRequest", epcis: "TransactionEvent" },
+    systems: LOGISTICS
   },
   {
     axis: "tasks",
@@ -1794,7 +2055,36 @@ var TWIN_AXES = [
     kind: "instance",
     source: "state",
     historical: true,
-    standardClass: { isa95: "SegmentResponse", epcis: "TransformationEvent" }
+    standardClass: { isa95: "SegmentResponse", epcis: "TransformationEvent" },
+    systems: LOGISTICS
+  },
+  /*
+   * ── 에너지가 더하는 개념은 **하나**다 (2026-08-14, §10 6.5단계) ──────────────
+   *
+   * 에너지 트윈의 개체 대부분은 **이미 있는 축**이 답한다: 전기 구간은 `locations`, 계량기·차단기·
+   * 태양광·축전지·감축 부하는 `equipment` 다(카탈로그가 그 타입들을 그 역할로 선언한다). 그것들을
+   * 새 축으로 다시 세우면 같은 것이 두 곳에서 세어진다 — 개념 지도가 계량기를 두 번 보여 준다.
+   *
+   * 정말로 새로운 것은 **수요 구간**이다: 자원이 아니고, 선언이 아니고, 15분마다 닫히는 **사실**이다.
+   * 그것이 요금의 알갱이이고 피크의 근거다(피크는 마감된 구간의 최대이므로 파생이다 — 축이 아니다).
+   *
+   * ── 표준 칸을 비운다 ──────────────────────────────────────────────────────
+   * 15분 수요 구간은 **요금 제도의 알갱이**다(계약·TOU). ISO 50001 은 경영 체계를, IEC 61850 은 설비
+   * 데이터 모델을 말하고, 둘 다 이 구간을 정의하지 않는다. 가까운 이름을 적으면 적합성 표가 거짓을
+   * 말하므로 비워 둔다 — 「표준에 자리가 없으면 빈 객체」라는 이 선언의 규율 그대로다.
+   *
+   * 아직 세우지 않은 것: **요금 구간**(TariffPeriod)과 **원단위**(EnPI). 둘 다 아직 아무도 만들지
+   * 않는다 — 선언만 하면 개념 지도가 언제나 0 을 보여 주고, 그것은 결손처럼 읽힌다(§10 7단계의 일).
+   */
+  {
+    axis: "demandWindows",
+    path: "energy.closed",
+    label: "twin.axis.demandWindows",
+    kind: "instance",
+    source: "state",
+    historical: true,
+    standardClass: {},
+    systems: ["ems"]
   }
 ];
 var TWIN_RELATIONS = [
@@ -1816,7 +2106,7 @@ var TWIN_RELATIONS = [
   { from: "routes", field: "steps[]", target: { kind: "axis", axis: "operations" }, via: "twin.rel.step" },
   /*
    * 일정·실적의 관계 — **관측 관계다.** 선언 관계는 "그렇게 만들기로 했다" 이고, 이것은 "그렇게
-   * 일어났다" 다. 관계가 없으면 이 두 축은 지도에서 떠 있는 카드가 된다(그러면 걸어 들어갈 수 없다).
+   * 일어났다" 다. 관계가 없으면 이 두 축은 지도에서 연결되지 않은 카드가 된다(그러면 걸어 들어갈 수 없다).
    */
   /*
    * 오더가 무엇을 만드나 — **자재 키가 아니라 GS1 품목 참조다**(`lines[].gtin`). 자재와 이어 주는
@@ -1912,7 +2202,20 @@ var relationsTo = (axis) => TWIN_RELATIONS.filter((r) => r.target.kind === "axis
 function axisInfo(axis) {
   return TWIN_AXES.find((a) => a.axis === axis);
 }
-var DOMAIN_SYSTEMS = ["wms", "yms", "mes"];
+var DOMAIN_SYSTEMS = ["wms", "yms", "mes", "ems"];
+var axisAppliesTo = (axis, system) => {
+  const declared = TWIN_AXES.find((a) => a.axis === axis)?.systems;
+  if (!declared || !system) return true;
+  if (!DOMAIN_SYSTEMS.includes(system)) return true;
+  return declared.includes(system);
+};
+var levelOfLocationType = (typeKey, system) => {
+  const pick = (sys) => DOMAIN_CATALOG[sys]?.types.find((t) => t.role === "location" && t.key === typeKey)?.level;
+  if (system && DOMAIN_SYSTEMS.includes(system)) return pick(system);
+  const found = [...new Set(DOMAIN_SYSTEMS.map(pick).filter(Boolean))];
+  return found.length === 1 ? found[0] : void 0;
+};
+var axesOfSystem = (system) => TWIN_AXES.filter((a) => axisAppliesTo(a.axis, system));
 function capabilitiesForType(system, typeKey) {
   return DOMAIN_CATALOG[system]?.types.find((t) => t.key === typeKey)?.capabilities ?? [];
 }
@@ -2521,7 +2824,7 @@ var FlowEngine = class {
   /*
    * ── 선언 하나를 상태 하나로 짓는 자리 ─────────────────────────────────────
    * 최초 적재(`loadTwinModel`)와 가동 중 교체(`adoptStructure`)가 **같은 구성을 쓴다.** 두 곳에서
-   * 따로 지으면 곧 갈라지고, 갈라진 쪽으로 들어온 자원만 필드 하나가 비는 식으로 조용히 다르다.
+   * 따로 지으면 곧 갈라지고, 어긋난 쪽으로 들어온 자원만 필드 하나가 비는 식으로 조용히 다르다.
    */
   buildLocation(n) {
     return { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: "idle", parentId: n.parentId };
@@ -2565,7 +2868,7 @@ var FlowEngine = class {
     this.observeMode = true;
   }
   /**
-   * 돌면서 공장을 갈아탄다 — **현실이 안 멈추므로 미러도 멈출 수 없다.**
+   * 돌면서 공장을 전환한다 — **현실이 안 멈추므로 미러도 멈출 수 없다.**
    *
    * ── 왜 관측 구동에만 여는가 ────────────────────────────────────────────────
    * 미러는 이미 있는 현실을 따라갈 뿐이라, 설비가 한 대 늘었다고 멈췄다 서는 것은 그 사이의
@@ -2578,7 +2881,7 @@ var FlowEngine = class {
    * 자원은 버리되 **몇 개를 버렸는지 돌려준다.** 여기서는 그 판단을 커널 자신의 선언 표에도
    * 그대로 옮긴다. 관측층만 갈면 사라진 설비가 커널 표에 남아 **화면이 없는 설비를 그린다.**
    *
-   * 관측으로 알게 된 자리는 선언에 없어도 지운 뒤 다시 심는다 — 다음 스냅샷에서 관측층이
+   * 관측으로 알게 된 자리는 선언에 없어도 지운 뒤 다시 주입한다 — 다음 스냅샷에서 관측층이
    * 되살리므로(`settleObserved` → `hydrateObserved`), 여기서 지켜야 할 것은 **선언분**뿐이다.
    */
   adoptStructure(def) {
@@ -2670,7 +2973,7 @@ var FlowEngine = class {
     this.items.clear();
     for (const it of snap.items) {
       this.items.set(itemKeyOf(it), {
-        /* 품번 키·로트는 식별자에서 파생되므로 심지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
+        /* 품번 키·로트는 식별자에서 파생되므로 주입하지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
         epc: it.epc,
         location: it.location,
         disposition: it.disposition ?? DISP.sellable,
@@ -2706,13 +3009,13 @@ var FlowEngine = class {
          * **잰 값을 이어받으면 잰 구간도 이어받아야 한다.**
          *
          * 카운터만 되살리고 창을 지금으로 두면 둘이 어긋난다: 이어받은 가동 8시간이 방금 시작한 창
-         * 안에 앉아, 놀고 있는 설비가 **가동률 100%·유휴 0초**로 보인다(화면에서 관측됨).
+         * 안에 앉아, 대기 중인 설비가 **가동률 100%·유휴 0초**로 보인다(화면에서 관측됨).
          *
          * 창은 지표 자신이 말해 준다 — 계획 시간은 가동·준비·고장·유휴의 합이다. 그래서 그 합만큼
          * 뒤로 물려 창을 다시 세운다. 지표가 없으면 창도 없다(그때는 지금부터 새로 잰다).
          */
         ...oee ? { metricsSinceMs: this.clockMs - ((oee.runMs ?? 0) + (oee.setupMs ?? 0) + (oee.downMs ?? 0) + (oee.idleMs ?? 0)) } : {},
-        /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 굴린다
+        /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 시뮬레이션한다
            (예측이 낙관 쪽으로 치우친다). 씨앗 왕복 대조가 이것을 잡았다. */
         ...m.held ? { held: true } : {},
         /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 보드에서 읽어 실어 온다). */
@@ -3070,7 +3373,7 @@ var FlowEngine = class {
         return st;
       }),
       /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
-       * 다른 커널을 심으면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
+       * 다른 커널을 주입하면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
        * 델타에서 왔으므로 갖고 있었다 — 같은 계약을 두 구동이 다르게 채우던 자리). */
       tasks: [...this.tasks.values()].map((t) => ({
         id: t.id,
@@ -3154,7 +3457,7 @@ var FlowEngine = class {
   }
   /**
    * fork — 현재 상태를 정확히 복제한 새 엔진 (디지털트윈 본연: "현재로부터 예측").
-   * 원본(live/sim)은 계속 진행, fork 는 what-if 를 앞으로 굴려 forecast·발산(predicted vs actual) 검사에 쓴다.
+   * 원본(live/sim)은 계속 진행, fork 는 what-if 를 앞으로 시뮬레이션해 forecast·발산(predicted vs actual) 검사에 쓴다.
    * fork 는 자기 구독자·시나리오를 갖고 원본과 격리(handlers·gens 비움, generating=false).
    * rng 는 fork 의 시나리오 load 시 재시드(드레인 예측은 생성 없어 rng 무관·결정적).
    */
@@ -3180,7 +3483,7 @@ var FlowEngine = class {
    * 이 커널의 **지금**(ms) — 시각으로 바뀌는 모든 판정의 단일 기준.
    *
    * ── 관측 모드에서 시계가 멈춰 있었다 ────────────────────────────────────
-   * `apply()` 는 `clockMs` 를 밀지 않는다(관측은 시간을 굴리지 않는다). 그래서 라이브 트윈의 "지금" 이
+   * `apply()` 는 `clockMs` 를 밀지 않는다(관측은 시간을 진행시키지 않는다). 그래서 라이브 트윈의 "지금" 이
    * **BASE_EPOCH(2026-01-01)에 얼어 있었다.** 실 이벤트는 실제 시각을 달고 오므로 결과가 이렇게 된다:
    *  · **납기 초과를 영원히 보고하지 않는다** — 실 납기가 항상 미래로 보인다
    *  · 폐기·도입예정 판정이 틀린다(§EffectivePeriod)
@@ -3217,14 +3520,14 @@ var FlowEngine = class {
     return max <= min ? min : min + Math.floor(this.rng() * (max - min + 1));
   }
   /**
-   * 관측 구동(P0 스파이크) — **이벤트로 커널을 굴린다.**
+   * 관측 구동(P0 스파이크) — **이벤트로 커널을 실행한다.**
    *
    * 상태를 만드는 구동이 둘인데(시뮬 `tick` / 미러 `apply`) 지금은 **모델도 둘**이라 한쪽만 고치면
-   * 갈라진다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
+   * 어긋난다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
    * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
    *
    * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
-   * (`hydrateObserved`)로 커널 상태에 심는다. 그래서 관측으로 굴린 커널을 그대로 `fork`·`tick` 할 수
+   * (`hydrateObserved`)로 커널 상태에 주입한다. 그래서 관측으로 실행한 커널을 그대로 `fork`·`tick` 할 수
    * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
    *
    * **비용은 정직하게**: 이벤트마다 전체를 다시 심으므로 O(상태 크기)다. P1 에서 반영 로직을 순수
@@ -3280,14 +3583,14 @@ var FlowEngine = class {
     return void 0;
   }
   /**
-   * **이 공장이 하루 몇 대를 낼 수 있는가** — 굴려 보지 않고 답한다.
+   * **이 공장이 하루 몇 대를 낼 수 있는가** — 실행해 보지 않고 답한다.
    *
    * 커널이 직접 답하는 이유: 필요한 사실이 전부 여기 있다(공정 명세·설비와 신뢰도·인원·물리자산·
    * 자리·근무 달력·시각 기준). 밖에서 모으면 그 값을 옮겨 적게 되고, 한쪽만 바뀌는 순간 "충분하다"
    * 가 조용히 거짓이 된다. 계산 자체는 순수 함수(`analyzeCapacity`)에 맡긴다.
    *
    * 달력은 **자원이 선언한 것**을 쓴다. 자원마다 다른 달력을 쓰는 현장이면 대표를 고를 수 없으므로
-   * 그 사실을 결과에 실어 보낸다(`mixedCalendars`) — 조용히 하나를 골라 계산하면 천장이 틀린 채로
+   * 그 사실을 결과에 실어 보낸다(`mixedCalendars`) — 조용히 하나를 골라 계산하면 상한이 틀린 채로
    * 그럴듯해 보인다.
    */
   capacity(opts) {
@@ -3375,7 +3678,7 @@ var FlowEngine = class {
   /**
    * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
    *
-   * 이 순서인 이유: 실측에서 배운 값이 선언값을 이기고, 선언값이 우리가 코드에 박아 둔 상수를 이긴다.
+   * 이 순서인 이유: 실측에서 배운 값이 선언값을 이기고, 선언값이 우리가 코드에 고정한 상수를 이긴다.
    * 셋 중 무엇을 썼는지는 `specCoverage()` 로 드러낸다 — 상수를 쓴 것이 조용히 넘어가지 않게.
    * "얼마"만 소비하고 "경로"는 씬이 소유한다(좌표-free 유지).
    */
@@ -3458,7 +3761,7 @@ var FlowEngine = class {
     else this.specUse.set(kind, { duration: "default", params: /* @__PURE__ */ new Set([id]) });
   }
   /**
-   * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 박아 둔 상수인가.**
+   * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 코드에 고정한 상수인가.**
    *
    * 시뮬레이션 결과를 받는 쪽이 이걸 봐야 한다: 소요시간이 전부 기본값이면 그 예측으로 말할 수 있는 것은
    * "같은 조건에서의 상대 비교" 뿐이고 "몇 시에 끝난다" 는 근거가 없다. 그 구분을 숫자로 드러낸다.
@@ -3554,7 +3857,7 @@ var FlowEngine = class {
     this.observeDisposition(epcs, DISP.reserved, bizStep);
   }
   /**
-   * 처분 변화 관측 — **상태와 이벤트를 한 번에.** 둘을 따로 쓰면 반드시 갈라진다.
+   * 처분 변화 관측 — **상태와 이벤트를 한 번에.** 둘을 따로 쓰면 반드시 어긋난다.
    *
    * 실제로 양쪽으로 갈라져 있었다: 할당은 상태만 바꾸고 이벤트를 안 냈고(미러가 모름), 야드 도크
    * 도착은 이벤트만 내고 상태를 안 바꿨다(이벤트와 상태가 다른 말). 적합성 하네스가 둘 다 잡았다.
@@ -3808,7 +4111,7 @@ var FlowEngine = class {
     }
     return picked;
   }
-  /** 확보한 자산을 작업에 묶는다 — 싣는 물류단위(SSCC)가 있으면 연결한다(GRAI ↔ SSCC). */
+  /** 확보한 자산을 작업에 배정한다 — 싣는 물류단위(SSCC)가 있으면 연결한다(GRAI ↔ SSCC). */
   assignAssets(t, gear) {
     if (!gear.length) return;
     t.assets = gear;
@@ -3946,7 +4249,7 @@ var FlowEngine = class {
    * 이 작업이 **딛고 선 것**이 아직 있나 — 없으면 무엇이 없는지 답한다.
    *
    * 작업은 혼자 서지 못한다: 옮길 **물품**과, (있다면) 그것을 시킨 **오더** 위에 선다. 진행 중에
-   * 둘 중 하나가 사라질 수 있다 — 물품은 포장·출하·소비로, 오더는 이미 이행돼 씨앗이 심지 않아서.
+   * 둘 중 하나가 사라질 수 있다 — 물품은 포장·출하·소비로, 오더는 이미 이행돼 씨앗이 주입하지 않아서.
    *
    * 그때 도메인 훅은 없는 것을 딛으려다 던진다(`order.gtin` · `item.location`). 그 예외 하나가
    * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
@@ -4056,7 +4359,7 @@ var FlowEngine = class {
    * 자원 하나의 **가용 능력** — 계약의 판정에 이 커널의 시각·시간대·필수 시험을 채워 넘긴다.
    *
    * 배정도 스냅샷도 이 자리를 지난다. 예전에는 배정이 조건을 늘어놓고 화면이 플래그를 보고 짐작해서,
-   * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(놀고 있는 것은 맞지만 쓸 수 있는 것은 아니다).
+   * **자격이 만료된 사람이 화면에서는 `대기` 로 보였다**(대기 중인 것은 맞지만 쓸 수 있는 것은 아니다).
    * 판정에 필요한 둘(시각·등급 상속)을 아는 것은 커널뿐이므로, 답도 커널이 낸다.
    */
   capabilityOfResource(r, directClassIds, defs, at = this.now()) {
@@ -4121,7 +4424,7 @@ var FlowEngine = class {
     }
     return picked.length ? picked : null;
   }
-  /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
+  /** 확보한 사람을 작업에 배정한다(설비까지 확정된 뒤). */
   assignCrew(t, crew) {
     if (!crew.length) return;
     t.personnel = crew;
@@ -4172,7 +4475,7 @@ var FlowEngine = class {
    * 유효 기간 밖인가 — **네 번째 이유**(§Effectivity). 설비·사람·자산이 같은 규칙을 쓴다.
    *
    * 시뮬 시각을 ISO 로 풀어 계약의 `effectivityAt` 에 넘긴다. **판정은 커널에 두지 않는다** —
-   * 호스트(라이브 관측)도 같은 판정을 해야 하고, 규칙이 두 벌이면 갈라진다.
+   * 호스트(라이브 관측)도 같은 판정을 해야 하고, 규칙이 두 벌이면 어긋난다.
    */
   effectivityOf(r) {
     if (!r.effectiveStart && !r.effectiveEnd) return void 0;
@@ -4193,7 +4496,7 @@ var FlowEngine = class {
   /**
    * 스냅샷·델타에 실을 조각 — **선언한 기간과 판정을 함께** 낸다.
    *
-   * 판정만 내면 화면이 "왜" 를 말할 수 없고(언제 폐기됐나), 기간만 내면 소비처마다 다시 판정해 갈라진다.
+   * 판정만 내면 화면이 "왜" 를 말할 수 없고(언제 폐기됐나), 기간만 내면 소비처마다 다시 판정해 어긋난다.
    * 선언이 없으면 아무것도 붙이지 않는다(대부분의 자원이 그렇다 — 필드를 늘리지 않는다).
    */
   effectivePart(r) {
@@ -4209,7 +4512,7 @@ var FlowEngine = class {
    * 지금 근무 시간 밖인가 — **캘린더가 있으면 그것으로, 없으면 옛 `window` 로** 판정한다.
    *
    * `window`(시 단위 하나)는 캘린더의 특수한 경우다. 둘을 한 함수로 모아 두면 인원·설비가 같은 규칙을
-   * 쓴다(예전에는 같은 식이 두 곳에 복사돼 있었다 — 한쪽만 고치면 조용히 갈라진다).
+   * 쓴다(예전에는 같은 식이 두 곳에 복사돼 있었다 — 한쪽만 고치면 조용히 어긋난다).
    */
   offCalendar(r) {
     return offCalendarAt(r, this.nowMs(), this.boardDef?.utcOffsetMinutes);
@@ -4680,7 +4983,7 @@ var WmsKernel = class extends FlowEngine {
    * 자재는 **작업이 일어나는 자리에** 있어야 소비되고, 산출물은 `in_progress` 로 태어나 **팔 수 있는
    * 재고가 아니다.** 그래서 부품을 작업대로 옮기고, 가공하고, 나온 것을 보관 자리로 되돌린다.
    *
-   * **한 오더에 사슬 하나만** 굴린다. 매 tick 마다 다시 발행하면 같은 부품을 두 번 끌어오는 작업이
+   * **한 오더에 사슬 하나만** 실행한다. 매 tick 마다 다시 발행하면 같은 부품을 두 번 끌어오는 작업이
    * 쌓이고, 그중 하나만 성공한 뒤 나머지는 영원히 재료를 기다린다.
    */
   makeShortLines(o) {
@@ -4701,7 +5004,7 @@ var WmsKernel = class extends FlowEngine {
       if (plan.steps.length) return;
     }
   }
-  /** 이 오더가 굴리고 있는 생산 사슬이 있나 — 이송·가공·되돌리기 중 하나라도 열려 있으면 그렇다. */
+  /** 이 오더가 실행 중인 생산 사슬이 있나 — 이송·가공·되돌리기 중 하나라도 열려 있으면 그렇다. */
   hasOpenMakeChain(orderId) {
     for (const t of this.tasks.values()) {
       if (t.orderId !== orderId || t.status === "completed") continue;
@@ -4748,7 +5051,7 @@ var WmsKernel = class extends FlowEngine {
    * 들여놓는 것**이다: 산출물은 `in_progress` 로 태어나 팔 수 있는 재고가 아니다.
    *
    * ── 왜 팔레트로 묶나 ───────────────────────────────────────────────────────
-   * 코어의 산출은 **클래스+수량 줄**이고 그 키에는 자리가 박혀 있다(`품목@자리`). 창고의 출고 경로는
+   * 코어의 산출은 **클래스+수량 줄**이고 그 키에는 자리가 고정되어 있다(`품목@자리`). 창고의 출고 경로는
    * 직렬 물류단위(팔레트 SSCC)를 다루므로, 그 줄을 그대로 출고에 태우면 키를 EPC 로 착각해 조회가
    * 깨진다(실제로 그렇게 터졌다). 억지로 태우면 EPCIS 에도 **EPC 가 아닌 문자열**이 `epcList` 로
    * 나가는데, 그것은 코어가 산출에서 경계한 바로 그 일이다.
@@ -5020,7 +5323,7 @@ var MesKernel = class extends FlowEngine {
    * **산출을 두 곳에서 만들지 않는다** — 기동 때 막는다.
    *
    * MES 는 레시피로 산출을 만든다: WIP 사슬(스텝마다 앞의 WIP 을 먹고 다음 WIP 을 낸다) · **직렬번호**
-   * (회사 프리픽스 + 일련번호) · **수율**(양품/불량이 처분을 가른다) · 생산오더 연결. 코어의 일반
+   * (회사 프리픽스 + 일련번호) · **수율**(양품/불량이 처분을 구분한다) · 생산오더 연결. 코어의 일반
    * 자재 명세(`use: 'produced'`)는 **비직렬 클래스+수량**이라 그 넷을 표현하지 못한다.
    *
    * 그래서 MES 를 일반 선언으로 옮기지 않는다 — 옮기면 정체성·수율·오더 연결을 **잃는다**(§4-20).
@@ -5114,7 +5417,7 @@ var MesKernel = class extends FlowEngine {
   /**
    * MES 는 완료 시점에 **오더와 제품 정의**를 딛고 선다 — 둘 중 하나만 없어도 끝맺을 수 없다.
    *
-   * 씨앗이 이미 이행된 오더를 심지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
+   * 씨앗이 이미 이행된 오더를 주입하지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
    * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 던졌고 **그 예외
    * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
    */
@@ -5270,6 +5573,445 @@ var MesKernel = class extends FlowEngine {
   }
 };
 
+// src/ems-kernel.ts
+var DEMAND_WINDOW_MS = 15 * 60 * 1e3;
+var demandWindowStart = (atMs, windowMs = DEMAND_WINDOW_MS) => Math.floor(atMs / windowMs) * windowMs;
+function windowMsOf(opts) {
+  const raw = typeof opts === "number" ? opts : opts?.windowMs;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : DEMAND_WINDOW_MS;
+}
+var KEEP_CLOSED = 96;
+var EmsKernel = class extends FlowEngine {
+  points = /* @__PURE__ */ new Map();
+  open;
+  closed = [];
+  closedTotal = 0;
+  peak;
+  /** 이 구간에서 이미 제안을 냈나 — 같은 사실을 되풀어 방송하지 않는다(라이브 브리지의 교훈). */
+  suggestedFor;
+  windowMs;
+  /**
+   * ── 세 번째 인자는 **호스트가 정한 자리**다 (2026-08-14 실측으로 고침) ──────
+   *
+   * 호스트는 모든 커널을 한 모양으로 세운다: `new Kernel(tenantId, undefined, productionSpecOf(model))`.
+   * 즉 세 번째 인자는 **도메인 옵션 슬롯**이고 커널마다 뜻이 다르다(야드는 모드, 생산은 명세).
+   *
+   * 처음에 이 자리를 `windowMs: number` 로 받았다가, 라이브에서 **모든 수요 구간이 깨졌다** —
+   * 생산 명세 객체가 창 길이로 들어와 `startMs: null`·`endMs: NaN` 이 됐다. 내 시험은 커널을
+   * `new EmsKernel('t')` 로 직접 세웠기 때문에 그것을 잡지 못했다(호스트와 다른 방식으로 세운 것이
+   * 그 자체로 결함이었다).
+   *
+   * 그래서 **쓸 수 있는 것만 읽는다**: 수면 창 길이로 쓰고, 객체면 `windowMs` 를 찾고, 없으면 기본값
+   * (15분)이다. 모르는 것을 창 길이로 삼지 않는다.
+   */
+  constructor(tenantId, policy = firstFitPolicy, opts) {
+    super(tenantId, policy);
+    this.windowMs = windowMsOf(opts);
+  }
+  /**
+   * 계약전력 — **현장이 선언한 자리 속성**에서 읽는다(`EMS_PROPERTY.contractKW`).
+   *
+   * 여러 자리가 선언하면 **가장 큰 값**을 쓴다: 수전 지점의 계약이 분기의 것보다 크고, 트윈 전체의
+   * 한계는 수전이 정한다. 선언이 없으면 `undefined` — 계약을 모르면 계약 대비 판정을 하지 않는다
+   * (기본값을 지어내면 그 뒤 모든 판정이 거짓 위에 선다).
+   */
+  declaredContractKW() {
+    let max;
+    for (const loc of this.boardDef?.locations ?? []) {
+      for (const p of loc.properties ?? []) {
+        if (p.id !== EMS_PROPERTY.contractKW) continue;
+        const v = Number(p.value);
+        if (!Number.isFinite(v) || v <= 0) continue;
+        if (max === void 0 || v > max) max = v;
+      }
+    }
+    return max;
+  }
+  /**
+   * 계측 표본을 받는다 — 에너지 사건만 가로채고 나머지는 그대로 상위에 넘긴다.
+   *
+   * 가로챈 표본은 **다시 방출하지 않는다**: 원천이 이미 그 사실을 갖고 있고, 저널은 인입에서 한 번만
+   * 적는다(상위 `apply` 의 재방출 규약과 같은 이유).
+   */
+  apply(envelope) {
+    if (envelope.eventType === ENERGY_EVENT.measured) {
+      this.ingestMeasured(envelope);
+      return;
+    }
+    super.apply(envelope);
+  }
+  ingestMeasured(envelope) {
+    const d = envelope.data;
+    const atMs = [String(d?.at ?? ""), String(envelope.eventTime ?? "")].map((v) => Date.parse(v)).find((v) => Number.isFinite(v));
+    if (atMs === void 0) throw new Error("energy.measured has no usable time (data.at / eventTime) \u2014 cannot place it in a demand window");
+    const id = String(d?.meterId ?? "").trim();
+    if (!id) throw new Error("energy.measured has no meterId \u2014 a measurement with no meter cannot be accumulated");
+    this.closeDue(atMs);
+    this.openWindow(atMs);
+    const kW = Number.isFinite(Number(d?.kW)) ? Number(d.kW) : void 0;
+    const point = this.points.get(id) ?? { id, samplesInWindow: 0 };
+    if (point.atMs === void 0 || atMs >= point.atMs) {
+      point.atMs = atMs;
+      if (kW !== void 0) point.kW = kW;
+      if (Number.isFinite(Number(d?.kWh))) point.kWh = Number(d.kWh);
+      if (Number.isFinite(Number(d?.powerFactor))) point.powerFactor = Number(d.powerFactor);
+    }
+    point.samplesInWindow++;
+    this.points.set(id, point);
+    const w = this.open;
+    if (kW !== void 0) {
+      const total = [...this.points.values()].reduce((sum, p) => sum + (p.kW ?? 0), 0);
+      if (w.maxKW === void 0 || total > w.maxKW) w.maxKW = total;
+      w.samples++;
+      w.meanKW = w.meanKW === void 0 ? total : (w.meanKW * (w.samples - 1) + total) / w.samples;
+    }
+    this.revision++;
+    this.judgeOpenWindow(atMs);
+  }
+  openWindow(atMs) {
+    const start = demandWindowStart(atMs, this.windowMs);
+    if (this.open?.startMs === start) return;
+    const contractKW = this.declaredContractKW();
+    this.open = { startMs: start, endMs: start + this.windowMs, samples: 0, ...contractKW !== void 0 ? { contractKW } : {} };
+    for (const p of this.points.values()) p.samplesInWindow = 0;
+    this.suggestedFor = void 0;
+  }
+  /**
+   * 지난 구간을 닫는다 — **표본이 없으면 값을 만들지 않는다.**
+   *
+   * 침묵한 구간을 「0 kW」로 닫으면 그 트윈은 「그 15분 동안 전기를 쓰지 않았다」고 말하는 것이 된다.
+   * 구간이 지난 것은 사실이고 우리가 못 쟀다는 것도 사실이므로, 구간은 남기고 값은 비운다.
+   *
+   * 표본이 오지 않으면 마감도 오지 않는다(라이브에서 계측이 끊기면 열린 구간이 그대로 남는다).
+   * 그래서 이것은 **공개**다 — 호스트가 시각을 주며 부를 수 있다(`tick` 도 이것을 부른다).
+   */
+  closeDue(nowMs) {
+    const done = [];
+    while (this.open && nowMs >= this.open.endMs) {
+      const w = this.open;
+      if (w.contractKW !== void 0 && w.maxKW !== void 0) w.overContract = w.maxKW > w.contractKW;
+      this.closed.push(w);
+      this.closedTotal++;
+      if (this.closed.length > KEEP_CLOSED) this.closed.splice(0, this.closed.length - KEEP_CLOSED);
+      done.push(w);
+      this.emitOp(ENERGY_EVENT.demandWindow, {
+        startMs: w.startMs,
+        endMs: w.endMs,
+        ...w.maxKW !== void 0 ? { maxKW: w.maxKW } : {},
+        ...w.meanKW !== void 0 ? { meanKW: w.meanKW } : {},
+        samples: w.samples,
+        ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {},
+        ...w.overContract !== void 0 ? { overContract: w.overContract } : {},
+        /*
+         * 부하를 셀 근거가 없었다는 사실을 코드로 낸다 — 화면이 「0 kW」와 「못 쟀다」를 구별할 수 있게.
+         *
+         * 이름이 조건과 정확히 같아야 한다: `samples` 는 **kW 를 실은 표본**의 수다. 표본은 왔는데
+         * kW 를 못 읽은 경우(계기 오류·필드 누락)가 실제로 있고, 그것은 「아무것도 오지 않았다」와
+         * 다르다. 무엇이 왔는지는 지점별 `samplesInWindow` 가 답한다.
+         */
+        ...w.samples === 0 ? { observedAbsence: "no-load-samples" } : {}
+      });
+      if (w.maxKW !== void 0 && (this.peak === void 0 || w.maxKW > this.peak.kW)) {
+        this.peak = { kW: w.maxKW, windowStartMs: w.startMs };
+        this.emitOp(ENERGY_EVENT.peak, { kW: w.maxKW, windowStartMs: w.startMs, ...w.contractKW !== void 0 ? { contractKW: w.contractKW } : {} });
+      }
+      this.open = void 0;
+    }
+    return done;
+  }
+  /**
+   * 열린 구간의 판정 — **이대로 가면 계약을 넘는가.**
+   *
+   * 예측은 「지금까지의 평균 부하가 구간 끝까지 이어진다」다. 단순하지만 그 가정을 **값과 함께 낸다**
+   * (`projectionBasis`) — 근거를 감춘 예측은 사용자가 검증할 수 없다. 남은 시간이 짧을수록 이 예측은
+   * 실제에 가까워진다(구간 초반의 경보는 성급할 수 있다는 뜻이고, 그것도 사용자가 알아야 한다).
+   *
+   * 넘을 것 같으면 **제안**을 낸다 — 무엇을 줄일 수 있는지는 모델이 선언한 감축 가능 설비가 답한다.
+   * 우리는 끄지 않는다.
+   */
+  judgeOpenWindow(atMs) {
+    const w = this.open;
+    if (!w || w.contractKW === void 0 || w.meanKW === void 0) return;
+    if (this.suggestedFor === w.startMs) return;
+    const elapsed = Math.max(1, atMs - w.startMs);
+    const projected = (w.meanKW * elapsed + w.meanKW * (w.endMs - atMs)) / this.windowMs;
+    if (projected <= w.contractKW) return;
+    this.suggestedFor = w.startMs;
+    this.emitOp(ENERGY_EVENT.drSuggested, {
+      windowStartMs: w.startMs,
+      projectedKW: projected,
+      contractKW: w.contractKW,
+      gapKW: projected - w.contractKW,
+      projectionBasis: "mean-so-far",
+      /* 줄일 수 있는 것 — 선언된 감축 가능 설비다. 우선순위·최소 유지는 현장이 정하므로 여기서
+         고르지 않고 **후보를 있는 대로** 낸다(고르는 것은 사람의 일이다). */
+      curtailableCandidates: this.curtailableIds()
+    });
+  }
+  /** 감축 가능으로 **선언된** 설비 — 커널이 능력을 짐작하지 않는다(타입이 선언한다). */
+  curtailableIds() {
+    return (this.boardDef?.equipment ?? []).filter((e) => String(e.kind ?? "") === "curtailable-load").map((e) => e.id);
+  }
+  /*
+   * ── 흐름 훅 넷 — **상속의 대가다** (§6 안 A) ─────────────────────────────
+   *
+   * `FlowEngine` 은 이 넷을 abstract 로 요구한다: 도착·오더·배정·작업 완료. 에너지에는 그 넷이 없다
+   * (물건이 도착하지 않고, 주문이 없고, 배정할 자원이 없고, 완료될 작업이 없다). 그래서 여기서
+   * **아무 일도 하지 않는다** — 그런데 조용히 넘기지 않는다: 이 커널이 그런 요청을 받았다는 것은
+   * **배선이 잘못됐다는 사실**이고(EMS 트윈에 물류 명령을 보낸 것), 조용히 넘기면 그 사실이 사라진다.
+   *
+   * 던지지도 않는다: 저널 재생 중이라면 트윈 전체가 멈춘다. 그래서 커널이 담을 줄 모르는 사건을
+   * 세는 자리(`ObservedReducer.unhandled`)와 같은 규율으로, **개수를 세어 상태로 낸다.**
+   */
+  flowRequests = /* @__PURE__ */ new Map();
+  noteFlowRequest(hook) {
+    this.flowRequests.set(hook, (this.flowRequests.get(hook) ?? 0) + 1);
+  }
+  onArrival() {
+    this.noteFlowRequest("onArrival");
+  }
+  onOrder() {
+    this.noteFlowRequest("onOrder");
+  }
+  allocate() {
+    this.noteFlowRequest("allocate");
+  }
+  onTaskComplete() {
+    this.noteFlowRequest("onTaskComplete");
+  }
+  /** 시뮬 시간으로도 구간이 닫힌다 — 관측이 없어도 시간은 간다. */
+  tick(dtMs) {
+    super.tick(dtMs);
+    this.closeDue(this.clockMs);
+  }
+  getSnapshot() {
+    const snap = super.getSnapshot();
+    const contractKW = this.declaredContractKW();
+    const energy = {
+      points: [...this.points.values()].map((p) => ({ ...p })),
+      ...this.open ? {
+        open: {
+          ...this.open,
+          ...this.open.meanKW !== void 0 ? { projectedKW: this.open.meanKW, projectionBasis: "mean-so-far" } : {}
+        }
+      } : {},
+      closed: this.closed.map((w) => ({ ...w })),
+      closedTotal: this.closedTotal,
+      ...this.peak ? { peakSince: { ...this.peak } } : {},
+      ...contractKW !== void 0 ? { contractKW } : {},
+      /* 물류 흐름 요청을 받은 적이 있나 — 있으면 이 트윈에 엉뚱한 명령이 오고 있다는 사실이다. */
+      ...this.flowRequests.size ? { flowRequests: [...this.flowRequests.entries()].map(([hook, count]) => ({ hook, count })) } : {}
+    };
+    return { ...snap, energy };
+  }
+};
+
+// src/energy-ingest.ts
+function isEnergyRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.meterId === "string" && r.meterId.trim().length > 0 && r.epc === void 0;
+}
+function ingestEnergyRecords(records, opts) {
+  const arr = Array.isArray(records) ? records : records ? [records] : [];
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const record of arr) {
+    const errors = [];
+    const meterId = String(record?.meterId ?? "").trim();
+    if (!meterId) errors.push("meterId \uC5C6\uC74C \u2014 \uC5B4\uB514\uC758 \uC18C\uBE44\uC778\uC9C0 \uBAA8\uB974\uB294 \uAC12\uC740 \uB204\uC801\uD560 \uC218 \uC5C6\uB2E4");
+    const at = String(record?.at ?? "").trim() || opts.defaultEventTime;
+    const atMs = at ? Date.parse(at) : Number.NaN;
+    if (!Number.isFinite(atMs)) errors.push("at \uC5C6\uC74C/\uD615\uC2DD \uC624\uB958 \u2014 \uC9C0\uAE08 \uC2DC\uAC01\uC73C\uB85C \uBA54\uC6B0\uBA74 \uB0A8\uC758 \uC218\uC694 \uAD6C\uAC04\uC5D0 \uC2E4\uB9B0\uB2E4");
+    const num = (v, name) => {
+      if (v === void 0 || v === null || v === "") return void 0;
+      const n = Number(v);
+      if (!Number.isFinite(n)) {
+        errors.push(`${name} \uAC00 \uC218\uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+        return void 0;
+      }
+      return n;
+    };
+    const kW = num(record?.kW, "kW");
+    const kWh = num(record?.kWh, "kWh");
+    const powerFactor = num(record?.powerFactor, "powerFactor");
+    if (errors.length) {
+      rejected.push({ record, errors });
+      continue;
+    }
+    const eventTime = new Date(atMs).toISOString();
+    const data = {
+      meterId,
+      /* 계약은 `kW` 를 필수로 두지만 **못 읽은 표본도 사실**이다 — 그 경우 값을 비우고 보낸다.
+         커널이 「받았지만 부하를 못 읽었다」로 세고, 구간 마감에 그 이유를 싣는다. */
+      ...kW !== void 0 ? { kW } : {},
+      ...kWh !== void 0 ? { kWh } : {},
+      ...powerFactor !== void 0 ? { powerFactor } : {},
+      at: eventTime
+    };
+    accepted.push({
+      eventId: `${opts.tenantId}-energy-${++seq}`,
+      eventType: ENERGY_EVENT.measured,
+      eventTime,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+
+// src/energy-attribution.ts
+var near = (a, b, eps = 1e-9) => Math.abs(a - b) <= eps;
+function attributeEnergy(opts) {
+  const byId = new Map(opts.consumers.map((c) => [c.id, c]));
+  const dedicated = /* @__PURE__ */ new Map();
+  for (const c of opts.consumers) if (c.meterId) dedicated.set(c.meterId, c);
+  const shares = [];
+  const unattributed = [];
+  const excluded = [];
+  const overhead = [];
+  for (const pool of opts.pools) {
+    const kWh = Number(pool.kWh);
+    if (!Number.isFinite(kWh)) continue;
+    const own = dedicated.get(pool.meterId);
+    if (own) {
+      shares.push({ consumerId: own.id, kWh, basis: "measured", poolMeterId: pool.meterId });
+      continue;
+    }
+    if (pool.overhead) {
+      const alloc = opts.overheadAllocation;
+      const targets = (alloc?.processConsumerIds ?? []).map((id) => byId.get(id)).filter((c) => !!c);
+      const wOf = (c) => alloc?.weightKind === "equal" ? 1 : Number.isFinite(Number(c.weight)) && Number(c.weight) > 0 ? Number(c.weight) : 0;
+      const sharing2 = alloc?.weightKind === "equal" ? targets : targets.filter((c) => wOf(c) > 0);
+      const ws = sharing2.map(wOf);
+      const total = ws.reduce((a, b) => a + b, 0);
+      if (!alloc || total <= 0) {
+        overhead.push({ poolMeterId: pool.meterId, kWh });
+        continue;
+      }
+      let done = 0;
+      sharing2.forEach((c, i) => {
+        const share = ws[i] / total;
+        const amount = i === sharing2.length - 1 ? kWh - done : kWh * share;
+        done += amount;
+        shares.push({
+          consumerId: c.id,
+          kWh: amount,
+          basis: "apportioned",
+          poolMeterId: pool.meterId,
+          weightKind: alloc.weightKind,
+          weightShare: share,
+          overhead: true
+        });
+      });
+      continue;
+    }
+    const covered = (pool.consumerIds ?? []).map((id) => byId.get(id)).filter((c) => !!c);
+    if (!covered.length) {
+      unattributed.push({ poolMeterId: pool.meterId, kWh, reason: "no-consumers" });
+      continue;
+    }
+    if (covered.length === 1) {
+      shares.push({ consumerId: covered[0].id, kWh, basis: "measured", poolMeterId: pool.meterId });
+      continue;
+    }
+    const kind = opts.weightKind;
+    const weightOf = (c) => kind === "equal" ? 1 : Number.isFinite(Number(c.weight)) && Number(c.weight) > 0 ? Number(c.weight) : 0;
+    const sharing = kind === "equal" ? covered : covered.filter((c) => weightOf(c) > 0);
+    if (kind && sharing.length < covered.length) {
+      for (const c of covered) if (weightOf(c) <= 0) excluded.push({ consumerId: c.id, poolMeterId: pool.meterId, reason: "zero-weight" });
+    }
+    const weights = sharing.map(weightOf);
+    const sum = weights.reduce((a, b) => a + b, 0);
+    if (!kind || sum <= 0) {
+      unattributed.push({
+        poolMeterId: pool.meterId,
+        kWh,
+        reason: "no-weights",
+        consumerIds: covered.map((c) => c.id)
+      });
+      continue;
+    }
+    let given = 0;
+    sharing.forEach((c, i) => {
+      const share = weights[i] / sum;
+      const amount = i === sharing.length - 1 ? kWh - given : kWh * share;
+      given += amount;
+      shares.push({
+        consumerId: c.id,
+        kWh: amount,
+        basis: "apportioned",
+        poolMeterId: pool.meterId,
+        weightKind: kind,
+        weightShare: share
+      });
+    });
+  }
+  const measuredKWh = opts.pools.reduce((a, p) => a + (Number.isFinite(Number(p.kWh)) ? Number(p.kWh) : 0), 0);
+  const attributedKWh = shares.reduce((a, s) => a + s.kWh, 0);
+  const unattributedKWh = unattributed.reduce((a, u) => a + u.kWh, 0);
+  const overheadKWh = overhead.reduce((a, o) => a + o.kWh, 0);
+  if (!near(attributedKWh + unattributedKWh + overheadKWh, measuredKWh, 1e-6)) {
+    throw new Error(
+      `energy attribution lost or created energy: measured=${measuredKWh} attributed=${attributedKWh} unattributed=${unattributedKWh} overhead=${overheadKWh}`
+    );
+  }
+  return { shares, unattributed, excluded, overhead, totals: { measuredKWh, attributedKWh, unattributedKWh, overheadKWh } };
+}
+var UNIT = {
+  output: "kWh/unit",
+  runtimeHours: "kW",
+  area: "kWh/m2"
+};
+function energyIntensity(input) {
+  const kWh = Number(input.kWh);
+  if (!Number.isFinite(kWh)) return { value: null, reason: "no-energy" };
+  const den = Number(input.denominator?.value);
+  if (!Number.isFinite(den)) return { value: null, reason: "no-denominator" };
+  const ew = input.energyWindow;
+  const dw = input.denominator?.window;
+  if (ew && dw && (ew.startMs !== dw.startMs || ew.endMs !== dw.endMs)) return { value: null, reason: "window-mismatch" };
+  if (den === 0) return { value: null, reason: "zero-denominator" };
+  const window = ew ?? dw;
+  return {
+    value: kWh / den,
+    unit: UNIT[input.denominator.kind] ?? "kWh",
+    kWh,
+    denominator: den,
+    ...window ? { window } : { window: { startMs: 0, endMs: 0 } }
+  };
+}
+function energyOfWindows(windows, range) {
+  const inRange = (w) => !range || w.startMs >= range.startMs && w.endMs <= range.endMs;
+  let kWh = 0;
+  let counted = 0;
+  let skipped = 0;
+  let first;
+  let last;
+  for (const w of windows ?? []) {
+    if (!inRange(w)) continue;
+    const mean = Number(w.meanKW);
+    const hours = (Number(w.endMs) - Number(w.startMs)) / 36e5;
+    if (!Number.isFinite(mean) || !Number.isFinite(hours) || hours <= 0) {
+      skipped++;
+      continue;
+    }
+    kWh += mean * hours;
+    counted++;
+    if (first === void 0 || w.startMs < first) first = w.startMs;
+    if (last === void 0 || w.endMs > last) last = w.endMs;
+  }
+  return {
+    ...counted > 0 ? { kWh } : {},
+    basis: "mean-kw",
+    counted,
+    skipped,
+    ...first !== void 0 && last !== void 0 ? { window: { startMs: first, endMs: last } } : {}
+  };
+}
+
 // src/vocabulary.ts
 var RETIRED_VOCABULARY = ["mover", "Mover", "MOVER", "node", "Node", "NODE"];
 var VOCABULARY_EXCEPTIONS = [
@@ -5322,11 +6064,18 @@ function retiredVocabularyIn(line) {
   CAPABILITY_KEYS,
   CBV_BIZSTEP,
   CMD,
+  DEMAND_WINDOW_MS,
   DISP,
   DOMAIN_CATALOG,
   DOMAIN_SYSTEMS,
+  EMS_EQUIPMENT_TYPES,
+  EMS_LOCATION_TYPES,
+  EMS_PROPERTY,
+  EMS_TYPES,
+  ENERGY_EVENT,
   EPCIS_CONTEXT,
   EQUIPMENT_LEVEL,
+  EmsKernel,
   EventJournal,
   FlowEngine,
   GUARD_PRAGMA,
@@ -5365,6 +6114,9 @@ function retiredVocabularyIn(line) {
   activeShiftOf,
   aggregationEvent,
   analyzeCapacity,
+  attributeEnergy,
+  axesOfSystem,
+  axisAppliesTo,
   axisInfo,
   axisSource,
   capabilitiesForType,
@@ -5375,10 +6127,13 @@ function retiredVocabularyIn(line) {
   constantDuration,
   conversionFactorOf,
   counterfactualAt,
+  demandWindowStart,
   deriveAttentions,
   documentPath,
   dueStatusOf,
   effectivityAt,
+  energyIntensity,
+  energyOfWindows,
   fefoPolicy,
   firstFitPolicy,
   foldJobResponses,
@@ -5389,9 +6144,12 @@ function retiredVocabularyIn(line) {
   inWorkCalendar,
   inWorkCalendarAt,
   ingest,
+  ingestEnergyRecords,
+  isEnergyRecord,
   isEquipmentLevel,
   isoDurationHours,
   itemKeyOf,
+  levelOfLocationType,
   lgtinClass,
   locationStatusOf,
   mapRecord,