@operato/twin-kernel 0.11.25 → 0.11.27

package/dist-cjs/index.cjs

@@ -1044,7 +1044,26 @@ var BIZSTEP = {
   packing: "urn:epcglobal:cbv:bizstep:packing",
   staging_outbound: "urn:epcglobal:cbv:bizstep:staging_outbound",
   shipping: "urn:epcglobal:cbv:bizstep:shipping",
-  replenishing: "urn:epcglobal:cbv:bizstep:replenishing"
+  /**
+   * **Replenishment** — moving goods to where they are picked from. CBV has no `replenishing`; this contract
+   * wrote one until 2026-09-24, and the closed-list test found it. CBV `stocking` is the step that means it:
+   * "…within a location to make an object available to the customer or for order fulfilment within a DC"
+   * (CBV ontology, `BizStep-stocking`). Ruled by the chief architect; no reader branches on the value, and
+   * the journal keeps what it already wrote (ADR-0038).
+   */
+  stocking: "urn:epcglobal:cbv:bizstep:stocking",
+  /**
+   * **Counted, and the book set to the count** — CBV `cycle_counting`. Primary source: the CBV ontology
+   * (gs1/EPCIS `Ontology/CBV.ttl`, `cbv:BizStep-cycle_counting`, also served at ref.gs1.org/cbv): "Process of
+   * counting objects within a location in order to obtain an accurate inventory for business needs other
+   * than accounting purposes (e.g., replenishment and allocation)."
+   *
+   * **Only for an event somebody actually counted** (chief architect, 2026-09-24). A person correcting the
+   * book without counting is `CBV_BIZSTEP.other` with the reason carried as a value — `epcis.ts` says why:
+   * writing that as `cycle_counting` records a count that never happened. A count for the accounts is a
+   * different CBV step (`stock_taking`) and is not this one.
+   */
+  cycle_counting: "urn:epcglobal:cbv:bizstep:cycle_counting"
 };
 var BTT = {
   /** Purchase Order — the document an inbound receipt is made against. */
@@ -1092,634 +1111,212 @@ var WMS_TYPES = [
   { key: "packer", role: "equipment", label: "twin.type.packer", standardClass: { epcis: "object", isa95: "Equipment" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
-// ../ops-contract/dist/yms-profile.js
-var YARD_BIZSTEP = {
-  arriving: "urn:epcglobal:cbv:bizstep:arriving",
-  // 게이트-인
-  staging: "urn:epcglobal:cbv:bizstep:staging",
-  // 야드 슬롯 주차·대기
-  loading: "urn:epcglobal:cbv:bizstep:loading",
-  // 도크 작업(상차: 트레일러←화물)
-  unloading: "urn:epcglobal:cbv:bizstep:unloading",
-  // 도크 작업(하차: 트레일러→화물)
-  departing: "urn:epcglobal:cbv:bizstep:departing"
-  // 게이트-아웃
-};
-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" }, 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"] }
-];
-
-// ../ops-contract/dist/mes-profile.js
-var MES_BIZSTEP = {
-  receiving: "urn:epcglobal:cbv:bizstep:receiving",
-  // 원자재 수령
-  producing: "urn:epcglobal:cbv:bizstep:commissioning",
-  // 생산(제품 최초 생성)
-  storing: "urn:epcglobal:cbv:bizstep:storing"
-  // 완제품 저장
-};
-var BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
-function sgtinUri(companyPrefix, itemRef, serial) {
-  return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
-}
-var MES_LOCATION_TYPES = ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
-var MES_LOCATION_CLS = {
-  "raw-store": { epcis: "bizLocation" },
-  "cut-station": { isa95: "WorkCenter", epcis: "bizLocation" },
-  "weld-station": { isa95: "WorkCenter", epcis: "bizLocation" },
-  "paint-booth": { isa95: "WorkCenter", epcis: "bizLocation" },
-  "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" }, 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"] },
-  { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
-];
-
-// ../ops-contract/dist/ems-profile.js
-var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
-var METER_DIRECTION = ["import", "export", "bidirectional"];
-var EMS_PROPERTY = {
-  /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
-  contractKW: "contract.kW",
-  /*
-   * ── 계량 지점의 방향 (2026-08-25) ──────────────────────────────────────────
-   * **요금은 계통 접속점의 순 유입에 매겨진다.** 그러니 그 지점의 계량기가 무엇을 재는지 모르면
-   * 요금을 사실대로 말할 수 없다 — 내보낸 양을 쓴 양으로 세면 계약 대비 판단이 반대로 뒤집힌다.
+// ../ops-contract/dist/epcis.js
+var EPCIS_CONTEXT = "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld";
+var UTC_OFFSET = "+00:00";
+var DISP = {
+  in_progress: "urn:epcglobal:cbv:disp:in_progress",
+  sellable: "urn:epcglobal:cbv:disp:sellable_accessible",
+  reserved: "urn:epcglobal:cbv:disp:reserved",
+  in_transit: "urn:epcglobal:cbv:disp:in_transit",
+  non_sellable: "urn:epcglobal:cbv:disp:non_sellable_other",
+  // 불량/scrap
+  /**
+   * **기한이 지났다** — CBV `expired`.
    *
-   * 이 축이 없는 동안 계량 지점의 kW 를 전부 부하로 셌다. 상계 거래를 하는 현장, 축전지를 붙인 현장,
-   * 열병합이 있는 현장 — 접속점 계량기가 양쪽을 재는 곳은 늘 있다.
+   * ── 왜 `non_sellable` 로 계산하지 않나 (2026-08-24) ─────────────────────────────
+   * 커널의 `non_sellable` 은 CBV 의 `non_sellable_other`, 즉 **「그 밖의 이유」**다. 기한 지남을 거기
+   * 넣으면 「기한이 지나 못 판다」와 「깨져서 못 판다」가 같은 값이 되고, 화면은 회수·폐기의 사유를
+   * 구별할 수 없다. 식품에서 그 둘은 다른 조치다.
    *
-   * **발전기를 계량기로 만드는 것과 다른 일이다.** 발전은 설비의 사실이고(`energyGenerating`), 그것을
-   * 계량 지점으로 보내는 것은 여전히 하지 않는다. 이 축은 **접속점 계량기**가 무엇을 재는지 말하는
-   * 자리다.
+   * 그리고 표준에 **정확한 낱말이 있다** — 합치는 것은 있는 낱말을 버리는 것이다.
    *
-   * 방향은 **관측이 아니라 선언**이다. 표본마다 바뀌는 값이 아니고, 그 계량기가 무엇을 재도록
-   * 설치되었는지는 현장이 안다. 그래서 표본(`EnergyRecord`)에 넣지 않고 자원 속성으로 둔다.
+   * ── 기한 날짜와 다른 축이다 ────────────────────────────────────────────────
+   * `ItemState.expiry` 는 **날짜**이고 이것은 **상태**다. 날짜가 있으면 「지났나」는 파생이지만, 원본이
+   * 「기한 지남」을 상태로 선언하는 시스템이 있다 — 그때 이 값은 관측이다.
    *
-   * 값은 계량기 자신의 낱말을 쓴다(적산 레지스터가 그렇게 갈려 있다). §`METER_DIRECTION`.
-   */
-  meterDirection: "meter.direction",
-  /*
-   * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
-   * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
-   * 선언하지 않은 설비는 부하를 만들지 않는다. 기본값을 두면 아무도 그 수가 짐작인 줄 모른 채
-   * 요금 판정이 그 위에 선다.
-   */
-  /** 가동 중 소비(kW). */
-  ratedKW: "power.ratedKW",
-  /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */
-  standbyKW: "power.standbyKW",
-  /*
-   * ── 요금 단가 — 수를 금액으로 바꾸는 선언 (2026-08-17) ─────────────────────
+   * 둘이 어긋나면(날짜는 남았는데 상태가 지남, 또는 그 반대) **어느 쪽이 맞다고 정하지 않는다** —
+   * 아직 그 판정을 세울 근거가 없다. 어긋남의 구분을 없애지 않는 것이 지금의 규율이다.
    *
-   * 그동안 트윈은 「최대수요 328kW」·「전력량 1,547kWh」까지 말하고 멈췄다. 그런데 피크를 깎는 일이
-   * 돈이 되는 이유는 **요금이 둘로 나뉘기** 때문이다: 사용량(kWh)에 붙는 요금과 **최대수요(kW)에 붙는
-   * 기본요금**. 단가가 없으면 그 절반을 말할 수 없고, 그래서 「피크를 깎아 얼마를 아끼나」에 답하지 못했다.
+   * ── 원문으로 확인했다 (2026-08-24) ────────────────────────────────────────
+   * 1차 출처: **CBV Standard Release 2.0, Ratified Jun 2022** §7.2.3 처분 값 표(38개). 이 객체의
+   * 다른 값들(`in_progress`·`sellable_accessible`·`reserved`·`in_transit`·`non_sellable_other`)도
+   * 그 표에 있다.
    *
-   * 단가는 **현장의 계약**이다(같은 나라 안에서도 사업자·요금제마다 다르다). 그래서 기본값을 두지
-   * 않는다 — 선언하지 않으면 금액을 계산하지 않는다. 짐작한 단가로 낸 금액은 숫자가 있다는 것만으로
-   * 사람을 결정으로 밀어붙인다.
+   * **`non_sellable_expired` 를 쓰지 않는 이유**: 그 값은 CBV 1.0 의 것이고 표준이 **폐기**했다 —
+   * 「deprecated in favour of new disposition values expired, damaged, disposed, … introduced in
+   * CBV 1.1」. 폐기된 값을 쓰면 새 소비처가 읽지 못한다.
    *
-   * 계약전력(`contract.kW`)과 같은 자리(수전)에 선언한다.
+   * 참고: GS1 어휘 등록처(`ref.gs1.org/cbv/…`)로는 확인할 수 없었다 — **없는 값에도 같은 응답**을
+   * 준다(지어낸 값의 JSON-LD 가 실재 값과 바이트까지 같았다). 그 경로를 근거로 삼지 말 것.
    */
-  /** 기본요금 단가 — 최대수요 1kW 당(청구 주기 기준). */
-  demandChargePerKW: "tariff.demandChargePerKW",
+  expired: "urn:epcglobal:cbv:disp:expired",
   /**
-   * **요금적용전력**(kW) — 기본요금이 실제로 매겨지는 기준. 계약전력과 다른 값이다.
-   *
-   * 기본요금이 걸리는 수는 이 주기에 잰 최대가 아닌 경우가 많다 — 지난 몇 달의 최고를 끌고 가거나,
-   * 약정 용량으로 매기거나, 사업자가 따로 정한다. 그 규칙은 나라와 계약마다 다르므로 커널이 계산하지
-   * 않고 **계산된 결과를 받는다.** 이 값이 있으면 기본요금이 조건부 파생이 아니라 사실이 된다.
-   *
-   * 계약전력(`contract.kW`)을 이 자리에 넣지 말 것. 넘었을 때의 뜻이 다르다 — 계약 초과는 약정
-   * 위반이고, 이쪽은 다음 주기의 기본요금이 오른다는 뜻이다.
-   */
-  billingDemandKW: "tariff.billingDemandKW",
-  /** 사용량 단가 — 1kWh 당. */
-  energyChargePerKWh: "tariff.energyChargePerKWh",
-  /** 통화 — ISO 4217 코드(USD·KRW…). 없으면 금액에 단위를 붙이지 않는다. */
-  currency: "tariff.currency",
-  /*
-   * ── 축전지의 용량과 방전 정책 (2026-08-17) ─────────────────────────────────
-   *
-   * 「배터리로 피크를 깎는다」를 시뮬이 보이려면 방전을 만들어야 하고, 그것은 **선언에서** 나와야 한다.
-   * 임계·최대율·예비를 우리가 정하면 그 수가 어디서 왔는지 아무도 설명할 수 없다.
-   *
-   * ── 선언한다는 것은 「그 자동화가 있다」는 주장이다 ─────────────────────────
-   * 이 정책을 모델에 적으면 **라이브가 아닌 모든 구동이 그 규칙으로 돈다.** 현장에 BESS 제어기가 없는데
-   * 적으면 파생 부하가 실제보다 낙관적으로 나온다(피크가 깎인 것으로 보인다). 그러니 「도입하면?」을
-   * 묻는 것이라면 선언이 아니라 **what-if 가 덮어쓸 일**이다.
-   *
-   * 용량이 없으면 방전하지 않는다 — 용량을 모르면 「얼마나 버티나」를 답할 수 없고, 버티는 시간을
-   * 모른 채 깎으면 무한히 깎을 수 있다고 주장하는 셈이다.
+   * **폐기됐다 — 남은 것이 없다.** CBV `destroyed` (CBV ontology, `Disp-destroyed`), with the step
+   * `CBV_BIZSTEP.destroying`. Ruled 2026-09-24, shape from plant: the disposition belongs to the quantity
+   * **observed**, which is what is left. A partial scrap leaves the rest `in_progress`; only the last of it —
+   * nothing left — is `destroyed`. Putting it on a remainder would say sound goods were thrown away.
    */
-  /** 축전지 용량(kWh) — SOC 를 에너지로 바꾸는 값. 없으면 방전을 만들지 않는다. */
-  capacityKWh: "storage.capacityKWh",
-  /** 이 순수요를 넘으면 방전한다(kW) — 피크 억제 임계. */
-  dischargeAboveKW: "dispatch.dischargeAboveKW",
-  /** 최대 방전율(kW) — 인버터가 낼 수 있는 한계. */
-  maxDischargeKW: "dispatch.maxDischargeKW",
-  /** 예비 SOC(%) — 이 아래로는 쓰지 않는다(비상 대비). 없으면 0 으로 본다. */
-  reserveSoc: "dispatch.reserveSoc",
+  destroyed: "urn:epcglobal:cbv:disp:destroyed",
   /**
-   * 시뮬레이션이 **출발할 때의 SOC(%)** — 씨앗값이다.
+   * **검사에 합격했다 / 불합격했다** — CBV `conformant` / `non_conformant`.
    *
-   * 계측이 SOC 를 알려 주는 트윈에는 필요 없다(잰 값이 진실이다). 시뮬 트윈에는 알려 줄 것이 없어서
-   * 「SOC 를 모르면 방전하지 않는다」는 규율에 걸려 **배터리가 아무 일도 하지 못했다** — 정책을 선언해도
-   * 피크가 한 톨도 깎이지 않았다(실화면에서 그렇게 났다).
+   * 1차 출처(CBV 2.0 §7.2.3) 정의 그대로다.
    *
-   * 이것은 상태의 씨앗이지 계측이 아니다. 그래서 계측이 들어오는 순간 그것이 이긴다.
-   */
-  initialSoc: "storage.initialSoc",
-  /*
-   * ── 발전 — 태양광이 서 있기만 하던 자리 (2026-08-18) ────────────────────────
+   *   conformant       Outcome of a successful/passed inspection in an inspecting or repairing step
+   *   non_conformant   Outcome of an unsuccessful/failed inspection in an inspecting or repairing step
    *
-   * 계통도에 태양광을 그려 놓고 시뮬에서는 한 톨도 만들지 못했다. 미러는 원천이 발전량을 보내 주지만,
-   * 시뮬 트윈에는 그것을 만들 근거가 없었다 — 그래서 「태양광을 늘리면 피크가 얼마나 내려가나」를 물을 수
-   * 없었다(what-if 의 값이 절반만 성립했다).
+   * ── 왜 시험 결과 축을 자원에 더하지 않고 이것을 쓰나 (2026-08-24) ────────────
+   * 로트의 검사 판정을 담을 자리를 찾다가 `ItemState.testResults` 를 더하려 했다. 그런데 표준은 그
+   * 사실을 **이미 처분으로 말한다**: `bizStep: inspecting` 사건에 이 처분이 붙는다.
    *
-   * **형상을 우리가 지어내지 않는다.** 위도·계절·날씨로 곡선을 만들면 그 수가 어디서 왔는지 아무도
-   * 설명할 수 없고, 흐린 날 현장의 실적과 어긋난다. 그래서 현장이 **하루 형상을 적는다**: 24개 비율
-   * (0~1)이면 그것이 그 현장의 곡선이다(측정한 형상을 그대로 붙일 수 있다).
+   * 처분을 쓰면 두 가지가 공짜로 성립한다.
+   *   ① **상태 ⊆ 이벤트** — 처분은 이미 사건에서 온다. 상태에만 있는 축을 만들지 않는다
+   *   ② **운영에 곧 닿는다** — 「이 자재를 쓸 수 있나」가 처분으로 답해진다(판정을 따로 읽지 않는다)
    *
-   * 정격만 있고 형상이 없으면 발전하지 않는다 — 하루 종일 정격으로 발전하는 태양광은 없다.
+   * 시험의 **자세한 내용**(어느 명세로, 무엇을 재어)은 다른 물음이고, 표준은 그것을 `TestResult` 로
+   * 두며 결과가 대상을 가리킨다(`TestableObjectID`) — 대상이 결과를 들지 않는다. 그 축이 필요해지면
+   * 그때 열되, **판정 자체는 여기서 끝난다.**
    */
+  conformant: "urn:epcglobal:cbv:disp:conformant",
+  non_conformant: "urn:epcglobal:cbv:disp:non_conformant"
+};
+var HATIOLAB_VOCABULARY = "https://hatiolab.com/voc/";
+var PRIVATE_BIZSTEP = {
+  /** 공정에 자재가 들어갔다 — ISA-95 `MaterialUse: Consumed`. */
+  consuming: `${HATIOLAB_VOCABULARY}bizstep/consuming`
+};
+var CBV_BIZSTEP = {
+  /* 소비(`consuming`)는 CBV 에 없어 `PRIVATE_BIZSTEP` 으로 갔다(2026-09-24). */
   /**
-   * 발전 정격(kW) — **교류 쪽 최대 출력**. 계통으로 나가는 값이다.
-   *
-   * 이용률의 분모가 이 값이다(만든 양 ÷ 정격 × 시간). **직류 쪽 정격(§`genRatedKWdc`)과 다르고 더 작다** —
-   * 두 값을 한 이름에 담으면 이용률이 그 차이만큼 틀리고, 틀린 이유가 아무 데도 표시되지 않는다.
-   *
-   * 설비마다 선언하거나, 설비별 값을 모르는 현장은 **자리(수전)에 합계로** 선언한다.
+   * **폐기 — 물건이 끝났다.** CBV `destroying`: "Process of terminating an object. For an instance-level
+   * identifier, the object should not be the subject of subsequent events" (CBV ontology, `BizStep-destroying`).
+   * Ruled 2026-09-24 (chief architect) — plant wrote scrapping as `other`; the warehouse's disposal door uses the
+   * same step. Not a count, and not a correction: the goods are gone.
    */
-  genRatedKW: "generation.ratedKW",
+  destroying: "urn:epcglobal:cbv:bizstep:destroying",
+  /** 새 물품이 생겨 계보가 시작된다 — ISA-95 `MaterialUse: Produced`. */
+  commissioning: "urn:epcglobal:cbv:bizstep:commissioning",
   /**
-   * 발전 정격(kW) — **직류 쪽**. 변환기(인버터)의 입력 쪽 정격이고, 태양광이면 패널 정격의 합이다.
+   * **검사** — CBV `inspecting`. 1차 출처(CBV 2.0) 정의: 「Process of reviewing objects to address
+   * potential physical or documentation defects」이고, 「표본과 달리 검사된 대상은 그대로 남는다」고
+   * 이어진다(즉 검사는 물건을 소비하지 않는다).
    *
-   * 이용률의 분모로 쓰지 않는다. 이 값이 교류 정격보다 큰 것은 설계이고(변환기를 그렇게 고른다),
-   * 그 차이가 「맑은 정오에도 교류 출력이 더 오르지 않는 이유」를 설명한다.
+   * 이 단계에 `DISP.conformant`/`DISP.non_conformant` 가 붙어 판정이 처분으로 남는다 — 입고검수·
+   * 공정 중 검사가 그 모양이다.
    */
-  genRatedKWdc: "generation.ratedKWdc",
+  inspecting: "urn:epcglobal:cbv:bizstep:inspecting",
   /**
-   * 하루 형상 — 쉼표로 나눈 **24개 비율**(0~1). 시각(현장 시간대)의 정격 대비 출력이다.
+   * **어느 단계로도 이름 붙지 않는 활동** — 원문: 「A business step not identified by any other」.
    *
-   * 예: `0,0,0,0,0,0,0.05,0.2,0.45,0.7,0.9,1,1,0.95,0.8,0.6,0.35,0.12,0.02,0,0,0,0,0`
+   * 이것은 근사가 아니라 **표준이 준 낱말**이다. 그 구별이 중요하다: 재고 조정처럼 한 낱말이 두 일을
+   * 하는 원천(세어 보고 맞춘 것 · 사람이 정정한 것)을 `cycle_counting` 으로 옮기면 **일어나지 않은
+   * 계수를 기록**하게 된다. 그때 쓰는 것이 이 값이고, 무슨 일이었는지는 값으로 함께 나른다.
+   *
+   * 원문 확인: CBV Standard Release 2.0(Ratified Jun 2022) §7.1.
    */
-  genDailyProfile: "generation.dailyProfile"
+  other: "urn:epcglobal:cbv:bizstep:other"
 };
-var EMS_PROPERTY_SPEC = {
-  [EMS_PROPERTY.contractKW]: { uom: "kW", dataType: "xs:double", note: "contracted power at the metering point, in kW." },
-  /* 값이 셋 중 하나여야 한다 — 그 밖의 낱말은 받지 않는다(뜻이 통할 것 같은 말도 받지 않는다). */
-  [EMS_PROPERTY.meterDirection]: {
-    dataType: "xs:string",
-    note: 'what this metering point measures: "import" (drawn from the grid), "export" (generation sent out), or "bidirectional" (one meter for both, sign carries the direction). Left undeclared, the point counts as load \u2014 leaving it out never makes demand look smaller than it is.'
-  },
-  [EMS_PROPERTY.ratedKW]: { uom: "kW", dataType: "xs:double", note: "power drawn while running, in kW." },
-  [EMS_PROPERTY.standbyKW]: { uom: "kW", dataType: "xs:double", note: "power drawn while idle, in kW." },
-  [EMS_PROPERTY.demandChargePerKW]: { dataType: "xs:double", note: "demand charge per kW of billing-period peak, in the declared currency." },
-  [EMS_PROPERTY.billingDemandKW]: {
-    uom: "kW",
-    dataType: "xs:double",
-    note: "billing demand in kW \u2014 the basis the demand charge is actually billed on (often a rolling 12-month peak). Not the contracted power."
-  },
-  [EMS_PROPERTY.energyChargePerKWh]: { dataType: "xs:double", note: "energy charge per kWh, in the declared currency." },
-  [EMS_PROPERTY.currency]: { dataType: "xs:string", note: "ISO 4217 currency code, e.g. USD or KRW." },
-  [EMS_PROPERTY.capacityKWh]: { uom: "kWh", dataType: "xs:double", note: "usable energy of the storage, in kWh." },
-  [EMS_PROPERTY.dischargeAboveKW]: { uom: "kW", dataType: "xs:double", note: "net demand above which the storage discharges, in kW." },
-  [EMS_PROPERTY.maxDischargeKW]: { uom: "kW", dataType: "xs:double", note: "inverter limit on discharge rate, in kW." },
-  /* 퍼센트다 — 0.8 은 0.8% 이고 80% 가 아니다. 이 한 줄이 없어서 배터리가 조용히 비어 있었다. */
-  [EMS_PROPERTY.reserveSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "reserve state of charge as a percentage 0-100 (20 means 20%), never discharged below." },
-  [EMS_PROPERTY.initialSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "starting state of charge as a percentage 0-100 (80 means 80%, not 0.8)." },
-  [EMS_PROPERTY.genRatedKW]: {
-    uom: "kW",
-    dataType: "xs:double",
-    note: "rated AC generation output, in kW \u2014 the denominator of capacity factor. Declare per equipment, or on the incoming location as a site total."
-  },
-  [EMS_PROPERTY.genRatedKWdc]: {
-    uom: "kW",
-    dataType: "xs:double",
-    note: "rated DC generation capacity, in kW (panel rating for PV). Larger than the AC rating by design; not the capacity-factor denominator."
-  },
-  [EMS_PROPERTY.genDailyProfile]: {
-    dataType: "xs:string",
-    note: "daily shape as 24 comma-separated fractions of rated output (0-1), one per hour of local time \u2014 the site declares its own curve; we do not invent one."
-  }
+function sgtinClass(companyPrefix, itemRef) {
+  return `urn:epc:idpat:sgtin:${companyPrefix}.${itemRef}.*`;
+}
+var ILMD_ATTR = {
+  /** 유통기한·만료(로트 단위). */
+  expiry: "cbvmda:itemExpirationDate",
+  /** 로트·배치 번호(직렬 개체에 로트를 붙일 때). */
+  lot: "cbvmda:lotNumber"
 };
-function generationFractionAt(profile, hourOfDay) {
-  const parts = String(profile ?? "").split(",").map((v2) => v2.trim()).filter((v2) => v2 !== "");
-  if (parts.length !== 24)
-    return void 0;
-  const h = Math.floor(hourOfDay);
-  if (!Number.isFinite(h) || h < 0 || h > 23)
+function lgtinClass(companyPrefix, itemRefAndIndicator, lot) {
+  return `urn:epc:class:lgtin:${companyPrefix}.${itemRefAndIndicator}.${encodeURIComponent(lot)}`;
+}
+function parseEpc(uri) {
+  const raw = String(uri ?? "");
+  if (/(?:\/obj\/|:obj:)[^/:\s]+$/.test(raw))
+    return { scheme: "unknown", instance: true, uri: raw };
+  const inHouseClass = raw.match(/(?:\/class\/|:class:)([^/:\s]+)$/);
+  if (inHouseClass) {
+    const at = inHouseClass[1].indexOf(LOT_SEPARATOR);
+    const split = at > 0 ? decodedPair(inHouseClass[1].slice(0, at), inHouseClass[1].slice(at + LOT_SEPARATOR.length)) : void 0;
+    return split ? { scheme: "unknown", instance: false, item: split[0], lot: split[1], uri: raw } : { scheme: "unknown", instance: false, uri: raw };
+  }
+  const cls = raw.match(/^urn:epc:class:lgtin:(.+)$/);
+  if (cls) {
+    const seg = cls[1].split(".");
+    const lot = seg.slice(2).join(".");
+    return {
+      scheme: "lgtin",
+      instance: false,
+      gtinKey: seg.slice(0, 2).join("."),
+      lot: lot ? decodeURIComponent(lot) : void 0,
+      uri: raw
+    };
+  }
+  const pat = raw.match(/^urn:epc:idpat:sgtin:(.+)$/);
+  if (pat) {
+    const seg = pat[1].split(".");
+    return { scheme: "idpat", instance: false, gtinKey: seg.slice(0, 2).join("."), uri: raw };
+  }
+  const id = raw.match(/^urn:epc:id:([a-z]+):(.+)$/);
+  if (id) {
+    const scheme = id[1];
+    const seg = id[2].split(".");
+    const known = ["sgtin", "sscc", "gdti", "grai", "giai", "sgln"].includes(scheme);
+    return {
+      scheme: known ? scheme : "unknown",
+      instance: true,
+      ...scheme === "sgtin" ? { gtinKey: seg.slice(0, 2).join("."), serial: seg[2] } : { serial: seg.slice(1).join(".") },
+      uri: raw
+    };
+  }
+  return { scheme: "unknown", instance: false, uri: raw };
+}
+function decodedPair(item, lot) {
+  if (!lot)
     return void 0;
-  const v = Number(parts[h]);
-  if (!Number.isFinite(v) || v < 0 || v > 1)
+  try {
+    return [decodeURIComponent(item), decodeURIComponent(lot)];
+  } catch {
     return void 0;
-  return v;
+  }
 }
-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).
-     * 상태를 읽어 계통 구성을 알 뿐이다.
-     *
-     * 능력은 `switching` 이다 — `operable` 이 아니다(2026-08-14). `operable` 이던 동안 저작면이 차단기에
-     * **제어 컴포넌트**를 권했다: 우리가 하지 않기로 한 조작을 화면이 부추긴 것이다. 「위치를 읽는다」와
-     * 「명령을 받는다」는 다른 능력이고, 이제 그 둘이 갈려 있다(capability.ts 주석).
-     */
-    standardClass: { iec61850: "XCBR", iso55000: "Asset" },
-    identity: { scheme: "kernel:id" },
-    capabilities: ["switching"]
-  },
-  {
-    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: ["energyGenerating", "metered", "operable"]
-  },
-  {
-    key: "battery",
-    role: "equipment",
-    label: "twin.type.battery",
-    /* 축전지(ESS) — `ZBAT`. 충전·방전을 나눠 재고, 저장은 보관(`storable`)이 아니다(물건이 아니다). */
-    standardClass: { iec61850: "ZBAT", iso55000: "Asset" },
-    identity: { scheme: "kernel:id" },
-    capabilities: ["energyStoring", "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"]
+function itemClassOf(uri) {
+  if (!uri)
+    return void 0;
+  const parsed = parseEpc(uri);
+  if (parsed.scheme === "lgtin" && parsed.gtinKey)
+    return `urn:epc:idpat:sgtin:${parsed.gtinKey}.*`;
+  if (parsed.item !== void 0) {
+    const marker = /^(.*(?:\/class\/|:class:))[^/:\s]+$/.exec(parsed.uri);
+    if (marker)
+      return `${marker[1]}${parsed.item.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c])}`;
   }
-];
-function electricalUpstreamOf(locations, id) {
-  const byId2 = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
-  const self = byId2.get(String(id));
-  if (!self)
+  return parsed.uri;
+}
+function lotClassOfItem(itemClass, lot) {
+  if (!itemClass)
     return void 0;
-  if (self.upstreamId)
-    return String(self.upstreamId);
-  const parent = self.parentId ? byId2.get(String(self.parentId)) : void 0;
-  if (!parent)
+  const idpat = /^urn:epc:idpat:sgtin:(\d+)\.(\d+)\.\*$/.exec(itemClass);
+  if (idpat)
+    return lotClassUri({ namespace: "", item: "", lot, gtin: `${idpat[1]}.${idpat[2]}` });
+  const parsed = parseEpc(itemClass);
+  if (parsed.instance || parsed.lot !== void 0)
     return void 0;
-  return isElectricalLocationType(String(parent.type ?? "")) ? String(parent.id) : void 0;
+  const url = /^(https?:\/\/.+)\/class\/([^/:\s]+)$/.exec(itemClass);
+  const urn = /^(urn:.+):class:([^/:\s]+)$/.exec(itemClass);
+  const at = url ?? urn;
+  if (!at)
+    return void 0;
+  let item;
+  try {
+    item = decodeURIComponent(at[2]);
+  } catch {
+    return void 0;
+  }
+  return lotClassUri({ namespace: at[1], item, lot });
 }
-function isElectricalLocationType(type) {
-  return EMS_LOCATION_TYPES.includes(type);
-}
-
-// ../ops-contract/dist/domain-catalog.js
-var locationKeys = (types) => types.filter((t) => t.role === "location").map((t) => t.key);
-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) },
-  ems: { system: "ems", label: "twin.system.ems", types: EMS_TYPES, locationTypes: locationKeys(EMS_TYPES) }
-};
-
-// ../ops-contract/dist/domain-definition.js
-var OP_PARAM = {
-  /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
-  yield: "yield",
-  /** 셋업·체인지오버 소요(ISO 8601 기간 문자열). ISA-95 는 셋업을 별도 세그먼트로도 표현하지만,
-   *  현재 커널은 작업에 붙는 셋업으로 다루므로 모수로 받는다. */
-  setupDuration: "setupDuration"
-};
-function procedureViolations(route) {
-  const elements = route.procedure ?? [];
-  if (!elements.length)
-    return [];
-  const errors = [];
-  const byKey = new Map(elements.map((e) => [e.key, e]));
-  const hasChild = new Set(elements.map((e) => e.parent).filter((k) => !!k));
-  const stepSet = new Set(route.steps ?? []);
-  const seenStep = /* @__PURE__ */ new Map();
-  for (const n of elements) {
-    if (n.parent && !byKey.has(n.parent))
-      errors.push(`${n.key}: \uC0C1\uC704 '${n.parent}' \uAC00 \uC774 \uC808\uCC28\uC5D0 \uC5C6\uB2E4`);
-    if (n.step === void 0)
-      continue;
-    if (hasChild.has(n.key))
-      errors.push(`${n.key}: \uC544\uB798 \uC694\uC18C\uAC00 \uC788\uB294\uB370 \uB2E8\uACC4\uB97C \uB4E0\uB2E4 \u2014 \uC2E4\uD589\uB418\uB294 \uAC83\uC740 \uC78E\uBFD0\uC774\uB2E4`);
-    if (!stepSet.has(n.step))
-      errors.push(`${n.key}: \uBAA8\uB974\uB294 \uB2E8\uACC4 '${n.step}' \u2014 steps \uC5D0 \uC5C6\uB2E4`);
-    const already = seenStep.get(n.step);
-    if (already)
-      errors.push(`\uB2E8\uACC4 '${n.step}' \uAC00 '${already}' \uC640 '${n.key}' \uB458\uC5D0 \uC2E4\uB838\uB2E4 \u2014 \uC808\uCC28 \uC5B4\uB514\uC778\uC9C0 \uB9D0\uD560 \uC218 \uC5C6\uB2E4`);
-    else
-      seenStep.set(n.step, n.key);
-  }
-  return errors;
-}
-
-// ../ops-contract/dist/energy-ingest.js
-function resolveSubject(kind, localId, opts) {
-  const declared = opts.identityOf?.(kind, localId);
-  if (declared)
-    return { subject: declared, basis: "declared" };
-  return { subject: opts.scopeId ? `${opts.scopeId}/${localId}` : localId, basis: "twin-local" };
-}
-function periodFactId(tenantId, kind, subject, from, to) {
-  return [tenantId, kind, subject, from, to].join("|");
-}
-
-// ../ops-contract/dist/epcis.js
-var EPCIS_CONTEXT = "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld";
-var UTC_OFFSET = "+00:00";
-var DISP = {
-  in_progress: "urn:epcglobal:cbv:disp:in_progress",
-  sellable: "urn:epcglobal:cbv:disp:sellable_accessible",
-  reserved: "urn:epcglobal:cbv:disp:reserved",
-  in_transit: "urn:epcglobal:cbv:disp:in_transit",
-  non_sellable: "urn:epcglobal:cbv:disp:non_sellable_other",
-  // 불량/scrap
-  /**
-   * **기한이 지났다** — CBV `expired`.
-   *
-   * ── 왜 `non_sellable` 로 계산하지 않나 (2026-08-24) ─────────────────────────────
-   * 커널의 `non_sellable` 은 CBV 의 `non_sellable_other`, 즉 **「그 밖의 이유」**다. 기한 지남을 거기
-   * 넣으면 「기한이 지나 못 판다」와 「깨져서 못 판다」가 같은 값이 되고, 화면은 회수·폐기의 사유를
-   * 구별할 수 없다. 식품에서 그 둘은 다른 조치다.
-   *
-   * 그리고 표준에 **정확한 낱말이 있다** — 합치는 것은 있는 낱말을 버리는 것이다.
-   *
-   * ── 기한 날짜와 다른 축이다 ────────────────────────────────────────────────
-   * `ItemState.expiry` 는 **날짜**이고 이것은 **상태**다. 날짜가 있으면 「지났나」는 파생이지만, 원본이
-   * 「기한 지남」을 상태로 선언하는 시스템이 있다 — 그때 이 값은 관측이다.
-   *
-   * 둘이 어긋나면(날짜는 남았는데 상태가 지남, 또는 그 반대) **어느 쪽이 맞다고 정하지 않는다** —
-   * 아직 그 판정을 세울 근거가 없다. 어긋남의 구분을 없애지 않는 것이 지금의 규율이다.
-   *
-   * ── 원문으로 확인했다 (2026-08-24) ────────────────────────────────────────
-   * 1차 출처: **CBV Standard Release 2.0, Ratified Jun 2022** §7.2.3 처분 값 표(38개). 이 객체의
-   * 다른 값들(`in_progress`·`sellable_accessible`·`reserved`·`in_transit`·`non_sellable_other`)도
-   * 그 표에 있다.
-   *
-   * **`non_sellable_expired` 를 쓰지 않는 이유**: 그 값은 CBV 1.0 의 것이고 표준이 **폐기**했다 —
-   * 「deprecated in favour of new disposition values expired, damaged, disposed, … introduced in
-   * CBV 1.1」. 폐기된 값을 쓰면 새 소비처가 읽지 못한다.
-   *
-   * 참고: GS1 어휘 등록처(`ref.gs1.org/cbv/…`)로는 확인할 수 없었다 — **없는 값에도 같은 응답**을
-   * 준다(지어낸 값의 JSON-LD 가 실재 값과 바이트까지 같았다). 그 경로를 근거로 삼지 말 것.
-   */
-  expired: "urn:epcglobal:cbv:disp:expired",
-  /**
-   * **검사에 합격했다 / 불합격했다** — CBV `conformant` / `non_conformant`.
-   *
-   * 1차 출처(CBV 2.0 §7.2.3) 정의 그대로다.
-   *
-   *   conformant       Outcome of a successful/passed inspection in an inspecting or repairing step
-   *   non_conformant   Outcome of an unsuccessful/failed inspection in an inspecting or repairing step
-   *
-   * ── 왜 시험 결과 축을 자원에 더하지 않고 이것을 쓰나 (2026-08-24) ────────────
-   * 로트의 검사 판정을 담을 자리를 찾다가 `ItemState.testResults` 를 더하려 했다. 그런데 표준은 그
-   * 사실을 **이미 처분으로 말한다**: `bizStep: inspecting` 사건에 이 처분이 붙는다.
-   *
-   * 처분을 쓰면 두 가지가 공짜로 성립한다.
-   *   ① **상태 ⊆ 이벤트** — 처분은 이미 사건에서 온다. 상태에만 있는 축을 만들지 않는다
-   *   ② **운영에 곧 닿는다** — 「이 자재를 쓸 수 있나」가 처분으로 답해진다(판정을 따로 읽지 않는다)
-   *
-   * 시험의 **자세한 내용**(어느 명세로, 무엇을 재어)은 다른 물음이고, 표준은 그것을 `TestResult` 로
-   * 두며 결과가 대상을 가리킨다(`TestableObjectID`) — 대상이 결과를 들지 않는다. 그 축이 필요해지면
-   * 그때 열되, **판정 자체는 여기서 끝난다.**
-   */
-  conformant: "urn:epcglobal:cbv:disp:conformant",
-  non_conformant: "urn:epcglobal:cbv:disp:non_conformant"
-};
-var CBV_BIZSTEP = {
-  /** 공정에 자재가 들어갔다 — ISA-95 `MaterialUse: Consumed`. */
-  consuming: "urn:epcglobal:cbv:bizstep:consuming",
-  /** 새 물품이 생겨 계보가 시작된다 — ISA-95 `MaterialUse: Produced`. */
-  commissioning: "urn:epcglobal:cbv:bizstep:commissioning",
-  /**
-   * **검사** — CBV `inspecting`. 1차 출처(CBV 2.0) 정의: 「Process of reviewing objects to address
-   * potential physical or documentation defects」이고, 「표본과 달리 검사된 대상은 그대로 남는다」고
-   * 이어진다(즉 검사는 물건을 소비하지 않는다).
-   *
-   * 이 단계에 `DISP.conformant`/`DISP.non_conformant` 가 붙어 판정이 처분으로 남는다 — 입고검수·
-   * 공정 중 검사가 그 모양이다.
-   */
-  inspecting: "urn:epcglobal:cbv:bizstep:inspecting",
-  /**
-   * **어느 단계로도 이름 붙지 않는 활동** — 원문: 「A business step not identified by any other」.
-   *
-   * 이것은 근사가 아니라 **표준이 준 낱말**이다. 그 구별이 중요하다: 재고 조정처럼 한 낱말이 두 일을
-   * 하는 원천(세어 보고 맞춘 것 · 사람이 정정한 것)을 `cycle_counting` 으로 옮기면 **일어나지 않은
-   * 계수를 기록**하게 된다. 그때 쓰는 것이 이 값이고, 무슨 일이었는지는 값으로 함께 나른다.
-   *
-   * 원문 확인: CBV Standard Release 2.0(Ratified Jun 2022) §7.1.
-   */
-  other: "urn:epcglobal:cbv:bizstep:other"
-};
-function sgtinClass(companyPrefix, itemRef) {
-  return `urn:epc:idpat:sgtin:${companyPrefix}.${itemRef}.*`;
-}
-var ILMD_ATTR = {
-  /** 유통기한·만료(로트 단위). */
-  expiry: "cbvmda:itemExpirationDate",
-  /** 로트·배치 번호(직렬 개체에 로트를 붙일 때). */
-  lot: "cbvmda:lotNumber"
-};
-function lgtinClass(companyPrefix, itemRefAndIndicator, lot) {
-  return `urn:epc:class:lgtin:${companyPrefix}.${itemRefAndIndicator}.${encodeURIComponent(lot)}`;
-}
-function parseEpc(uri) {
-  const raw = String(uri ?? "");
-  if (/(?:\/obj\/|:obj:)[^/:\s]+$/.test(raw))
-    return { scheme: "unknown", instance: true, uri: raw };
-  const inHouseClass = raw.match(/(?:\/class\/|:class:)([^/:\s]+)$/);
-  if (inHouseClass) {
-    const at = inHouseClass[1].indexOf(LOT_SEPARATOR);
-    const split = at > 0 ? decodedPair(inHouseClass[1].slice(0, at), inHouseClass[1].slice(at + LOT_SEPARATOR.length)) : void 0;
-    return split ? { scheme: "unknown", instance: false, item: split[0], lot: split[1], uri: raw } : { scheme: "unknown", instance: false, uri: raw };
-  }
-  const cls = raw.match(/^urn:epc:class:lgtin:(.+)$/);
-  if (cls) {
-    const seg = cls[1].split(".");
-    const lot = seg.slice(2).join(".");
-    return {
-      scheme: "lgtin",
-      instance: false,
-      gtinKey: seg.slice(0, 2).join("."),
-      lot: lot ? decodeURIComponent(lot) : void 0,
-      uri: raw
-    };
-  }
-  const pat = raw.match(/^urn:epc:idpat:sgtin:(.+)$/);
-  if (pat) {
-    const seg = pat[1].split(".");
-    return { scheme: "idpat", instance: false, gtinKey: seg.slice(0, 2).join("."), uri: raw };
-  }
-  const id = raw.match(/^urn:epc:id:([a-z]+):(.+)$/);
-  if (id) {
-    const scheme = id[1];
-    const seg = id[2].split(".");
-    const known = ["sgtin", "sscc", "gdti", "grai", "giai", "sgln"].includes(scheme);
-    return {
-      scheme: known ? scheme : "unknown",
-      instance: true,
-      ...scheme === "sgtin" ? { gtinKey: seg.slice(0, 2).join("."), serial: seg[2] } : { serial: seg.slice(1).join(".") },
-      uri: raw
-    };
-  }
-  return { scheme: "unknown", instance: false, uri: raw };
-}
-function decodedPair(item, lot) {
-  if (!lot)
-    return void 0;
-  try {
-    return [decodeURIComponent(item), decodeURIComponent(lot)];
-  } catch {
-    return void 0;
-  }
-}
-function itemClassOf(uri) {
-  if (!uri)
-    return void 0;
-  const parsed = parseEpc(uri);
-  if (parsed.scheme === "lgtin" && parsed.gtinKey)
-    return `urn:epc:idpat:sgtin:${parsed.gtinKey}.*`;
-  if (parsed.item !== void 0) {
-    const marker = /^(.*(?:\/class\/|:class:))[^/:\s]+$/.exec(parsed.uri);
-    if (marker)
-      return `${marker[1]}${parsed.item.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c])}`;
-  }
-  return parsed.uri;
-}
-function lotClassOfItem(itemClass, lot) {
-  if (!itemClass)
-    return void 0;
-  const idpat = /^urn:epc:idpat:sgtin:(\d+)\.(\d+)\.\*$/.exec(itemClass);
-  if (idpat)
-    return lotClassUri({ namespace: "", item: "", lot, gtin: `${idpat[1]}.${idpat[2]}` });
-  const parsed = parseEpc(itemClass);
-  if (parsed.instance || parsed.lot !== void 0)
-    return void 0;
-  const url = /^(https?:\/\/.+)\/class\/([^/:\s]+)$/.exec(itemClass);
-  const urn = /^(urn:.+):class:([^/:\s]+)$/.exec(itemClass);
-  const at = url ?? urn;
-  if (!at)
-    return void 0;
-  let item;
-  try {
-    item = decodeURIComponent(at[2]);
-  } catch {
-    return void 0;
-  }
-  return lotClassUri({ namespace: at[1], item, lot });
-}
-function sameItemClass(a, b) {
-  const x = itemClassOf(a);
-  return x !== void 0 && x === itemClassOf(b);
+function sameItemClass(a, b) {
+  const x = itemClassOf(a);
+  return x !== void 0 && x === itemClassOf(b);
 }
 function gdtiUri(companyPrefix, docType, serial) {
   return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
@@ -1743,173 +1340,616 @@ function lotClassUri(input) {
       throw new Error(`lotClassUri: ${wrong}`);
     return uri;
   }
-  if (!item)
-    throw new Error(`lotClassUri: \uD488\uBC88\uC774 \uBE44\uC5C8\uB2E4 (lot=${lot})`);
-  const enc = (v) => v.replace(LOT_COMPONENT_BREAKING, (c) => PERCENT_ENCODED[c]);
-  return joinUnderNamespace(input.namespace, "class", `${enc(item)}${LOT_SEPARATOR}${enc(lot)}`);
-}
-var LOT_SEPARATOR = ";lot=";
-var LOT_COMPONENT_BREAKING = /[%/:?# ;]/g;
-function bizTransactionUri(namespace, transId) {
-  return underNamespace(namespace, "bt", transId);
-}
-var STRUCTURE_BREAKING = /[%/:?# ]/g;
-var PERCENT_ENCODED = {
-  "%": "%25",
-  "/": "%2F",
-  ":": "%3A",
-  "?": "%3F",
-  "#": "%23",
-  " ": "%20",
-  /* 로트 클래스의 가르는 글자 — `lotClassUri` 만 쓴다(§`LOT_COMPONENT_BREAKING`). 표는 한 벌이다. */
-  ";": "%3B"
-};
-function underNamespace(namespace, marker, id) {
-  const raw = String(id);
-  if (!raw)
-    return void 0;
-  return joinUnderNamespace(namespace, marker, raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]));
-}
-function joinUnderNamespace(namespace, marker, v) {
-  const ns = namespace?.trim();
-  if (!ns)
+  if (!item)
+    throw new Error(`lotClassUri: \uD488\uBC88\uC774 \uBE44\uC5C8\uB2E4 (lot=${lot})`);
+  const enc = (v) => v.replace(LOT_COMPONENT_BREAKING, (c) => PERCENT_ENCODED[c]);
+  return joinUnderNamespace(input.namespace, "class", `${enc(item)}${LOT_SEPARATOR}${enc(lot)}`);
+}
+var LOT_SEPARATOR = ";lot=";
+var LOT_COMPONENT_BREAKING = /[%/:?# ;]/g;
+function bizTransactionUri(namespace, transId) {
+  return underNamespace(namespace, "bt", transId);
+}
+var STRUCTURE_BREAKING = /[%/:?# ]/g;
+var PERCENT_ENCODED = {
+  "%": "%25",
+  "/": "%2F",
+  ":": "%3A",
+  "?": "%3F",
+  "#": "%23",
+  " ": "%20",
+  /* 로트 클래스의 가르는 글자 — `lotClassUri` 만 쓴다(§`LOT_COMPONENT_BREAKING`). 표는 한 벌이다. */
+  ";": "%3B"
+};
+function underNamespace(namespace, marker, id) {
+  const raw = String(id);
+  if (!raw)
+    return void 0;
+  return joinUnderNamespace(namespace, marker, raw.replace(STRUCTURE_BREAKING, (c) => PERCENT_ENCODED[c]));
+}
+function joinUnderNamespace(namespace, marker, v) {
+  const ns = namespace?.trim();
+  if (!ns)
+    return void 0;
+  if (/^https?:\/\/[^/\s]+/.test(ns))
+    return `${ns.replace(/\/+$/, "")}/${marker}/${v}`;
+  if (/^urn:epc(global)?:/.test(ns))
+    return void 0;
+  if (/^urn:[^:\s]+/.test(ns))
+    return `${ns.replace(/:+$/, "")}:${marker}:${v}`;
+  return void 0;
+}
+function header(type, eventTime, bizStep, opts) {
+  const h = {
+    "@context": EPCIS_CONTEXT,
+    type,
+    eventTime,
+    eventTimeZoneOffset: UTC_OFFSET,
+    bizStep
+  };
+  if (opts?.eventID)
+    h.eventID = opts.eventID;
+  if (opts?.recordTime)
+    h.recordTime = opts.recordTime;
+  if (opts?.errorDeclaration)
+    h.errorDeclaration = opts.errorDeclaration;
+  if (opts?.bizTransactionList?.length)
+    h.bizTransactionList = opts.bizTransactionList;
+  if (opts?.ilmd)
+    h.ilmd = opts.ilmd;
+  if (opts?.sourceList)
+    h.sourceList = opts.sourceList;
+  if (opts?.destinationList)
+    h.destinationList = opts.destinationList;
+  if (opts?.persistentDisposition)
+    h.persistentDisposition = opts.persistentDisposition;
+  if (opts?.sensorElementList)
+    h.sensorElementList = opts.sensorElementList;
+  if (opts?.certificationInfo)
+    h.certificationInfo = opts.certificationInfo;
+  return h;
+}
+function common(type, eventTime, action, bizStep, opts) {
+  return { ...header(type, eventTime, bizStep, opts), action };
+}
+function objectEvent(p) {
+  const e = { ...common("ObjectEvent", p.eventTime, p.action, p.bizStep, p), epcList: p.epcList };
+  if (p.disposition)
+    e.disposition = p.disposition;
+  if (p.quantityList)
+    e.quantityList = p.quantityList;
+  if (p.readPoint)
+    e.readPoint = { id: p.readPoint };
+  if (p.bizLocation)
+    e.bizLocation = { id: p.bizLocation };
+  if (p.bizTransactionList)
+    e.bizTransactionList = p.bizTransactionList;
+  return e;
+}
+function aggregationEvent(p) {
+  const e = { ...common("AggregationEvent", p.eventTime, p.action, p.bizStep, p), parentID: p.parentID };
+  if (p.disposition)
+    e.disposition = p.disposition;
+  if (p.childEPCs)
+    e.childEPCs = p.childEPCs;
+  if (p.childQuantityList)
+    e.childQuantityList = p.childQuantityList;
+  if (p.readPoint)
+    e.readPoint = { id: p.readPoint };
+  if (p.bizLocation)
+    e.bizLocation = { id: p.bizLocation };
+  return e;
+}
+function transactionEvent(p) {
+  const e = {
+    ...common("TransactionEvent", p.eventTime, p.action, p.bizStep, p),
+    bizTransactionList: p.bizTransactionList
+  };
+  if (p.disposition)
+    e.disposition = p.disposition;
+  if (p.parentID)
+    e.parentID = p.parentID;
+  if (p.epcList)
+    e.epcList = p.epcList;
+  if (p.quantityList)
+    e.quantityList = p.quantityList;
+  if (p.readPoint)
+    e.readPoint = { id: p.readPoint };
+  if (p.bizLocation)
+    e.bizLocation = { id: p.bizLocation };
+  return e;
+}
+function transformationEvent(p) {
+  const e = header("TransformationEvent", p.eventTime, p.bizStep, p);
+  if (p.disposition)
+    e.disposition = p.disposition;
+  if (p.inputEPCList)
+    e.inputEPCList = p.inputEPCList;
+  if (p.inputQuantityList)
+    e.inputQuantityList = p.inputQuantityList;
+  if (p.outputEPCList)
+    e.outputEPCList = p.outputEPCList;
+  if (p.outputQuantityList)
+    e.outputQuantityList = p.outputQuantityList;
+  if (p.transformationID)
+    e.transformationID = p.transformationID;
+  if (p.readPoint)
+    e.readPoint = { id: p.readPoint };
+  if (p.bizLocation)
+    e.bizLocation = { id: p.bizLocation };
+  if (p.bizTransactionList)
+    e.bizTransactionList = p.bizTransactionList;
+  return e;
+}
+var GS1_KEY_DIGITS = { sgtin: 13, lgtin: 13, sscc: 17, grai: 12, gdti: 12, sgln: 12 };
+function gs1KeyDigitViolation(uri) {
+  if (!uri)
+    return void 0;
+  const m = /^urn:epc:(?:id|idpat|class):([a-z]+):([^:]+)$/.exec(uri);
+  if (!m)
+    return void 0;
+  const want = GS1_KEY_DIGITS[m[1]];
+  if (!want)
+    return void 0;
+  const parts = m[2].split(".");
+  if (parts.length < 2)
+    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uAC00 '.' \uB85C \uAC08\uB824\uC57C \uD55C\uB2E4`;
+  const [prefix, ref] = parts;
+  if (ref === "*")
+    return void 0;
+  if (!/^\d+$/.test(prefix) || !/^\d+$/.test(ref)) {
+    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uB294 \uC22B\uC790\uB2E4`;
+  }
+  const got = prefix.length + ref.length;
+  if (got === want)
+    return void 0;
+  return `${m[1]} \uC790\uB9AC \uC218 \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4(${prefix.length}) + \uCC38\uC870(${ref.length}) = ${got} \uC774\uC9C0\uB9CC ${want} \uC5EC\uC57C \uD55C\uB2E4(GS1 TDS). \uD504\uB9AC\uD53D\uC2A4\uB97C \uBC14\uAFB8\uBA74 \uCC38\uC870 \uC790\uB9AC \uC218\uB97C \uD568\uAED8 \uB9DE\uCDB0\uC57C \uD55C\uB2E4.`;
+}
+
+// ../ops-contract/dist/yms-profile.js
+var YARD_BIZSTEP = {
+  arriving: "urn:epcglobal:cbv:bizstep:arriving",
+  // 게이트-인
+  loading: "urn:epcglobal:cbv:bizstep:loading",
+  // 도크 작업(상차: 트레일러←화물)
+  unloading: "urn:epcglobal:cbv:bizstep:unloading",
+  // 도크 작업(하차: 트레일러→화물)
+  departing: "urn:epcglobal:cbv:bizstep:departing"
+  // 게이트-아웃
+};
+var YARD_PRIVATE_BIZSTEP = {
+  staging: `${HATIOLAB_VOCABULARY}bizstep/staging`
+  // 야드 슬롯 주차·대기
+};
+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" }, 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"] }
+];
+
+// ../ops-contract/dist/mes-profile.js
+var MES_BIZSTEP = {
+  receiving: "urn:epcglobal:cbv:bizstep:receiving",
+  // 원자재 수령
+  producing: "urn:epcglobal:cbv:bizstep:commissioning",
+  // 생산(제품 최초 생성)
+  storing: "urn:epcglobal:cbv:bizstep:storing"
+  // 완제품 저장
+};
+var BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
+function sgtinUri(companyPrefix, itemRef, serial) {
+  return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
+}
+var MES_LOCATION_TYPES = ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
+var MES_LOCATION_CLS = {
+  "raw-store": { epcis: "bizLocation" },
+  "cut-station": { isa95: "WorkCenter", epcis: "bizLocation" },
+  "weld-station": { isa95: "WorkCenter", epcis: "bizLocation" },
+  "paint-booth": { isa95: "WorkCenter", epcis: "bizLocation" },
+  "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" }, 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"] },
+  { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
+];
+
+// ../ops-contract/dist/ems-profile.js
+var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
+var METER_DIRECTION = ["import", "export", "bidirectional"];
+var EMS_PROPERTY = {
+  /** 계약전력(kW) — 수전·분기 자리에 선언한다. 없으면 계약 대비 판정을 하지 않는다. */
+  contractKW: "contract.kW",
+  /*
+   * ── 계량 지점의 방향 (2026-08-25) ──────────────────────────────────────────
+   * **요금은 계통 접속점의 순 유입에 매겨진다.** 그러니 그 지점의 계량기가 무엇을 재는지 모르면
+   * 요금을 사실대로 말할 수 없다 — 내보낸 양을 쓴 양으로 세면 계약 대비 판단이 반대로 뒤집힌다.
+   *
+   * 이 축이 없는 동안 계량 지점의 kW 를 전부 부하로 셌다. 상계 거래를 하는 현장, 축전지를 붙인 현장,
+   * 열병합이 있는 현장 — 접속점 계량기가 양쪽을 재는 곳은 늘 있다.
+   *
+   * **발전기를 계량기로 만드는 것과 다른 일이다.** 발전은 설비의 사실이고(`energyGenerating`), 그것을
+   * 계량 지점으로 보내는 것은 여전히 하지 않는다. 이 축은 **접속점 계량기**가 무엇을 재는지 말하는
+   * 자리다.
+   *
+   * 방향은 **관측이 아니라 선언**이다. 표본마다 바뀌는 값이 아니고, 그 계량기가 무엇을 재도록
+   * 설치되었는지는 현장이 안다. 그래서 표본(`EnergyRecord`)에 넣지 않고 자원 속성으로 둔다.
+   *
+   * 값은 계량기 자신의 낱말을 쓴다(적산 레지스터가 그렇게 갈려 있다). §`METER_DIRECTION`.
+   */
+  meterDirection: "meter.direction",
+  /*
+   * ── 부하 계수 — 시뮬레이션이 전기를 만들 수 있게 (2026-08-14) ───────────────
+   * 「이 설비가 돌면 몇 kW 인가」는 **현장이 아는 값**이다. 그래서 타입 기본값을 두지 않는다:
+   * 선언하지 않은 설비는 부하를 만들지 않는다. 기본값을 두면 아무도 그 수가 짐작인 줄 모른 채
+   * 요금 판정이 그 위에 선다.
+   */
+  /** 가동 중 소비(kW). */
+  ratedKW: "power.ratedKW",
+  /** 멈춰 있을 때의 소비(kW). 없으면 멈춘 동안을 **비운다** — 0 이라고 주장하지 않는다. */
+  standbyKW: "power.standbyKW",
+  /*
+   * ── 요금 단가 — 수를 금액으로 바꾸는 선언 (2026-08-17) ─────────────────────
+   *
+   * 그동안 트윈은 「최대수요 328kW」·「전력량 1,547kWh」까지 말하고 멈췄다. 그런데 피크를 깎는 일이
+   * 돈이 되는 이유는 **요금이 둘로 나뉘기** 때문이다: 사용량(kWh)에 붙는 요금과 **최대수요(kW)에 붙는
+   * 기본요금**. 단가가 없으면 그 절반을 말할 수 없고, 그래서 「피크를 깎아 얼마를 아끼나」에 답하지 못했다.
+   *
+   * 단가는 **현장의 계약**이다(같은 나라 안에서도 사업자·요금제마다 다르다). 그래서 기본값을 두지
+   * 않는다 — 선언하지 않으면 금액을 계산하지 않는다. 짐작한 단가로 낸 금액은 숫자가 있다는 것만으로
+   * 사람을 결정으로 밀어붙인다.
+   *
+   * 계약전력(`contract.kW`)과 같은 자리(수전)에 선언한다.
+   */
+  /** 기본요금 단가 — 최대수요 1kW 당(청구 주기 기준). */
+  demandChargePerKW: "tariff.demandChargePerKW",
+  /**
+   * **요금적용전력**(kW) — 기본요금이 실제로 매겨지는 기준. 계약전력과 다른 값이다.
+   *
+   * 기본요금이 걸리는 수는 이 주기에 잰 최대가 아닌 경우가 많다 — 지난 몇 달의 최고를 끌고 가거나,
+   * 약정 용량으로 매기거나, 사업자가 따로 정한다. 그 규칙은 나라와 계약마다 다르므로 커널이 계산하지
+   * 않고 **계산된 결과를 받는다.** 이 값이 있으면 기본요금이 조건부 파생이 아니라 사실이 된다.
+   *
+   * 계약전력(`contract.kW`)을 이 자리에 넣지 말 것. 넘었을 때의 뜻이 다르다 — 계약 초과는 약정
+   * 위반이고, 이쪽은 다음 주기의 기본요금이 오른다는 뜻이다.
+   */
+  billingDemandKW: "tariff.billingDemandKW",
+  /** 사용량 단가 — 1kWh 당. */
+  energyChargePerKWh: "tariff.energyChargePerKWh",
+  /** 통화 — ISO 4217 코드(USD·KRW…). 없으면 금액에 단위를 붙이지 않는다. */
+  currency: "tariff.currency",
+  /*
+   * ── 축전지의 용량과 방전 정책 (2026-08-17) ─────────────────────────────────
+   *
+   * 「배터리로 피크를 깎는다」를 시뮬이 보이려면 방전을 만들어야 하고, 그것은 **선언에서** 나와야 한다.
+   * 임계·최대율·예비를 우리가 정하면 그 수가 어디서 왔는지 아무도 설명할 수 없다.
+   *
+   * ── 선언한다는 것은 「그 자동화가 있다」는 주장이다 ─────────────────────────
+   * 이 정책을 모델에 적으면 **라이브가 아닌 모든 구동이 그 규칙으로 돈다.** 현장에 BESS 제어기가 없는데
+   * 적으면 파생 부하가 실제보다 낙관적으로 나온다(피크가 깎인 것으로 보인다). 그러니 「도입하면?」을
+   * 묻는 것이라면 선언이 아니라 **what-if 가 덮어쓸 일**이다.
+   *
+   * 용량이 없으면 방전하지 않는다 — 용량을 모르면 「얼마나 버티나」를 답할 수 없고, 버티는 시간을
+   * 모른 채 깎으면 무한히 깎을 수 있다고 주장하는 셈이다.
+   */
+  /** 축전지 용량(kWh) — SOC 를 에너지로 바꾸는 값. 없으면 방전을 만들지 않는다. */
+  capacityKWh: "storage.capacityKWh",
+  /** 이 순수요를 넘으면 방전한다(kW) — 피크 억제 임계. */
+  dischargeAboveKW: "dispatch.dischargeAboveKW",
+  /** 최대 방전율(kW) — 인버터가 낼 수 있는 한계. */
+  maxDischargeKW: "dispatch.maxDischargeKW",
+  /** 예비 SOC(%) — 이 아래로는 쓰지 않는다(비상 대비). 없으면 0 으로 본다. */
+  reserveSoc: "dispatch.reserveSoc",
+  /**
+   * 시뮬레이션이 **출발할 때의 SOC(%)** — 씨앗값이다.
+   *
+   * 계측이 SOC 를 알려 주는 트윈에는 필요 없다(잰 값이 진실이다). 시뮬 트윈에는 알려 줄 것이 없어서
+   * 「SOC 를 모르면 방전하지 않는다」는 규율에 걸려 **배터리가 아무 일도 하지 못했다** — 정책을 선언해도
+   * 피크가 한 톨도 깎이지 않았다(실화면에서 그렇게 났다).
+   *
+   * 이것은 상태의 씨앗이지 계측이 아니다. 그래서 계측이 들어오는 순간 그것이 이긴다.
+   */
+  initialSoc: "storage.initialSoc",
+  /*
+   * ── 발전 — 태양광이 서 있기만 하던 자리 (2026-08-18) ────────────────────────
+   *
+   * 계통도에 태양광을 그려 놓고 시뮬에서는 한 톨도 만들지 못했다. 미러는 원천이 발전량을 보내 주지만,
+   * 시뮬 트윈에는 그것을 만들 근거가 없었다 — 그래서 「태양광을 늘리면 피크가 얼마나 내려가나」를 물을 수
+   * 없었다(what-if 의 값이 절반만 성립했다).
+   *
+   * **형상을 우리가 지어내지 않는다.** 위도·계절·날씨로 곡선을 만들면 그 수가 어디서 왔는지 아무도
+   * 설명할 수 없고, 흐린 날 현장의 실적과 어긋난다. 그래서 현장이 **하루 형상을 적는다**: 24개 비율
+   * (0~1)이면 그것이 그 현장의 곡선이다(측정한 형상을 그대로 붙일 수 있다).
+   *
+   * 정격만 있고 형상이 없으면 발전하지 않는다 — 하루 종일 정격으로 발전하는 태양광은 없다.
+   */
+  /**
+   * 발전 정격(kW) — **교류 쪽 최대 출력**. 계통으로 나가는 값이다.
+   *
+   * 이용률의 분모가 이 값이다(만든 양 ÷ 정격 × 시간). **직류 쪽 정격(§`genRatedKWdc`)과 다르고 더 작다** —
+   * 두 값을 한 이름에 담으면 이용률이 그 차이만큼 틀리고, 틀린 이유가 아무 데도 표시되지 않는다.
+   *
+   * 설비마다 선언하거나, 설비별 값을 모르는 현장은 **자리(수전)에 합계로** 선언한다.
+   */
+  genRatedKW: "generation.ratedKW",
+  /**
+   * 발전 정격(kW) — **직류 쪽**. 변환기(인버터)의 입력 쪽 정격이고, 태양광이면 패널 정격의 합이다.
+   *
+   * 이용률의 분모로 쓰지 않는다. 이 값이 교류 정격보다 큰 것은 설계이고(변환기를 그렇게 고른다),
+   * 그 차이가 「맑은 정오에도 교류 출력이 더 오르지 않는 이유」를 설명한다.
+   */
+  genRatedKWdc: "generation.ratedKWdc",
+  /**
+   * 하루 형상 — 쉼표로 나눈 **24개 비율**(0~1). 시각(현장 시간대)의 정격 대비 출력이다.
+   *
+   * 예: `0,0,0,0,0,0,0.05,0.2,0.45,0.7,0.9,1,1,0.95,0.8,0.6,0.35,0.12,0.02,0,0,0,0,0`
+   */
+  genDailyProfile: "generation.dailyProfile"
+};
+var EMS_PROPERTY_SPEC = {
+  [EMS_PROPERTY.contractKW]: { uom: "kW", dataType: "xs:double", note: "contracted power at the metering point, in kW." },
+  /* 값이 셋 중 하나여야 한다 — 그 밖의 낱말은 받지 않는다(뜻이 통할 것 같은 말도 받지 않는다). */
+  [EMS_PROPERTY.meterDirection]: {
+    dataType: "xs:string",
+    note: 'what this metering point measures: "import" (drawn from the grid), "export" (generation sent out), or "bidirectional" (one meter for both, sign carries the direction). Left undeclared, the point counts as load \u2014 leaving it out never makes demand look smaller than it is.'
+  },
+  [EMS_PROPERTY.ratedKW]: { uom: "kW", dataType: "xs:double", note: "power drawn while running, in kW." },
+  [EMS_PROPERTY.standbyKW]: { uom: "kW", dataType: "xs:double", note: "power drawn while idle, in kW." },
+  [EMS_PROPERTY.demandChargePerKW]: { dataType: "xs:double", note: "demand charge per kW of billing-period peak, in the declared currency." },
+  [EMS_PROPERTY.billingDemandKW]: {
+    uom: "kW",
+    dataType: "xs:double",
+    note: "billing demand in kW \u2014 the basis the demand charge is actually billed on (often a rolling 12-month peak). Not the contracted power."
+  },
+  [EMS_PROPERTY.energyChargePerKWh]: { dataType: "xs:double", note: "energy charge per kWh, in the declared currency." },
+  [EMS_PROPERTY.currency]: { dataType: "xs:string", note: "ISO 4217 currency code, e.g. USD or KRW." },
+  [EMS_PROPERTY.capacityKWh]: { uom: "kWh", dataType: "xs:double", note: "usable energy of the storage, in kWh." },
+  [EMS_PROPERTY.dischargeAboveKW]: { uom: "kW", dataType: "xs:double", note: "net demand above which the storage discharges, in kW." },
+  [EMS_PROPERTY.maxDischargeKW]: { uom: "kW", dataType: "xs:double", note: "inverter limit on discharge rate, in kW." },
+  /* 퍼센트다 — 0.8 은 0.8% 이고 80% 가 아니다. 이 한 줄이 없어서 배터리가 조용히 비어 있었다. */
+  [EMS_PROPERTY.reserveSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "reserve state of charge as a percentage 0-100 (20 means 20%), never discharged below." },
+  [EMS_PROPERTY.initialSoc]: { uom: "%", dataType: "xs:double", range: [0, 100], note: "starting state of charge as a percentage 0-100 (80 means 80%, not 0.8)." },
+  [EMS_PROPERTY.genRatedKW]: {
+    uom: "kW",
+    dataType: "xs:double",
+    note: "rated AC generation output, in kW \u2014 the denominator of capacity factor. Declare per equipment, or on the incoming location as a site total."
+  },
+  [EMS_PROPERTY.genRatedKWdc]: {
+    uom: "kW",
+    dataType: "xs:double",
+    note: "rated DC generation capacity, in kW (panel rating for PV). Larger than the AC rating by design; not the capacity-factor denominator."
+  },
+  [EMS_PROPERTY.genDailyProfile]: {
+    dataType: "xs:string",
+    note: "daily shape as 24 comma-separated fractions of rated output (0-1), one per hour of local time \u2014 the site declares its own curve; we do not invent one."
+  }
+};
+function generationFractionAt(profile, hourOfDay) {
+  const parts = String(profile ?? "").split(",").map((v2) => v2.trim()).filter((v2) => v2 !== "");
+  if (parts.length !== 24)
+    return void 0;
+  const h = Math.floor(hourOfDay);
+  if (!Number.isFinite(h) || h < 0 || h > 23)
+    return void 0;
+  const v = Number(parts[h]);
+  if (!Number.isFinite(v) || v < 0 || v > 1)
+    return void 0;
+  return v;
+}
+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).
+     * 상태를 읽어 계통 구성을 알 뿐이다.
+     *
+     * 능력은 `switching` 이다 — `operable` 이 아니다(2026-08-14). `operable` 이던 동안 저작면이 차단기에
+     * **제어 컴포넌트**를 권했다: 우리가 하지 않기로 한 조작을 화면이 부추긴 것이다. 「위치를 읽는다」와
+     * 「명령을 받는다」는 다른 능력이고, 이제 그 둘이 갈려 있다(capability.ts 주석).
+     */
+    standardClass: { iec61850: "XCBR", iso55000: "Asset" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["switching"]
+  },
+  {
+    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: ["energyGenerating", "metered", "operable"]
+  },
+  {
+    key: "battery",
+    role: "equipment",
+    label: "twin.type.battery",
+    /* 축전지(ESS) — `ZBAT`. 충전·방전을 나눠 재고, 저장은 보관(`storable`)이 아니다(물건이 아니다). */
+    standardClass: { iec61850: "ZBAT", iso55000: "Asset" },
+    identity: { scheme: "kernel:id" },
+    capabilities: ["energyStoring", "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"]
+  }
+];
+function electricalUpstreamOf(locations, id) {
+  const byId2 = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
+  const self = byId2.get(String(id));
+  if (!self)
     return void 0;
-  if (/^https?:\/\/[^/\s]+/.test(ns))
-    return `${ns.replace(/\/+$/, "")}/${marker}/${v}`;
-  if (/^urn:epc(global)?:/.test(ns))
+  if (self.upstreamId)
+    return String(self.upstreamId);
+  const parent = self.parentId ? byId2.get(String(self.parentId)) : void 0;
+  if (!parent)
     return void 0;
-  if (/^urn:[^:\s]+/.test(ns))
-    return `${ns.replace(/:+$/, "")}:${marker}:${v}`;
-  return void 0;
-}
-function header(type, eventTime, bizStep, opts) {
-  const h = {
-    "@context": EPCIS_CONTEXT,
-    type,
-    eventTime,
-    eventTimeZoneOffset: UTC_OFFSET,
-    bizStep
-  };
-  if (opts?.eventID)
-    h.eventID = opts.eventID;
-  if (opts?.recordTime)
-    h.recordTime = opts.recordTime;
-  if (opts?.errorDeclaration)
-    h.errorDeclaration = opts.errorDeclaration;
-  if (opts?.bizTransactionList?.length)
-    h.bizTransactionList = opts.bizTransactionList;
-  if (opts?.ilmd)
-    h.ilmd = opts.ilmd;
-  if (opts?.sourceList)
-    h.sourceList = opts.sourceList;
-  if (opts?.destinationList)
-    h.destinationList = opts.destinationList;
-  if (opts?.persistentDisposition)
-    h.persistentDisposition = opts.persistentDisposition;
-  if (opts?.sensorElementList)
-    h.sensorElementList = opts.sensorElementList;
-  if (opts?.certificationInfo)
-    h.certificationInfo = opts.certificationInfo;
-  return h;
-}
-function common(type, eventTime, action, bizStep, opts) {
-  return { ...header(type, eventTime, bizStep, opts), action };
-}
-function objectEvent(p) {
-  const e = { ...common("ObjectEvent", p.eventTime, p.action, p.bizStep, p), epcList: p.epcList };
-  if (p.disposition)
-    e.disposition = p.disposition;
-  if (p.quantityList)
-    e.quantityList = p.quantityList;
-  if (p.readPoint)
-    e.readPoint = { id: p.readPoint };
-  if (p.bizLocation)
-    e.bizLocation = { id: p.bizLocation };
-  if (p.bizTransactionList)
-    e.bizTransactionList = p.bizTransactionList;
-  return e;
+  return isElectricalLocationType(String(parent.type ?? "")) ? String(parent.id) : void 0;
 }
-function aggregationEvent(p) {
-  const e = { ...common("AggregationEvent", p.eventTime, p.action, p.bizStep, p), parentID: p.parentID };
-  if (p.disposition)
-    e.disposition = p.disposition;
-  if (p.childEPCs)
-    e.childEPCs = p.childEPCs;
-  if (p.childQuantityList)
-    e.childQuantityList = p.childQuantityList;
-  if (p.readPoint)
-    e.readPoint = { id: p.readPoint };
-  if (p.bizLocation)
-    e.bizLocation = { id: p.bizLocation };
-  return e;
+function isElectricalLocationType(type) {
+  return EMS_LOCATION_TYPES.includes(type);
 }
-function transactionEvent(p) {
-  const e = {
-    ...common("TransactionEvent", p.eventTime, p.action, p.bizStep, p),
-    bizTransactionList: p.bizTransactionList
-  };
-  if (p.disposition)
-    e.disposition = p.disposition;
-  if (p.parentID)
-    e.parentID = p.parentID;
-  if (p.epcList)
-    e.epcList = p.epcList;
-  if (p.quantityList)
-    e.quantityList = p.quantityList;
-  if (p.readPoint)
-    e.readPoint = { id: p.readPoint };
-  if (p.bizLocation)
-    e.bizLocation = { id: p.bizLocation };
-  return e;
+
+// ../ops-contract/dist/domain-catalog.js
+var locationKeys = (types) => types.filter((t) => t.role === "location").map((t) => t.key);
+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) },
+  ems: { system: "ems", label: "twin.system.ems", types: EMS_TYPES, locationTypes: locationKeys(EMS_TYPES) }
+};
+
+// ../ops-contract/dist/domain-definition.js
+var OP_PARAM = {
+  /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
+  yield: "yield",
+  /** 셋업·체인지오버 소요(ISO 8601 기간 문자열). ISA-95 는 셋업을 별도 세그먼트로도 표현하지만,
+   *  현재 커널은 작업에 붙는 셋업으로 다루므로 모수로 받는다. */
+  setupDuration: "setupDuration"
+};
+function procedureViolations(route) {
+  const elements = route.procedure ?? [];
+  if (!elements.length)
+    return [];
+  const errors = [];
+  const byKey = new Map(elements.map((e) => [e.key, e]));
+  const hasChild = new Set(elements.map((e) => e.parent).filter((k) => !!k));
+  const stepSet = new Set(route.steps ?? []);
+  const seenStep = /* @__PURE__ */ new Map();
+  for (const n of elements) {
+    if (n.parent && !byKey.has(n.parent))
+      errors.push(`${n.key}: \uC0C1\uC704 '${n.parent}' \uAC00 \uC774 \uC808\uCC28\uC5D0 \uC5C6\uB2E4`);
+    if (n.step === void 0)
+      continue;
+    if (hasChild.has(n.key))
+      errors.push(`${n.key}: \uC544\uB798 \uC694\uC18C\uAC00 \uC788\uB294\uB370 \uB2E8\uACC4\uB97C \uB4E0\uB2E4 \u2014 \uC2E4\uD589\uB418\uB294 \uAC83\uC740 \uC78E\uBFD0\uC774\uB2E4`);
+    if (!stepSet.has(n.step))
+      errors.push(`${n.key}: \uBAA8\uB974\uB294 \uB2E8\uACC4 '${n.step}' \u2014 steps \uC5D0 \uC5C6\uB2E4`);
+    const already = seenStep.get(n.step);
+    if (already)
+      errors.push(`\uB2E8\uACC4 '${n.step}' \uAC00 '${already}' \uC640 '${n.key}' \uB458\uC5D0 \uC2E4\uB838\uB2E4 \u2014 \uC808\uCC28 \uC5B4\uB514\uC778\uC9C0 \uB9D0\uD560 \uC218 \uC5C6\uB2E4`);
+    else
+      seenStep.set(n.step, n.key);
+  }
+  return errors;
 }
-function transformationEvent(p) {
-  const e = header("TransformationEvent", p.eventTime, p.bizStep, p);
-  if (p.disposition)
-    e.disposition = p.disposition;
-  if (p.inputEPCList)
-    e.inputEPCList = p.inputEPCList;
-  if (p.inputQuantityList)
-    e.inputQuantityList = p.inputQuantityList;
-  if (p.outputEPCList)
-    e.outputEPCList = p.outputEPCList;
-  if (p.outputQuantityList)
-    e.outputQuantityList = p.outputQuantityList;
-  if (p.transformationID)
-    e.transformationID = p.transformationID;
-  if (p.readPoint)
-    e.readPoint = { id: p.readPoint };
-  if (p.bizLocation)
-    e.bizLocation = { id: p.bizLocation };
-  if (p.bizTransactionList)
-    e.bizTransactionList = p.bizTransactionList;
-  return e;
+
+// ../ops-contract/dist/energy-ingest.js
+function resolveSubject(kind, localId, opts) {
+  const declared = opts.identityOf?.(kind, localId);
+  if (declared)
+    return { subject: declared, basis: "declared" };
+  return { subject: opts.scopeId ? `${opts.scopeId}/${localId}` : localId, basis: "twin-local" };
 }
-var GS1_KEY_DIGITS = { sgtin: 13, lgtin: 13, sscc: 17, grai: 12, gdti: 12, sgln: 12 };
-function gs1KeyDigitViolation(uri) {
-  if (!uri)
-    return void 0;
-  const m = /^urn:epc:(?:id|idpat|class):([a-z]+):([^:]+)$/.exec(uri);
-  if (!m)
-    return void 0;
-  const want = GS1_KEY_DIGITS[m[1]];
-  if (!want)
-    return void 0;
-  const parts = m[2].split(".");
-  if (parts.length < 2)
-    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uAC00 '.' \uB85C \uAC08\uB824\uC57C \uD55C\uB2E4`;
-  const [prefix, ref] = parts;
-  if (ref === "*")
-    return void 0;
-  if (!/^\d+$/.test(prefix) || !/^\d+$/.test(ref)) {
-    return `${m[1]} \uD615\uC2DD \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4\uC640 \uCC38\uC870\uB294 \uC22B\uC790\uB2E4`;
-  }
-  const got = prefix.length + ref.length;
-  if (got === want)
-    return void 0;
-  return `${m[1]} \uC790\uB9AC \uC218 \uC624\uB958: ${uri} \u2014 \uD68C\uC0AC \uD504\uB9AC\uD53D\uC2A4(${prefix.length}) + \uCC38\uC870(${ref.length}) = ${got} \uC774\uC9C0\uB9CC ${want} \uC5EC\uC57C \uD55C\uB2E4(GS1 TDS). \uD504\uB9AC\uD53D\uC2A4\uB97C \uBC14\uAFB8\uBA74 \uCC38\uC870 \uC790\uB9AC \uC218\uB97C \uD568\uAED8 \uB9DE\uCDB0\uC57C \uD55C\uB2E4.`;
+function periodFactId(tenantId, kind, subject, from, to) {
+  return [tenantId, kind, subject, from, to].join("|");
 }
 
 // ../ops-contract/dist/order-fold.js
+var ORDER_FOLD_HOUR_MS = 60 * 60 * 1e3;
 var ORDER_FOLD_DEFAULT = Object.freeze({ afterMs: 24 * 60 * 60 * 1e3, maxTerminal: 1e3 });
 function orderFoldPolicyOf(declared) {
   const policy = { ...ORDER_FOLD_DEFAULT };
@@ -1922,6 +1962,9 @@ function orderFoldPolicyOf(declared) {
     }
     policy[key] = key === "maxTerminal" ? Math.floor(v) : v;
   }
+  if (policy.afterMs % ORDER_FOLD_HOUR_MS !== 0) {
+    return { error: `order fold afterMs must be a whole number of hours, got ${policy.afterMs} ms \u2014 the window is counted in hour slots (ADR-0092)` };
+  }
   if (policy.maxTerminal < 1)
     return { error: "order fold maxTerminal must be at least 1 (ADR-0092)" };
   return { policy };
@@ -1949,6 +1992,7 @@ function foldOrdersInto(folded, orders) {
     counts: Object.fromEntries(Object.entries(folded?.counts ?? {}).map(([k, v]) => [k, { ...v }])),
     boundaryMs: folded?.boundaryMs ?? null
   };
+  const hours = Object.fromEntries(Object.entries(folded?.hours ?? {}).map(([h, byKind]) => [h, Object.fromEntries(Object.entries(byKind).map(([k, v]) => [k, { ...v }]))]));
   for (const o of orders) {
     const kind = String(o.kind ?? "");
     const status = String(o.status ?? "");
@@ -1956,8 +2000,12 @@ function foldOrdersInto(folded, orders) {
     byStatus[status] = (byStatus[status] ?? 0) + 1;
     if (typeof o.terminalAtMs === "number" && Number.isFinite(o.terminalAtMs)) {
       out.boundaryMs = out.boundaryMs === null ? o.terminalAtMs : Math.max(out.boundaryMs, o.terminalAtMs);
+      const slot = (hours[String(hourStartOf(o.terminalAtMs))] ??= {})[kind] ??= {};
+      slot[status] = (slot[status] ?? 0) + 1;
     }
   }
+  if (Object.keys(hours).length)
+    out.hours = hours;
   return out;
 }
 function standsNewOrderRow(record, eventTimeMs, folded) {
@@ -1970,6 +2018,22 @@ function standsNewOrderRow(record, eventTimeMs, folded) {
     return true;
   return eventTimeMs > boundary;
 }
+function hourStartOf(ms2) {
+  return Math.floor(ms2 / ORDER_FOLD_HOUR_MS) * ORDER_FOLD_HOUR_MS;
+}
+function finishedWindowStartMs(nowMs, policy = ORDER_FOLD_DEFAULT) {
+  return hourStartOf(nowMs) - policy.afterMs;
+}
+function pruneFoldedHours(folded, nowMs, policy = ORDER_FOLD_DEFAULT) {
+  if (!folded.hours)
+    return folded;
+  const start = finishedWindowStartMs(nowMs, policy);
+  const kept = Object.fromEntries(Object.entries(folded.hours).filter(([h]) => Number(h) >= start));
+  const out = { counts: folded.counts, boundaryMs: folded.boundaryMs };
+  if (Object.keys(kept).length)
+    out.hours = kept;
+  return out;
+}
 
 // ../ops-contract/dist/iso-duration.js
 var RE = /^(-)?P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
@@ -3852,7 +3916,7 @@ var ObservedReducer = class {
     const ids = planOrderFold([...this.orders.values()], nowMs, this.orderFoldPolicy);
     if (!ids.length) return 0;
     const rows = ids.map((id) => this.orders.get(id)).filter(Boolean);
-    this.foldedOrders = foldOrdersInto(this.foldedOrders, rows);
+    this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, rows), nowMs, this.orderFoldPolicy);
     for (const id of ids) {
       this.orders.delete(id);
       this.lastAt.delete(`order:${id}`);
@@ -4524,7 +4588,8 @@ var FlowEngine = class {
     }
     const ids = planOrderFold([...this.orders.values()], nowMs ?? this.nowMs(), this.orderFoldPolicy);
     if (!ids.length) return 0;
-    this.foldedOrders = foldOrdersInto(this.foldedOrders, ids.map((id) => this.orders.get(id)).filter(Boolean));
+    const now = nowMs ?? this.nowMs();
+    this.foldedOrders = pruneFoldedHours(foldOrdersInto(this.foldedOrders, ids.map((id) => this.orders.get(id)).filter(Boolean)), now, this.orderFoldPolicy);
     for (const id of ids) this.orders.delete(id);
     this.revision++;
     return ids.length;
@@ -6950,7 +7015,7 @@ var FlowEngine = class {
         this.emit(objectEvent({
           eventTime: this.now(),
           action: "OBSERVE",
-          bizStep: CBV_BIZSTEP.consuming,
+          bizStep: PRIVATE_BIZSTEP.consuming,
           disposition: DISP.in_progress,
           epcList: [],
           quantityList: [{ epcClass: it.gtin ?? it.epc, quantity: left, uom: it.uom }],
@@ -6964,7 +7029,7 @@ var FlowEngine = class {
     }
     if (!whole.length) return;
     if (this.adoptConsumed(t, whole)) {
-      this.observeDisposition(whole, DISP.in_progress, CBV_BIZSTEP.consuming);
+      this.observeDisposition(whole, DISP.in_progress, PRIVATE_BIZSTEP.consuming);
       return;
     }
     const at = this.items.get(whole[0])?.location ?? t.toNode;
@@ -6979,7 +7044,7 @@ var FlowEngine = class {
       objectEvent({
         eventTime: this.now(),
         action: "DELETE",
-        bizStep: CBV_BIZSTEP.consuming,
+        bizStep: PRIVATE_BIZSTEP.consuming,
         disposition: DISP.in_progress,
         epcList: whole.slice(),
         readPoint: at,
@@ -8039,8 +8104,8 @@ var YmsKernel = class extends FlowEngine {
       return;
     }
     if (to.type === "yard-slot") {
-      trailer.disposition = DISP.sellable;
-      this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: YARD_BIZSTEP.staging, disposition: DISP.sellable, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+      delete trailer.disposition;
+      this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: YARD_PRIVATE_BIZSTEP.staging, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
       return;
     }
     if (to.type === "dock-door") {
@@ -8054,7 +8119,7 @@ var YmsKernel = class extends FlowEngine {
           this.aggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.loading, readPoint: to.id, consume: { readPoint: staging.id, disposition: DISP.in_transit } });
         }
         this.trailerCargo.delete(trailer.epc);
-        trailer.disposition = DISP.sellable;
+        delete trailer.disposition;
       } else if (cargo.length && staging) {
         this.disaggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.unloading, readPoint: to.id, materialize: { location: staging.id, disposition: DISP.sellable } });
         this.trailerCargo.delete(trailer.epc);