@operato/ops-contract 0.1.0

package/dist-cjs/index.cjs

@@ -0,0 +1,3767 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BIZSTEP: () => BIZSTEP,
+  BTT: () => BTT,
+  BTT_DELIVERY: () => BTT_DELIVERY,
+  BTT_PRODORDER: () => BTT_PRODORDER,
+  CAPABILITIES: () => CAPABILITIES,
+  CAPABILITY_KEYS: () => CAPABILITY_KEYS,
+  CBV_BIZSTEP: () => CBV_BIZSTEP,
+  CMD: () => CMD,
+  DISP: () => DISP,
+  DISPOSITION_DECISION: () => DISPOSITION_DECISION,
+  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_PROPERTY_SPEC: () => EMS_PROPERTY_SPEC,
+  EMS_TYPES: () => EMS_TYPES,
+  ENERGY_EVENT: () => ENERGY_EVENT,
+  EPCIS_CONTEXT: () => EPCIS_CONTEXT,
+  EPCIS_EVENT: () => EPCIS_EVENT,
+  EQUIPMENT_LEVEL: () => EQUIPMENT_LEVEL,
+  GUARD_PRAGMA: () => GUARD_PRAGMA,
+  ILMD_ATTR: () => ILMD_ATTR,
+  LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
+  MES_BIZSTEP: () => MES_BIZSTEP,
+  MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
+  MES_TYPES: () => MES_TYPES,
+  METER_DIRECTION: () => METER_DIRECTION,
+  OBSERVATION_BASIS: () => OBSERVATION_BASIS,
+  OP_EVENT: () => OP_EVENT,
+  OP_PARAM: () => OP_PARAM,
+  ORDER_TERMINAL_STATUS: () => ORDER_TERMINAL_STATUS,
+  PRIORITY_UNSET: () => PRIORITY_UNSET,
+  RETIRED_VOCABULARY: () => RETIRED_VOCABULARY,
+  TWIN_AXES: () => TWIN_AXES,
+  TWIN_PROPERTIES: () => TWIN_PROPERTIES,
+  TWIN_RELATIONS: () => TWIN_RELATIONS,
+  UTC_OFFSET: () => UTC_OFFSET,
+  VOCABULARY_EXCEPTIONS: () => VOCABULARY_EXCEPTIONS,
+  VOCABULARY_TYPE: () => VOCABULARY_TYPE,
+  WMS_LOCATION_TYPES: () => WMS_LOCATION_TYPES,
+  WMS_TYPES: () => WMS_TYPES,
+  YARD_BIZSTEP: () => YARD_BIZSTEP,
+  YMS_LOCATION_TYPES: () => YMS_LOCATION_TYPES,
+  YMS_TYPES: () => YMS_TYPES,
+  activeShiftAt: () => activeShiftAt,
+  activeShiftOf: () => activeShiftOf,
+  aggregationEvent: () => aggregationEvent,
+  analyzeCapacity: () => analyzeCapacity,
+  axesOfSystem: () => axesOfSystem,
+  axisAppliesTo: () => axisAppliesTo,
+  axisInfo: () => axisInfo,
+  axisSource: () => axisSource,
+  bizTransactionUri: () => bizTransactionUri,
+  capabilitiesForType: () => capabilitiesForType,
+  capabilityOf: () => capabilityOf,
+  classClosure: () => classClosure,
+  classIdentifierViolation: () => classIdentifierViolation,
+  commandsOf: () => commandsOf,
+  conversionFactorOf: () => conversionFactorOf,
+  criterionSaysNothing: () => criterionSaysNothing,
+  documentPath: () => documentPath,
+  dueStatusOf: () => dueStatusOf,
+  effectivityAt: () => effectivityAt,
+  electricalUpstreamOf: () => electricalUpstreamOf,
+  expiryFromAttributes: () => expiryFromAttributes,
+  gdtiUri: () => gdtiUri,
+  generationFractionAt: () => generationFractionAt,
+  graiUri: () => graiUri,
+  gs1KeyDigitViolation: () => gs1KeyDigitViolation,
+  hierarchyOf: () => hierarchyOf,
+  identityGroundingOf: () => identityGroundingOf,
+  inWorkCalendar: () => inWorkCalendar,
+  inWorkCalendarAt: () => inWorkCalendarAt,
+  ingest: () => ingest,
+  ingestEnergyBillRecords: () => ingestEnergyBillRecords,
+  ingestEnergyEquipmentRecords: () => ingestEnergyEquipmentRecords,
+  ingestEnergyGenerationPeriodRecords: () => ingestEnergyGenerationPeriodRecords,
+  ingestEnergyGenerationPriceRecords: () => ingestEnergyGenerationPriceRecords,
+  ingestEnergyGenerationRecords: () => ingestEnergyGenerationRecords,
+  ingestEnergyRecords: () => ingestEnergyRecords,
+  ingestEnergyTariffBasisRecords: () => ingestEnergyTariffBasisRecords,
+  ingestEnergyUsagePeriodRecords: () => ingestEnergyUsagePeriodRecords,
+  ingestMasterData: () => ingestMasterData,
+  ingestOperationalRecords: () => ingestOperationalRecords,
+  isAggregationRecord: () => isAggregationRecord,
+  isElectricalLocationType: () => isElectricalLocationType,
+  isEnergyBillRecord: () => isEnergyBillRecord,
+  isEnergyEquipmentRecord: () => isEnergyEquipmentRecord,
+  isEnergyGenerationPeriodRecord: () => isEnergyGenerationPeriodRecord,
+  isEnergyGenerationPriceRecord: () => isEnergyGenerationPriceRecord,
+  isEnergyGenerationRecord: () => isEnergyGenerationRecord,
+  isEnergyRecord: () => isEnergyRecord,
+  isEnergyTariffBasisRecord: () => isEnergyTariffBasisRecord,
+  isEnergyUsagePeriodRecord: () => isEnergyUsagePeriodRecord,
+  isEpcisEventType: () => isEpcisEventType,
+  isEquipmentLevel: () => isEquipmentLevel,
+  isMasterDataRecord: () => isMasterDataRecord,
+  isOperationalRecord: () => isOperationalRecord,
+  isOrderTerminal: () => isOrderTerminal,
+  isTransformationRecord: () => isTransformationRecord,
+  isoDurationHours: () => isoDurationHours,
+  itemKeyOf: () => itemKeyOf,
+  judgeAgainstSpec: () => judgeAgainstSpec,
+  levelOfLocationType: () => levelOfLocationType,
+  lgtinClass: () => lgtinClass,
+  localDayIndexAt: () => localDayIndexAt,
+  localDayStartMs: () => localDayStartMs,
+  locationStatusOf: () => locationStatusOf,
+  lotFromAttributes: () => lotFromAttributes,
+  mapRecord: () => mapRecord,
+  mapRecordChecked: () => mapRecordChecked,
+  meetsTests: () => meetsTests,
+  minuteOfDayAt: () => minuteOfDayAt,
+  objectEvent: () => objectEvent,
+  objectUri: () => objectUri,
+  observationAt: () => observationAt,
+  offCalendarAt: () => offCalendarAt,
+  offCalendarReasonAt: () => offCalendarReasonAt,
+  operationalKindOf: () => operationalKindOf,
+  operationsCapabilityOf: () => operationsCapabilityOf,
+  outsideLimit: () => outsideLimit,
+  parseEpc: () => parseEpc,
+  parseIsoDuration: () => parseIsoDuration,
+  periodFactId: () => periodFactId,
+  priorityRank: () => priorityRank,
+  procedureViolations: () => procedureViolations,
+  propertiesOf: () => propertiesOf,
+  quantityIn: () => quantityIn,
+  readBoardAssets: () => readBoardAssets,
+  readBoardEquipment: () => readBoardEquipment,
+  readBoardLocations: () => readBoardLocations,
+  relationsFrom: () => relationsFrom,
+  relationsTo: () => relationsTo,
+  requiredTestsFor: () => requiredTestsFor,
+  resolveSubject: () => resolveSubject,
+  retiredVocabularyIn: () => retiredVocabularyIn,
+  sgtinClass: () => sgtinClass,
+  sgtinUri: () => sgtinUri,
+  ssccUri: () => ssccUri,
+  stateFieldsOf: () => stateFieldsOf,
+  subLotIdOf: () => subLotIdOf,
+  testEvidenceGaps: () => testEvidenceGaps,
+  testPassedAt: () => testPassedAt,
+  transactionEvent: () => transactionEvent,
+  transformationEvent: () => transformationEvent,
+  validateDomainDefinition: () => validateDomainDefinition,
+  validateEpcisEvent: () => validateEpcisEvent,
+  validateScenario: () => validateScenario,
+  weekdayAt: () => weekdayAt,
+  workingHoursBetween: () => workingHoursBetween,
+  workingTimeOfWeek: () => workingTimeOfWeek
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/capability.ts
+var CAPABILITIES = {
+  operable: {
+    key: "operable",
+    label: "twin.capability.operable",
+    semantics: "\uB2A5\uB3D9 \uC790\uC6D0\uC758 \uC6B4\uC601 \uC0C1\uD0DC(\uC720\uD734/\uAC00\uB3D9/\uACE0\uC7A5). status \uAD50\uCC28 \uAD00\uC2EC\uC0AC\uB97C \uC5EC\uAE30 \uD558\uB098\uB85C.",
+    commands: ["resource.hold", "resource.resume", "resource.down", "resource.repair", "resource.reset-metrics"],
+    stateFields: ["status"],
+    results: ["statusChanged"]
+  },
+  storable: {
+    key: "storable",
+    label: "twin.capability.storable",
+    semantics: "\uC544\uC774\uD15C\uC744 \uBCF4\uC720\uD558\uB294 \uC704\uCE58 \u2014 \uC810\uC720/\uC6A9\uB7C9. (\uC52C \uAE30\uC81C: Capacity)",
+    commands: [],
+    stateFields: ["occupancy", "capacity"],
+    invariants: ["0 <= occupancy <= capacity (capacity>0)"],
+    results: ["occupancyChanged"]
+  },
+  mobile: {
+    key: "mobile",
+    label: "twin.capability.mobile",
+    semantics: "\uC790\uC6D0 \uC790\uC2E0\uC774 \uC790\uB9AC \uAC04 \uC774\uB3D9. Transferable(\uC544\uC774\uD15C \uC774\uB3D9)\uACFC \uB2E4\uB984. (\uC52C \uAE30\uC81C: CarrierLine)",
+    commands: [],
+    stateFields: ["location", "motion"],
+    models: ["Motion"],
+    results: ["moved", "motionTick"]
+  },
+  processable: {
+    key: "processable",
+    label: "twin.capability.processable",
+    semantics: "\uBCC0\uD658/\uAC00\uACF5 \uC218\uD589 \u2014 \uC0B0\uCD9C(\uC591\uD488/\uBD88\uB7C9). \uC6B4\uC601 status \uB294 Operable \uC870\uD569. progress \uBC29\uCD9C\uC740 \uD6C4\uC18D.",
+    commands: [],
+    stateFields: ["output"],
+    results: ["completed"]
+  },
+  /*
+   * ── 「위치를 읽는다」 ≠ 「조작할 수 있다」 (2026-08-14) ─────────────────────
+   * 차단기는 이 둘이 갈리는 자리다. 상태를 읽어 계통 구성을 알지만 **우리는 조작하지 않는다**
+   * (안전 계통은 범위 밖: profiles/ems.md §1). 그런데 능력을 `operable` 로 주면 저작면이 그 설비에
+   * **제어 컴포넌트를 권한다** — 화면이 우리가 하지 않기로 한 것을 하라고 부추긴다.
+   *
+   * 그래서 개폐 기기의 관측을 따로 세운다. 이름을 `observable` 로 하지 않은 이유: 그러면 상태 필드가
+   * `status` 여야 하고 그건 `operable` 의 것이다(원칙 ② 직교). 없는 필드를 지어내는 대신 **표준이 주는
+   * 이름**을 쓴다 — 개폐 기기의 관측은 `Pos`(위치)다.
+   *
+   * `operable` 은 그대로 「명령을 받는 능동 자원」의 자리로 남는다.
+   */
+  switching: {
+    key: "switching",
+    label: "twin.capability.switching",
+    semantics: "\uD68C\uB85C\uB97C \uC5F4\uACE0 \uB2EB\uB294 \uAE30\uAE30\uC758 **\uC704\uCE58\uB97C \uC77D\uB294\uB2E4** \u2014 \uC6B0\uB9AC\uB294 \uC870\uC791\uD558\uC9C0 \uC54A\uB294\uB2E4(\uBA85\uB839 \uC5C6\uC74C). IEC 61850 XCBR/XSWI Pos.",
+    commands: [],
+    stateFields: ["position"],
+    models: ["SwitchingState"],
+    results: ["positionChanged"]
+  },
+  trackable: {
+    key: "trackable",
+    label: "twin.capability.trackable",
+    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.",
+    commands: ["order.hold", "order.resume", "order.release"],
+    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).",
+    commands: [],
+    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.",
+    commands: [],
+    stateFields: ["curtailable", "minKW"],
+    models: ["CurtailableState"],
+    invariants: ["minKW >= 0"],
+    results: ["drSuggested"]
+  },
+  energyGenerating: {
+    key: "energyGenerating",
+    label: "twin.capability.energyGenerating",
+    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.",
+    commands: [],
+    /*
+     * ── 적산을 더한다 (2026-08-26) ─────────────────────────────────────────────
+     * 이 능력이 순시 출력만 선언하고 있었다. 그래서 「지금 발전 중」은 말하고 「얼마나 발전했나」는 말할
+     * 수 없었다 — 사건 이름(`energy.generated`)과 설계 문서에는 처음부터 있던 사실이다.
+     *
+     * 계량 능력(`metered`)이 `kW` 와 `kWh` 를 함께 선언한 것과 같은 짝이다. 적산은 발전 설비의 보편적
+     * 사실이고(태양광·열병합·디젤), 그것이 없으면 성능비·발전시간 같은 성과를 아무도 셀 수 없다.
+     */
+    stateFields: ["generatedKW", "exportKW", "generatedKWh", "generatedKWhResetAt", "generatedKWhSince", "generatedKWhBasis", "generatedKWhAccumulation", "generatedKWhLastPeriod", "generatedKWhLastPeriodEnd", "generatedKWhLastPeriodObservedFrom", "generatedKWhLastPeriodObservedTo", "dcVoltage", "dcCurrent", "acVoltage", "acCurrent"],
+    models: ["GeneratingState"],
+    results: ["generated"]
+  },
+  /*
+   * ── 왜 `storing` 이 아니라 `energyStoring` 인가 (2026-08-15) ────────────────
+   * 같은 카탈로그에 `storable`(물건을 담는 자리)이 있다. 전기를 담는 것과 물건을 담는 것이 한 글자
+   * 차이로 붙어 있어서, 컴포넌트를 만들 때 `twin-storage` 를 피해 `twin-storage-energy` 로 도망쳤다 —
+   * 한 이름을 두 번 피해 갔다면 그 이름이 틀린 것이다.
+   *
+   * 도메인(EMS)이 아니라 **양(에너지)** 을 이름에 넣는다. 그래서 MES 트윈 안의 디젤 발전기도 그대로
+   * `energyGenerating` 이다 — 능력은 도메인이 아니라 관측의 면이다(방언 없음).
+   */
+  energyStoring: {
+    key: "energyStoring",
+    label: "twin.capability.energyStoring",
+    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).",
+    commands: [],
+    stateFields: ["soc", "chargeKW", "dischargeKW"],
+    models: ["StoringState"],
+    invariants: ["0 <= soc <= 100"],
+    results: ["stored", "discharged"]
+  }
+};
+var CAPABILITY_KEYS = ["operable", "storable", "mobile", "processable", "trackable", "switching", "metered", "curtailable", "energyGenerating", "energyStoring"];
+function stateFieldsOf(caps) {
+  const out = /* @__PURE__ */ new Set();
+  for (const c of caps) for (const f of CAPABILITIES[c]?.stateFields ?? []) out.add(f);
+  return [...out];
+}
+function commandsOf(caps) {
+  const out = /* @__PURE__ */ new Set();
+  for (const c of caps) for (const cmd of CAPABILITIES[c]?.commands ?? []) out.add(cmd);
+  return [...out];
+}
+
+// src/contract.ts
+var ORDER_TERMINAL_STATUS = ["completed", "cancelled"];
+function isOrderTerminal(o) {
+  const status = String(o?.status ?? "").trim().toLowerCase();
+  if (ORDER_TERMINAL_STATUS.includes(status)) return true;
+  const requested = o?.requested;
+  const fulfilled = o?.fulfilled;
+  if (typeof requested !== "number" || !(requested > 0)) return false;
+  return typeof fulfilled === "number" && fulfilled >= requested;
+}
+var LOCATION_SATURATION_NEAR = 0.9;
+function locationStatusOf(n) {
+  const cap = n.capacity;
+  if (!(typeof cap === "number" && cap > 0)) return void 0;
+  const r = (n.occupancy ?? 0) / cap;
+  return r >= 1 ? "full" : r >= LOCATION_SATURATION_NEAR ? "near-full" : "available";
+}
+var EQUIPMENT_LEVEL = [
+  "Enterprise",
+  "Site",
+  "Area",
+  "ProcessCell",
+  "Unit",
+  "ProductionLine",
+  "WorkCell",
+  "ProductionUnit",
+  "StorageZone",
+  "StorageUnit",
+  "WorkCenter",
+  "WorkUnit",
+  "EquipmentModule",
+  "ControlModule",
+  "Other"
+];
+function isEquipmentLevel(v) {
+  return typeof v === "string" && EQUIPMENT_LEVEL.includes(v);
+}
+function hierarchyOf(s, levelOfType) {
+  const push = (m, k, v) => {
+    const cur = m.get(k);
+    if (cur) cur.push(v);
+    else m.set(k, [v]);
+  };
+  const parent = /* @__PURE__ */ new Map();
+  const kids = /* @__PURE__ */ new Map();
+  const known = new Set(s.locations.map((n) => n.id));
+  for (const n of s.locations) {
+    if (!n.parentId || n.parentId === n.id) continue;
+    parent.set(n.id, n.parentId);
+    if (known.has(n.parentId)) push(kids, n.parentId, n.id);
+  }
+  for (const start of known) {
+    const seen = [start];
+    for (let at = parent.get(start); at !== void 0; at = parent.get(at)) {
+      if (seen.includes(at)) throw new Error(`location hierarchy has a cycle: ${[...seen, at].join(" \u2192 ")}`);
+      seen.push(at);
+      if (!known.has(at)) break;
+    }
+  }
+  const homes = /* @__PURE__ */ new Map();
+  for (const m of s.equipment ?? []) if (m.homeLocation) push(homes, m.homeLocation, m.id);
+  const ancestorsOf = (id) => {
+    const out = [];
+    for (let at = parent.get(id); at !== void 0; at = parent.get(at)) {
+      out.push(at);
+      if (!known.has(at)) break;
+    }
+    return out;
+  };
+  const descendantsOf = (id) => {
+    const out = [];
+    const stack = [...kids.get(id) ?? []];
+    while (stack.length) {
+      const cur = stack.pop();
+      out.push(cur);
+      stack.push(...kids.get(cur) ?? []);
+    }
+    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 ?? (n.type ? levelOfType?.(n.type) : void 0)]));
+  return {
+    childrenOf: (id) => [...kids.get(id) ?? []],
+    ancestorsOf,
+    descendantsOf,
+    rollupOf: (id) => ancestorsOf(id).find((a) => !known.has(a)),
+    ancestorOfLevel: (id, level) => ancestorsOf(id).find((a) => known.has(a) && levelOf.get(a) === level),
+    ancestorOfType: (id, type) => ancestorsOf(id).find((a) => known.has(a) && typeOf.get(a) === type),
+    equipmentOf: (id, opts) => {
+      const scope = opts?.deep ? [id, ...descendantsOf(id)] : [id];
+      return scope.flatMap((n) => homes.get(n) ?? []);
+    }
+  };
+}
+var DISPOSITION_DECISION = ["rework", "use-as-is", "scrap", "return-to-supplier", "hold"];
+function testPassedAt(r, at) {
+  if (r.result !== "pass") return false;
+  if (!r.expiresAt || !at) return r.result === "pass";
+  return parsedMs(at) <= parsedMs(r.expiresAt);
+}
+function meetsTests(required, results, at) {
+  if (!required.length) return true;
+  const bySpec = new Map((results ?? []).map((r) => [r.specId, r]));
+  for (const specId of required) {
+    const r = bySpec.get(specId);
+    if (!r) continue;
+    if (!testPassedAt(r, at)) return false;
+  }
+  return true;
+}
+function criterionSaysNothing(c) {
+  if (c?.expression?.trim()) return false;
+  const l = c?.limit;
+  return !(typeof l?.minimum === "number" || typeof l?.maximum === "number");
+}
+function outsideLimit(criterion, observed) {
+  const l = criterion?.limit;
+  if (!l) return void 0;
+  const hasMin = typeof l.minimum === "number";
+  const hasMax = typeof l.maximum === "number";
+  if (!hasMin && !hasMax) return void 0;
+  const raw = observed?.value;
+  if (raw === void 0 || raw === null || String(raw).trim() === "") return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return void 0;
+  const lu = l.uom?.trim();
+  const ou = observed?.uom?.trim();
+  if (lu && ou && lu !== ou) return void 0;
+  if (hasMin && n < l.minimum) return true;
+  if (hasMax && n > l.maximum) return true;
+  return false;
+}
+function testEvidenceGaps(spec, result) {
+  const criteria = spec?.criteria ?? [];
+  const measurements = result?.propertyMeasurements ?? [];
+  const wanted = new Set(criteria.map((c) => c.evaluatedPropertyId).filter((k) => !!k));
+  const got = new Set(measurements.map((m) => m.testableObjectPropertyId).filter((k) => !!k));
+  return {
+    unmeasured: criteria.filter((c) => c.evaluatedPropertyId && !got.has(c.evaluatedPropertyId)).map((c) => c.id),
+    unmatched: measurements.map((m) => m.testableObjectPropertyId).filter((k) => !!k && !wanted.has(k))
+  };
+}
+function judgeAgainstSpec(spec, result) {
+  const criteria = (spec?.criteria ?? []).filter((c) => !criterionSaysNothing(c));
+  if (!criteria.length) return void 0;
+  const measurements = result?.propertyMeasurements ?? [];
+  let allJudged = true;
+  for (const c of criteria) {
+    const m = c.evaluatedPropertyId ? measurements.find((x) => x.testableObjectPropertyId === c.evaluatedPropertyId) : void 0;
+    const out = outsideLimit(c, m);
+    if (out === true) return "fail";
+    if (out === void 0) allJudged = false;
+  }
+  return allJudged ? "pass" : void 0;
+}
+function effectivityAt(p, at, opts) {
+  if (!p || !at) return void 0;
+  const atMs = parsedMs(at);
+  if (!Number.isFinite(atMs)) return void 0;
+  const from = p.effectiveStart ? parsedMs(p.effectiveStart) : NaN;
+  if (Number.isFinite(from) && atMs < from) return "not-yet";
+  const to = p.effectiveEnd ? parsedMs(p.effectiveEnd) : NaN;
+  if (Number.isFinite(to) && (opts?.end === "exclusive" ? atMs >= to : atMs > to)) return "expired";
+  return void 0;
+}
+var PARSED_MAX = 64;
+var parsedCache = /* @__PURE__ */ new Map();
+function parsedMs(at) {
+  const hit = parsedCache.get(at);
+  if (hit !== void 0) return hit;
+  const ms = Date.parse(at);
+  if (parsedCache.size >= PARSED_MAX) parsedCache.clear();
+  parsedCache.set(at, ms);
+  return ms;
+}
+var classIndexCache = /* @__PURE__ */ new WeakMap();
+function classIndex(defs) {
+  if (!defs) return EMPTY_CLASS_INDEX;
+  const hit = classIndexCache.get(defs);
+  if (hit) return hit;
+  const built = new Map(defs.map((d) => [d.id, d]));
+  classIndexCache.set(defs, built);
+  return built;
+}
+var EMPTY_CLASS_INDEX = /* @__PURE__ */ new Map();
+function classClosure(directIds, defs, at) {
+  const byId = classIndex(defs);
+  const inWindow = (d) => !d || effectivityAt(d, at) === void 0;
+  const out = /* @__PURE__ */ new Set();
+  const stack = [...directIds ?? []];
+  while (stack.length) {
+    const id = stack.pop();
+    if (out.has(id)) continue;
+    const def = byId.get(id);
+    if (!inWindow(def)) continue;
+    out.add(id);
+    for (const b of def?.baseIds ?? []) if (!out.has(b)) stack.push(b);
+  }
+  return out;
+}
+var PRIORITY_UNSET = Number.POSITIVE_INFINITY;
+function priorityRank(p) {
+  return typeof p === "number" && Number.isFinite(p) ? p : PRIORITY_UNSET;
+}
+function dueStatusOf(x, nowIso) {
+  if (!x.endTime || !nowIso) return void 0;
+  const due = parsedMs(x.endTime);
+  const now = parsedMs(nowIso);
+  if (!Number.isFinite(due) || !Number.isFinite(now)) return void 0;
+  return now > due ? "late" : "on-time";
+}
+function subLotIdOf(classUri, location) {
+  return `${classUri}@${location}`;
+}
+function itemKeyOf(item) {
+  return item.subLotId ?? item.epc;
+}
+function quantityIn(item, uom, definitions) {
+  const hit = item.quantities?.find((q) => (q.uom ?? void 0) === (uom ?? void 0));
+  if (hit) return hit.value;
+  if ((item.uom ?? void 0) === (uom ?? void 0)) return item.qty;
+  return convertQuantity(item, uom, definitions);
+}
+var MATERIAL_PROPERTY = {
+  /** 기준 단위 하나당 이 단위의 양. `uom` 이 대상 단위. */
+  perBaseUnit: "perBaseUnit"
+};
+function conversionFactorOf(def, uom) {
+  if (!def || !uom) return void 0;
+  for (const p of def.properties ?? []) {
+    if (p.id !== MATERIAL_PROPERTY.perBaseUnit || p.uom !== uom) continue;
+    const n = typeof p.value === "number" ? p.value : Number(p.value);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return void 0;
+}
+function convertQuantity(item, uom, definitions) {
+  if (!definitions || !uom) return void 0;
+  if (typeof item.qty !== "number" || !Number.isFinite(item.qty)) return void 0;
+  if (item.uom) return void 0;
+  const def = definitions.get(item.definitionId ?? item.gtin ?? "");
+  const factor = conversionFactorOf(def, uom);
+  return factor === void 0 ? void 0 : item.qty * factor;
+}
+function minutesOfDay(hhmm) {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm ?? "");
+  if (!m) return void 0;
+  const h = Number(m[1]);
+  const mi = Number(m[2]);
+  if (h > 23 || mi > 59) return void 0;
+  return h * 60 + mi;
+}
+var isAbsolute = (e) => !!(e.startDateTime || e.finishDateTime);
+var needsDate = (e) => isAbsolute(e) || !!e.daysOfWeek?.length;
+function onDeclaredDay(e, minuteOfDay, weekday) {
+  if (!e.daysOfWeek?.length) return true;
+  const from = minutesOfDay(e.fromTime);
+  const to = minutesOfDay(e.toTime);
+  const crosses = from !== void 0 && to !== void 0 && from > to;
+  const startedDay = crosses && minuteOfDay < to ? (weekday + 6) % 7 : weekday;
+  return e.daysOfWeek.includes(startedDay);
+}
+function weekdayAt(ms, utcOffsetMinutes) {
+  return new Date(ms + (utcOffsetMinutes ?? 0) * 6e4).getUTCDay();
+}
+function localDayIndexAt(ms, utcOffsetMinutes) {
+  return Math.floor((ms + (utcOffsetMinutes ?? 0) * 6e4) / 864e5);
+}
+function localDayStartMs(dayIndex, utcOffsetMinutes) {
+  return dayIndex * 864e5 - (utcOffsetMinutes ?? 0) * 6e4;
+}
+function coversInstant(e, atMs) {
+  const from = e.startDateTime ? Date.parse(e.startDateTime) : NaN;
+  const to = e.finishDateTime ? Date.parse(e.finishDateTime) : NaN;
+  if (!Number.isFinite(from) && !Number.isFinite(to)) return false;
+  if (Number.isFinite(from) && atMs < from) return false;
+  if (Number.isFinite(to) && atMs >= to) return false;
+  return true;
+}
+function coversMinute(e, minuteOfDay) {
+  const from = minutesOfDay(e.fromTime);
+  const to = minutesOfDay(e.toTime);
+  if (from === void 0 || to === void 0) return false;
+  return from <= to ? minuteOfDay >= from && minuteOfDay < to : minuteOfDay >= from || minuteOfDay < to;
+}
+function inWorkCalendar(entries, minuteOfDay) {
+  return judgeCalendar(entries, (e) => coversMinute(e, minuteOfDay), false);
+}
+function inWorkCalendarAt(entries, atMs, utcOffsetMinutes) {
+  const minute = minuteOfDayAt(atMs, utcOffsetMinutes);
+  const day = weekdayAt(atMs, utcOffsetMinutes);
+  const covers = (e) => {
+    if (isAbsolute(e)) return coversInstant(e, atMs);
+    if (!coversMinute(e, minute)) return false;
+    return onDeclaredDay(e, minute, day);
+  };
+  return judgeCalendar(entries, covers, true);
+}
+function judgeCalendar(entries, covers, withAbsolute) {
+  if (!entries?.length) return true;
+  const usable = withAbsolute ? entries : entries.filter((e) => !needsDate(e));
+  if (!usable.length) return true;
+  const working = usable.filter((e) => (e.entryType ?? "working") === "working");
+  const off = usable.filter((e) => e.entryType === "non-working");
+  if (off.some(covers)) return false;
+  if (!working.length) return true;
+  return working.some(covers);
+}
+function activeShiftOf(entries, minuteOfDay) {
+  if (!entries?.length) return void 0;
+  if (!inWorkCalendar(entries, minuteOfDay)) return void 0;
+  for (const e of entries) {
+    if (needsDate(e) || (e.entryType ?? "working") !== "working" || !e.id) continue;
+    if (coversMinute(e, minuteOfDay)) return e.id;
+  }
+  return void 0;
+}
+function activeShiftAt(entries, atMs, utcOffsetMinutes) {
+  if (!entries?.length) return void 0;
+  if (!inWorkCalendarAt(entries, atMs, utcOffsetMinutes)) return void 0;
+  const minute = minuteOfDayAt(atMs, utcOffsetMinutes);
+  const day = weekdayAt(atMs, utcOffsetMinutes);
+  for (const e of entries) {
+    if (isAbsolute(e) || (e.entryType ?? "working") !== "working" || !e.id) continue;
+    if (!coversMinute(e, minute)) continue;
+    if (!onDeclaredDay(e, minute, day)) continue;
+    return e.id;
+  }
+  return void 0;
+}
+function minuteOfDayAt(ms, utcOffsetMinutes) {
+  const shifted = ms + (utcOffsetMinutes ?? 0) * 6e4;
+  const DAY = 864e5;
+  const inDay = (shifted % DAY + DAY) % DAY;
+  return Math.floor(inDay / 6e4);
+}
+function offCalendarReasonAt(r, ms, utcOffsetMinutes) {
+  if (!offCalendarAt(r, ms, utcOffsetMinutes)) return void 0;
+  const entries = r.workCalendar;
+  if (!entries?.length) return "off-hours";
+  const minute = minuteOfDayAt(ms, utcOffsetMinutes);
+  const day = weekdayAt(ms, utcOffsetMinutes);
+  for (const e of entries) {
+    if (e.entryType !== "non-working") continue;
+    const covered = isAbsolute(e) ? coversInstant(e, ms) : coversMinute(e, minute) && onDeclaredDay(e, minute, day);
+    if (covered) return "non-working";
+  }
+  return "off-hours";
+}
+function offCalendarAt(r, ms, utcOffsetMinutes) {
+  const minute = minuteOfDayAt(ms, utcOffsetMinutes);
+  if (r.workCalendar?.length) return !inWorkCalendarAt(r.workCalendar, ms, utcOffsetMinutes);
+  const w = r.window;
+  if (!w) return false;
+  const h = Math.floor(minute / 60);
+  return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+}
+function requiredTestsFor(directIds, defs, at) {
+  if (!defs?.length) return [];
+  const cache = requiredTestsCache.get(defs) ?? /* @__PURE__ */ new Map();
+  if (!requiredTestsCache.has(defs)) requiredTestsCache.set(defs, cache);
+  const key = `${at ?? ""}\0${(directIds ?? []).join("
")}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const closure = classClosure(directIds, defs, at);
+  const required = [];
+  for (const d of defs) if (closure.has(d.id)) required.push(...d.testSpecificationIds ?? []);
+  if (cache.size >= REQUIRED_TESTS_MAX) cache.clear();
+  cache.set(key, required);
+  return required;
+}
+var REQUIRED_TESTS_MAX = 512;
+var requiredTestsCache = /* @__PURE__ */ new WeakMap();
+function capabilityOf(r, ctx) {
+  const at = ctx?.at;
+  const eff = effectivityAt(r, at);
+  if (eff === "not-yet") return { available: false, reason: "not-yet" };
+  if (eff === "expired") return { available: false, reason: "retired" };
+  if (r.held) return { available: false, reason: "held" };
+  if (r.status === "down") return { available: false, reason: "down" };
+  if (at) {
+    const ms = parsedMs(at);
+    if (Number.isFinite(ms)) {
+      const why = offCalendarReasonAt(r, ms, ctx?.utcOffsetMinutes);
+      if (why === "non-working") return { available: false, reason: "resting" };
+      if (why === "off-hours") return { available: false, reason: "off-shift" };
+    }
+  }
+  if (ctx?.requiredTests?.length && !meetsTests(ctx.requiredTests, r.testResults, at))
+    return { available: false, reason: "test-expired" };
+  if (r.status && r.status !== "idle" && r.status !== "available") return { available: false, reason: "working" };
+  return { available: true, reason: "available" };
+}
+function observationAt(observations, propertyId, at) {
+  const t = parsedMs(at);
+  if (!(t >= 0)) return void 0;
+  let best;
+  let bestStart = -1;
+  for (const o of observations ?? []) {
+    if (o.propertyId !== propertyId) continue;
+    const from = parsedMs(o.effectiveTime);
+    if (!(from >= 0) || from > t) continue;
+    if (o.effectiveEndTime) {
+      const to = parsedMs(o.effectiveEndTime);
+      if (to >= 0 && to < t) continue;
+    }
+    if (from > bestStart) {
+      best = o;
+      bestStart = from;
+    }
+  }
+  return best;
+}
+var OP_EVENT = {
+  task: "task.status",
+  equipment: "equipment.status",
+  /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
+  person: "person.status",
+  /** 물리 자산 상태 전이 — 어디 있나·무엇을 싣고 있나(빈 팔레트인가). */
+  asset: "asset.status",
+  order: "order.status",
+  quality: "quality.output",
+  // 품질 산출(양품/불량) — OEE quality 입력. live 누적기가 이걸로 good/scrap 정확 추적.
+  /**
+   * **시험 결과** — 어느 대상을 어느 기준으로 재고 판정했나.
+   *
+   * `quality.output` 과 **다른 사실이다.** 그것은 생산의 양품·불량 수(가동률 입력)이고, 이것은 선언된
+   * 기준에 대한 검사 판정이다. 한 낱말이 두 일을 하면 어느 쪽 어휘도 옳지 않게 된다.
+   *
+   * **대상을 가리킨다**(`testableObjectId`) — 표준 `TestResult.TestableObjectID` 그대로. 로트·설비·
+   * 사람·자리에 두루 쓰이므로 주체를 이름에 넣지 않았다.
+   *
+   * 이 채널이 없으면 시험 결과는 **상태에만 있는 축**이 된다 — 재기동에서 사라지고, 폴드가 되살릴 수
+   * 없고, 미러가 이어받지 못한다(§상태 ⊆ 이벤트).
+   */
+  test: "test.result",
+  /**
+   * **부적합 처분** — 재고 판정을 받은 것을 어떻게 하기로 정했나(재작업 · 특채 · 폐기 · 반품).
+   *
+   * ── 판정과 다른 사실이다 (2026-08-30) ─────────────────────────────────────
+   * `test.result` 에 필드로 붙이지 않는다. 셋 중 둘을 표현할 수 없게 되기 때문이다.
+   *
+   *   한 판정에 처분이 여럿   일부는 재작업하고 일부는 폐기한다
+   *   처분 없는 판정          기록만 하고 결정은 나중에 한다
+   *   판정 없는 처분          현장 재량으로 뺀다
+   *
+   * ── 왜 커널이 아는가 ──────────────────────────────────────────────────────
+   * 처분은 **자원에 효과를 준다.** 재작업은 자재를 다시 공정에 넣고, 폐기는 재고에서 뺀다. 효과를 주는
+   * 사실은 커널 1급이다.
+   *
+   * EPCIS 의 `disposition` 과 헷갈리지 않는다 — 그것은 **개체의 상태**(`damaged`·`destroyed`)이고
+   * 이것은 **결정**이다. 누가·언제·왜 그렇게 정했는지의 자리는 그쪽에 없다.
+   */
+  disposition: "nonconformance.disposition",
+  /**
+   * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 그것을 알린다.
+   *
+   * ── 왜 필요한가 (2026-08-25 실측) ────────────────────────────────────────
+   * 연결된 시스템은 매 주기 현재 재고를 전부 보낸다. 그런데 트윈은 그것을 낱낱의 관측으로 받아
+   * **더하기만 했다.** 「그리고 이것 말고는 없다」를 받는 곳이 없어서, 목록에서 빠진 줄은 아무 말도
+   * 오지 않은 것이 되고 트윈에 영원히 남았다.
+   *
+   * 실측: 실제 재고 1,704건인데 트윈이 10,038건을 갖고 있었다.
+   *
+   * ── 왜 「사라진 것을 알려 주기」가 아니라 이 방식인가 ──────────────────────
+   * 연결 쪽이 앞 주기와 비교해 사라진 줄을 찾아 알리는 방법도 있다. 그런데 그것은 **하나 빠뜨리면
+   * 그 줄이 영원히 남는다.** 이 방식은 주기마다 스스로 바로잡는다 — 이미 잘못 쌓인 것도 다음 주기에
+   * 사라진다.
+   *
+   * ── 보내는 쪽이 지킬 것 ─────────────────────────────────────────────────
+   * **끝까지 읽었을 때만 보낸다.** 읽다가 끊긴 주기에 이것을 보내면 **살아 있는 재고를 지운다.**
+   * 그리고 `since` 는 그 주기를 **시작한** 시각이다(끝낸 시각이 아니다) — 주기 도중에 들어온 관측이
+   * 지워지지 않아야 한다.
+   */
+  complete: "axis.complete",
+  /**
+   * 주목 신호 확인(ack) — **사람이 한 행위**라 파생될 수 없다.
+   *
+   * 다른 파생 상태는 상태에서 다시 계산된다(주목 신호 자체가 그렇다). 그런데 "누가 이것을 봤다" 는
+   * 계산으로 되살릴 수 없다. 저널에 남기지 않으면 재기동하면 확인해 둔 신호가 다시 빨개지고,
+   * 과거를 다시 계산해도 그때 무엇을 확인했는지 알 수 없다 — 저널이 현실을 불완전하게 담는 자리였다.
+   */
+  /*
+   * 값이 커맨드(`CMD.attentionAck='attention.ack'`)와 겹치지 않게 **과거형**으로 둔다 — 커맨드는
+   * "확인해라"(요청)이고 이벤트는 "확인했다"(사실)다. 같은 문자열을 쓰면 저널에서 요청과 사실이
+   * 구별되지 않는다.
+   */
+  attentionAck: "attention.acked",
+  /**
+   * **자리에서 관측된 물리량** — 냉장실 온도·습도, 세척수 유량 같은 것(§`LocationObservation`).
+   *
+   * ── 왜 채널이 필요한가 ────────────────────────────────────────────────────
+   * `LocationState.observations` 를 상태에 두었는데 그것을 낳는 사건이 없었다. 그러면 **상태 ⊆ 이벤트**
+   * 가 깨진다: 채워도 재기동에서 사라지고, 폴드가 되살릴 수 없고, 미러가 이어받을 수도 없다. 상태에만
+   * 있는 축은 조용히 사라지는 축이다.
+   *
+   * 이름을 `energy.measured` 와 같은 결로 둔다 — 그쪽이 에너지 계량의 도착이고 이쪽이 그 일반형이다.
+   * 두 채널을 합치지 않는 이유는 에너지 쪽이 **구간에 누적되는 표본**이라 처리가 다르기 때문이다.
+   */
+  observation: "location.measured"
+};
+var ENERGY_EVENT = {
+  /** 계량 도착 — 그 시점의 유효전력·누적량. 15분 수요 구간에 누적된다. */
+  measured: "energy.measured",
+  /**
+   * 설비의 에너지 상태 — 발전·저장·감축 여지·개폐 위치.
+   *
+   * 계량과 다른 사건으로 둔다: 계량은 구간에 **누적**되고 이것은 그 설비의 **지금**을 바꾼다.
+   */
+  equipment: "energy.equipment",
+  /** 수요 구간 마감 — 그 구간의 최대 수요가 확정된다(요금의 단위). */
+  demandWindow: "energy.demand.window",
+  /**
+   * **마감된 사용 구간이 도착했다** — 우리가 마감한 것이 아니라 밖에서 확정되어 온 것이다.
+   *
+   * 계량 표본이 오지 않는 현장이 있다. 공급자의 조회나 계량 데이터 시스템이 「이 구간에 X 썼다」를
+   * 이미 마감해 준다. 그 값을 적산(`energy.measured` 의 `kWh`)으로 보내면 커널이 그것을 누적으로
+   * 읽고 차분을 또 구한다 — 차분의 차분이 되어 틀린다. 그래서 다른 사건이다.
+   *
+   * `demandWindow` 와 **합치지 않는다.** 하나는 우리가 표본에서 마감한 것이고 이것은 밖에서 온
+   * 것이다. 두 회계를 더하면 같은 전기를 두 번 센다. 둘 다 있으면 읽는 쪽이 하나를 고르고 어느
+   * 쪽인지 말한다.
+   */
+  usagePeriod: "energy.usage.period",
+  /**
+   * **발전에 매겨지는 단가가 정해졌다** — 이 기간에 낸 전기 1kWh 의 값.
+   *
+   * 소비에 요금이 매겨지듯 발전에도 값이 매겨진다. 파는 발전소는 판 값이고, 자가소비형은 아꼈다고
+   * 볼 수 있는 값이다 — 어느 쪽인지는 현장이 정한다.
+   *
+   * **단가는 날마다 바뀐다.** 그래서 선언이 아니라 기간을 가진 사실로 받는다. 선언에 적어 두면
+   * 사람이 매일 갱신해야 하고, 안 하면 낡은 값으로 수익이 조용히 틀린다.
+   *
+   * 사건 시각은 기간의 시작이다 — 「이 시각부터 이 단가가 적용된다」이므로 기간이 끝나기 전에 성립한다.
+   *
+   * ── 담지 않은 것 ────────────────────────────────────────────────────────────
+   * 제도마다 있는 가산·인증서·가중치는 담지 않는다. 그 셈은 제도가 정하고 나라마다 다르므로,
+   * 커넥터가 계산해 **1kWh 당 얼마**로 옮겨 보낸다. 커널이 한 제도의 모양을 안으면 다른 제도에서
+   * 그 자리가 거짓이 된다.
+   */
+  generationPrice: "energy.generation.price",
+  /**
+   * **이 주기에 적용되는 요금 기준이 정해졌다** — 요금적용전력과 기본요금 단가.
+   *
+   * 청구서와 다른 사건이다. 청구서는 끝난 기간의 정산이고 이것은 **지금 적용되는 기준**이다.
+   * 그래서 사건 시각도 다르다 — 청구서는 기간의 끝, 이것은 기간의 시작이다(그때부터 유효하다).
+   *
+   * 이 값은 매 주기 다시 정해진다. 모델의 선언에 적어 두면 사람이 매달 갱신해야 하고, 안 하면 낡은
+   * 값으로 기본요금이 조용히 틀린다. 공급자가 알려 주는 값을 그대로 받는 것이 맞다.
+   *
+   * **금액을 싣지 않는다.** 요금적용전력 × 단가는 커널이 계산한다. 곱을 받으면 그것이 정산인 척한다.
+   */
+  tariffBasis: "energy.tariff.basis",
+  /**
+   * **청구서가 도착했다** — 공급자가 확정한 금액.
+   *
+   * 우리가 계산한 금액(§`electricityCost`)을 덮지 않는다. 두 값은 다른 것이다: 청구는 사실이고 우리
+   * 계산은 파생이다(구간 요금·예측·가정 비교에 쓴다). 계기 적산과 같은 규율이다 — 다를 때 맞는 쪽은
+   * 그 회계를 가진 쪽이다.
+   *
+   * 어긋나면 **그 사실을 낸다.** 우리 계산이 틀렸다는 뜻이고, 그것을 사람이 찾아내지 않아도 드러나야
+   * 한다(실제로 사람이 찾아낸 적이 있다 — 기본요금을 이 주기의 최대로 매기고 있었다).
+   */
+  bill: "energy.bill",
+  /**
+   * 피크 경신 — 월 최대 수요가 갱신됐다.
+   *
+   * 구간 마감에서 파생되지만 **사실로 남긴다**: 요금의 근거이고, 나중에 "언제 무엇 때문에 올랐나" 를
+   * 물을 때 파생으로는 답할 수 없다(그 순간의 부하 구성이 사라진다).
+   */
+  peak: "energy.peak",
+  /** 요금 구간 전환 — 경부하·중간부하·최대부하. 달력이 아니라 사건이다(계절제·특례로 바뀐다). */
+  tariffShift: "energy.tariff.shift",
+  /** 발전(PV 등) — 역송을 포함한다(음의 소비가 아니라 별개 사실이다). */
+  generated: "energy.generated",
+  /**
+   * **기간 발전량 확정** — 한 기간이 끝났고 그 기간에 얼마 냈는지가 정해졌다.
+   *
+   * ISO 50001 의 성과지표와 기준선, 태양광 성능비가 모두 「기간당 에너지」로 정의된다. 적산값만 상태에
+   * 두면 그 어느 것도 계산할 수 없고, 지난 기간들을 합할 수도 없다(상태는 지금 하나만 든다).
+   *
+   * 계량이 수요 구간을 마감해 사실로 내는 것과 같은 짝이다(§`demandWindow`). 두 값을 더하지 말 것 —
+   * 발전량은 설비가 만든 양이고 구간 전력량은 계량 지점을 지난 양이다.
+   */
+  generationPeriod: "energy.generation.period",
+  /** 저장(ESS 충전). */
+  stored: "energy.stored",
+  /** 방전(ESS). 충전과 나눈다 — 손실·수명 판단이 둘을 구별해야 한다. */
+  discharged: "energy.discharged",
+  /**
+   * 수요 제어 제안 — **제안이지 명령이 아니다.**
+   *
+   * 이 트윈은 차단·투입을 하지 않는다(안전 계통은 범위 밖: `ems.md` §1). 이대로면 계약을 넘는다는
+   * 판단과 무엇을 줄이면 되는지를 낼 뿐이고, 집행은 사람과 그 시스템의 몫이다. 이름을 `suggested`
+   * 로 둔 이유가 그것이다 — 저널만 보고도 "우리가 끈 것이 아니다" 를 알 수 있어야 한다.
+   */
+  drSuggested: "energy.dr.suggested"
+};
+var OBSERVATION_BASIS = ["metered", "provider", "billed", "estimated"];
+var CMD = {
+  orderHold: "order.hold",
+  orderResume: "order.resume",
+  orderRelease: "order.release",
+  attentionAck: "attention.ack",
+  // 주목 신호 확인(OPC UA A&C acknowledge) — args:{id}
+  // Operable 코어 — 모든 operable 자원(설비·이동설비) 공통. args:{resourceId}. capability-keyed(무방언, equipment.* 아님).
+  resourceHold: "resource.hold",
+  // 계획 정지(정비/오프라인) — 배정 스킵
+  resourceResume: "resource.resume",
+  // 계획 정지 해제
+  resourceDown: "resource.down",
+  // 비계획 고장 주입 — args:{resourceId, durationMs?}
+  resourceRepair: "resource.repair",
+  // 즉시 수리
+  resourceResetMetrics: "resource.reset-metrics",
+  // OEE 계측 창 리셋
+  resourceAdd: "resource.add"
+  // 라이브 자원(설비) 추가 — args:{kind, homeLocation, count?}. 런타임 구조 변이(what-if 아닌 실제 act)
+};
+function readBoardLocations(def) {
+  const d = def;
+  return d.locations ?? d.nodes ?? [];
+}
+function readBoardEquipment(def) {
+  const d = def;
+  const list = d.equipment ?? d.equipmentList ?? d.movers ?? [];
+  return list.map((e) => normalizeHomeLocation(e));
+}
+function normalizeHomeLocation(entry) {
+  const legacy = entry.homeNode;
+  if (legacy === void 0 || entry.homeLocation !== void 0) return entry;
+  const { homeNode: _drop, ...rest } = entry;
+  return { ...rest, homeLocation: legacy };
+}
+function readBoardAssets(def) {
+  const list = def.assets ?? [];
+  return list.map((a) => normalizeHomeLocation(a));
+}
+function identityGroundingOf(spec, kernelConstantPrefix) {
+  const declared = spec?.identity?.namespaces?.filter((n) => typeof n === "string" && n.length > 0) ?? [];
+  if (spec?.identity?.issuedClaim && declared.length) {
+    return { grounding: "issued", basis: "claimed-issued", namespaces: [...declared] };
+  }
+  if (declared.length) return { grounding: "declared", basis: "declared-namespace", namespaces: [...declared] };
+  if (spec?.companyPrefix && spec.binding) {
+    return { grounding: "declared", basis: "gs1-shaped", namespaces: gs1Namespaces(spec.companyPrefix) };
+  }
+  return {
+    grounding: "fabricated",
+    basis: "kernel-constant",
+    namespaces: kernelConstantPrefix ? gs1Namespaces(kernelConstantPrefix) : []
+  };
+}
+function gs1Namespaces(prefix) {
+  return [`urn:epc:idpat:sgtin:${prefix}.`, `urn:epc:class:lgtin:${prefix}.`, `urn:epc:id:sgtin:${prefix}.`];
+}
+
+// src/capacity.ts
+function isoDurationHours(iso) {
+  if (!iso) return 0;
+  const m = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?)?$/.exec(iso);
+  if (!m) throw new Error(`\uAE30\uAC04 \uD45C\uAE30\uB97C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${iso}`);
+  return Number(m[1] ?? 0) * 24 + Number(m[2] ?? 0) + Number(m[3] ?? 0) / 60 + Number(m[4] ?? 0) / 3600;
+}
+function paramOf(op, id) {
+  return op.parameters?.find((p) => p.id === id)?.value;
+}
+function workingTimeOfWeek(calendar, weekStartMs, utcOffsetMinutes) {
+  if (!calendar?.length) return { hoursPerWeek: 7 * 24, daysPerWeek: 7 };
+  let minutes = 0;
+  const touched = /* @__PURE__ */ new Set();
+  for (let m = 0; m < 7 * 24 * 60; m++) {
+    if (!inWorkCalendarAt(calendar, weekStartMs + m * 6e4, utcOffsetMinutes)) continue;
+    minutes++;
+    touched.add(Math.floor((m + (utcOffsetMinutes ?? 0)) / (24 * 60)));
+  }
+  const declared = /* @__PURE__ */ new Set();
+  for (const e of calendar) if (e.entryType !== "non-working") for (const d of e.daysOfWeek ?? []) declared.add(d);
+  return { hoursPerWeek: minutes / 60, daysPerWeek: declared.size || touched.size };
+}
+function availabilityOf(records) {
+  const ratios = records.map((r) => r.mtbfMs && r.mttrMs ? r.mtbfMs / (r.mtbfMs + r.mttrMs) : 1);
+  return ratios.length ? ratios.reduce((a, b) => a + b, 0) / ratios.length : 1;
+}
+function analyzeCapacity(input) {
+  const { hoursPerWeek, daysPerWeek } = workingTimeOfWeek(input.calendar, input.sampleWeekStartMs, input.utcOffsetMinutes);
+  const demandPerHour = hoursPerWeek > 0 ? input.unitsPerDay * daysPerWeek / hoursPerWeek : 0;
+  const equipmentByKind = /* @__PURE__ */ new Map();
+  for (const e of input.equipment ?? []) {
+    const list = equipmentByKind.get(e.kind) ?? [];
+    list.push(e);
+    equipmentByKind.set(e.kind, list);
+  }
+  const countByClass = (rows, field) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const r of rows ?? []) for (const c of r[field] ?? []) out.set(c, (out.get(c) ?? 0) + 1);
+    return out;
+  };
+  const personsByClass = countByClass(input.persons, "personnelClassIds");
+  const assetsByClass = countByClass(input.assets, "assetClassIds");
+  const slotsByLocationType = /* @__PURE__ */ new Map();
+  for (const l of input.locations ?? [])
+    if (l.type) slotsByLocationType.set(l.type, (slotsByLocationType.get(l.type) ?? 0) + Math.max(l.capacity ?? 1, 1));
+  const order = input.route?.length ? input.route.map((k) => input.operations.find((o) => o.key === k)).filter((o) => !!o) : [...input.operations];
+  let downstream = 1;
+  const reversed = [];
+  for (const op of [...order].reverse()) {
+    const cycleHours = isoDurationHours(op.duration) + isoDurationHours(paramOf(op, "setupDuration"));
+    downstream *= Number(paramOf(op, "yield") ?? 1);
+    const requiredPerHour = downstream > 0 ? demandPerHour / downstream : Infinity;
+    const requirements = [];
+    const add = (axis, className, quantity, available, availability) => {
+      const q = Math.max(quantity, 1);
+      requirements.push({
+        axis,
+        className,
+        quantity: q,
+        available,
+        availability,
+        perHour: cycleHours > 0 ? Math.floor(available / q) / cycleHours * availability : Infinity
+      });
+    };
+    const equipSpecs = op.equipmentSpecification?.length ? op.equipmentSpecification.map((s) => ({ className: s.equipmentClass ?? op.resourceType ?? "", quantity: s.quantity })) : op.resourceType ? [{ className: op.resourceType, quantity: 1 }] : [];
+    for (const s of equipSpecs) {
+      if (!s.className) continue;
+      const records = equipmentByKind.get(s.className) ?? [];
+      add("equipment", s.className, s.quantity, records.length, availabilityOf(records));
+    }
+    for (const s of op.personnelSpecification ?? [])
+      if (s.personnelClass) add("personnel", s.personnelClass, s.quantity, personsByClass.get(s.personnelClass) ?? 0, 1);
+    for (const s of op.physicalAssetSpecification ?? [])
+      if (s.assetClass) add("asset", s.assetClass, s.quantity, assetsByClass.get(s.assetClass) ?? 0, 1);
+    if (op.locationType) add("location", op.locationType, 1, slotsByLocationType.get(op.locationType) ?? 0, 1);
+    const constraint = requirements.length ? requirements.reduce((a, b) => a.perHour <= b.perHour ? a : b) : void 0;
+    const perHour = constraint ? constraint.perHour : Infinity;
+    reversed.push({ operation: op.key, cycleHours, perHour, requiredPerHour, ok: perHour >= requiredPerHour, constraint, requirements });
+  }
+  const operations = reversed.reverse();
+  const tightest = operations.length ? operations.reduce((a, b) => a.perHour / a.requiredPerHour <= b.perHour / b.requiredPerHour ? a : b) : void 0;
+  const headroom = operations.length ? Math.min(...operations.map((o) => o.perHour / o.requiredPerHour)) : Infinity;
+  return {
+    workingHoursPerWeek: hoursPerWeek,
+    workingDaysPerWeek: daysPerWeek,
+    demandPerHour,
+    operations,
+    ...tightest ? { bottleneck: { operation: tightest.operation, axis: tightest.constraint?.axis, className: tightest.constraint?.className } } : {},
+    maxUnitsPerDay: input.unitsPerDay * headroom,
+    ok: operations.every((o) => o.ok)
+  };
+}
+
+// src/wms-profile.ts
+var BIZSTEP = {
+  receiving: "urn:epcglobal:cbv:bizstep:receiving",
+  storing: "urn:epcglobal:cbv:bizstep:storing",
+  picking: "urn:epcglobal:cbv:bizstep:picking",
+  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"
+};
+var BTT = {
+  po: "urn:epcglobal:cbv:btt:po",
+  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" }, 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/yms-profile.ts
+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 BTT_DELIVERY = "urn:epcglobal:cbv:btt:deliv";
+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" }, 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"] }
+];
+
+// src/mes-profile.ts
+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"] }
+];
+
+// src/ems-profile.ts
+var EMS_LOCATION_TYPES = ["incoming", "feeder", "submeter-zone"];
+var METER_DIRECTION = ["import", "export", "bidirectional"];
+var EMS_EQUIPMENT_TYPES = ["meter", "breaker", "pv-array", "battery", "utility", "curtailable-load"];
+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 byId = new Map((locations ?? []).filter((l) => l?.id).map((l) => [String(l.id), l]));
+  const self = byId.get(String(id));
+  if (!self) return void 0;
+  if (self.upstreamId) return String(self.upstreamId);
+  const parent = self.parentId ? byId.get(String(self.parentId)) : void 0;
+  if (!parent) return void 0;
+  return isElectricalLocationType(String(parent.type ?? "")) ? String(parent.id) : void 0;
+}
+function isElectricalLocationType(type) {
+  return EMS_LOCATION_TYPES.includes(type);
+}
+
+// src/domain-catalog.ts
+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) }
+};
+var LOGISTICS = ["wms", "yms", "mes"];
+var TWIN_AXES = [
+  {
+    axis: "locations",
+    path: "locations",
+    label: "twin.axis.locations",
+    kind: "instance",
+    typeRole: "location",
+    standardClass: { epcis: "SGLN" }
+  },
+  {
+    axis: "equipment",
+    path: "equipment",
+    label: "twin.axis.equipment",
+    kind: "instance",
+    typeRole: "equipment",
+    standardClass: { isa95: "Equipment", iso55000: "Asset", epcis: "GIAI" }
+  },
+  {
+    axis: "persons",
+    path: "persons",
+    label: "twin.axis.persons",
+    kind: "instance",
+    standardClass: { isa95: "Person" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "assets",
+    path: "assets",
+    label: "twin.axis.assets",
+    kind: "instance",
+    standardClass: { isa95: "PhysicalAsset", iso55000: "Asset" }
+  },
+  {
+    axis: "personnelClasses",
+    path: "personnelClasses",
+    label: "twin.axis.personnelClasses",
+    kind: "class",
+    standardClass: { isa95: "PersonnelClass" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "equipmentClasses",
+    path: "equipmentClasses",
+    label: "twin.axis.equipmentClasses",
+    kind: "class",
+    standardClass: { isa95: "EquipmentClass" }
+  },
+  {
+    axis: "assetClasses",
+    path: "assetClasses",
+    label: "twin.axis.assetClasses",
+    kind: "class",
+    standardClass: { isa95: "PhysicalAssetClass" }
+  },
+  {
+    axis: "materialDefinitions",
+    path: "materialDefinitions",
+    label: "twin.axis.materialDefinitions",
+    kind: "class",
+    standardClass: { isa95: "MaterialDefinition" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "materialClasses",
+    path: "materialClasses",
+    label: "twin.axis.materialClasses",
+    kind: "class",
+    standardClass: { isa95: "MaterialClass" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "operations",
+    path: "operations",
+    label: "twin.axis.operations",
+    kind: "spec",
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "productionSpec",
+    path: "productionSpec",
+    label: "twin.axis.productionSpec",
+    kind: "spec",
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
+  },
+  /*
+   * 아래 셋은 저장상 `productionSpec.definition` 안에 있지만 **개념으로는 1급**이다.
+   * `materials` 가 최상위 `materialDefinitions` 와 **둘 다** 있는 것은 지금 상태 그대로다 —
+   * 전자는 도메인 정의의 가벼운 목록(`{key,label}`), 후자는 ISA-95 풍부형이다. 같은 것의 집이
+   * 둘이라는 사실을 **선언이 드러낸다**(감추면 화면이 어느 쪽을 보는지 아무도 모른다).
+   */
+  {
+    axis: "recipes",
+    path: "productionSpec.definition.recipes",
+    label: "twin.axis.recipes",
+    kind: "spec",
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "routes",
+    path: "productionSpec.definition.routes",
+    label: "twin.axis.routes",
+    kind: "spec",
+    standardClass: { isa95: "OperationsSegment" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "materials",
+    path: "productionSpec.definition.materials",
+    label: "twin.axis.materials",
+    kind: "class",
+    standardClass: { isa95: "MaterialDefinition" },
+    systems: LOGISTICS
+  },
+  /*
+   * 시험 명세 — **자원 아홉 종류가 가리키는 대상.**
+   *
+   * 이 축이 없던 동안 `testSpecificationIds` 는 허공을 가리켰다(값은 실리는데 무엇인지 아무도 모른다).
+   * 축이 서면 인스펙션의 선 채움이 **끊어진 참조를 센다** — 없는 명세를 가리키면 화면이 말한다.
+   *
+   * `kind: 'spec'` 이다: 자원도 등급도 아니고 **판정의 정의**다(공정·레시피와 같은 부류).
+   */
+  {
+    axis: "testSpecifications",
+    path: "testSpecifications",
+    label: "twin.axis.testSpecifications",
+    kind: "spec",
+    standardClass: { isa95: "TestSpecification" }
+  },
+  /*
+   * ── ISA-95 Part 4 — 일정과 실적 ────────────────────────────────────────────────
+   *
+   * 여기부터는 **선언이 아니다.** 오더와 작업은 사람이 board 에 적어 두는 값이 아니라 현장이 낳는
+   * 사실이고, 그 집은 커널 상태와 저널이다. 그래서 `source` 가 `'state'` 이고 `path` 가 없다.
+   *
+   * ── 왜 축이어야 하나 ──────────────────────────────────────────────────────────
+   * 이 둘이 축이 아니던 동안 "이 트윈이 표준의 어디를 채우나" 라는 질문은 **절반만** 답했다. Part 2
+   * 자원 모델은 여덟이 완전한데 Part 4 는 통째로 비어 있었다 — 런타임에는 실재하는데 조회 모델에는
+   * 없었기 때문이다. 실적을 성과 화면이 답한다는 것은 사실이지만, 그건 **집계**이고 개념 자체를
+   * 가리켜 걸어 들어갈 자리는 없었다(어느 오더가 어느 공정에서 무엇을 먹었나).
+   *
+   * ── 왜 테이블로 투영하지 않나 ─────────────────────────────────────────────────
+   * 정본이 저널이다. 구조 엔티티는 **원본이 낼 수 있는 것만** 담고(ADR-0032-D), 오더는 원본이 낸
+   * 것이지만 트윈이 **관측한** 것이다. 투영은 규모에서 성능이 필요해질 때 KPI 폴드와 같은 급의
+   * 별도 결정으로 한다.
+   */
+  {
+    axis: "orders",
+    label: "twin.axis.orders",
+    kind: "instance",
+    source: "state",
+    historical: true,
+    standardClass: { isa95: "OperationsRequest", epcis: "TransactionEvent" },
+    systems: LOGISTICS
+  },
+  {
+    axis: "tasks",
+    label: "twin.axis.tasks",
+    kind: "instance",
+    source: "state",
+    historical: true,
+    standardClass: { isa95: "SegmentResponse", epcis: "TransformationEvent" },
+    systems: LOGISTICS
+  },
+  /*
+   * ── 물품이 축이 아니었다 (2026-08-22) ──────────────────────────────────────
+   * 트윈에서 **수가 가장 많은 것**이 물품인데(실측: 엔티티 3,611 중 2,400 · hatio-us 는 2,805) 그것을
+   * 가리켜 걸어 들어갈 자리가 없었다. 지도와 집약 태그에는 이미 보이는데 「모델 살펴보기」에는 문이
+   * 없었다 — 사용자가 트윈에 가장 자주 묻는 것이 「내 물건이 어디 있나」이므로 그것은 접근 장벽이다.
+   *
+   * 성격은 `orders`·`tasks` 와 같다: 상태에 살고, 저널에 이력이 있고, 원본이 낸 것을 트윈이 관측한다.
+   * 그래서 같은 조합(`instance` · `state` · `historical`)이다.
+   *
+   * ── 표준 대응 ─────────────────────────────────────────────────────────────
+   * ISA-95 는 `MaterialLot` 이다 — 물품은 「무슨 품목인가」(정의)가 아니라 「그 품목의 이 덩어리」이고,
+   * 위치·수량·부분(`MaterialSubLot`)을 그 자리가 든다. EPCIS 는 `ObjectEvent` 다: 개체가 생기고
+   * 관측되고 사라지는 것을 그 사건이 말한다.
+   *
+   * ── 무엇이 이 항목을 가리키나 ─────────────────────────────────────────────
+   * `subLotId ?? epc` 다. 짐작에 맡기면 `gtin` 으로 떨어지고, 그러면 **같은 품목의 물품 전부가 한
+   * 식별자로 뭉친다** — 화면이 2,400개를 몇 개로 보인다.
+   */
+  {
+    axis: "items",
+    label: "twin.axis.items",
+    kind: "instance",
+    source: "state",
+    historical: true,
+    idField: ["subLotId", "epc"],
+    standardClass: { isa95: "MaterialLot", epcis: "ObjectEvent" },
+    systems: LOGISTICS
+  },
+  /*
+   * ── 에너지가 더하는 개념은 **하나**다 (2026-08-14, §10 6.5단계) ──────────────
+   *
+   * 에너지 트윈의 개체 대부분은 **이미 있는 축**이 답한다: 전기 구간은 `locations`, 계량기·차단기·
+   * 태양광·축전지·감축 부하는 `equipment` 다(카탈로그가 그 타입들을 그 역할로 선언한다). 그것들을
+   * 새 축으로 다시 세우면 같은 것이 두 곳에서 세어진다 — 개념 지도가 계량기를 두 번 보여 준다.
+   *
+   * 정말로 새로운 것은 **수요 구간**이다: 자원이 아니고, 선언이 아니고, 15분마다 닫히는 **사실**이다.
+   * 그것이 요금의 알갱이이고 피크의 근거다(피크는 마감된 구간의 최대이므로 파생이다 — 축이 아니다).
+   *
+   * ── 표준 칸을 비운다 ──────────────────────────────────────────────────────
+   * 15분 수요 구간은 **요금 제도의 알갱이**다(계약·TOU). ISO 50001 은 경영 체계를, IEC 61850 은 설비
+   * 데이터 모델을 말하고, 둘 다 이 구간을 정의하지 않는다. 가까운 이름을 적으면 적합성 표가 거짓을
+   * 말하므로 비워 둔다 — 「표준에 자리가 없으면 빈 객체」라는 이 선언의 규율 그대로다.
+   *
+   * 아직 세우지 않은 것: **요금 구간**(TariffPeriod)과 **원단위**(EnPI). 둘 다 아직 아무도 만들지
+   * 않는다 — 선언만 하면 개념 지도가 언제나 0 을 보여 주고, 그것은 결손처럼 읽힌다(§10 7단계의 일).
+   */
+  /*
+   * **무엇이 이 항목을 가리키나** — `idField` 가 말한다.
+   *
+   * 수요 구간에는 `id` 가 없다. 그것이 결함은 아니다: 구간의 정체성은 **그 구간이 언제 시작했나**이고
+   * (요금의 알갱이가 그 시각으로 정해진다) 커널도 그것으로 키를 만든다(`contract-projected-over:<startMs>`).
+   *
+   * 그런데 소비처가 `id`·`key`·`gtin` 을 **짐작**하고 있어서, 화면이 여섯 구간 모두를 「식별자 없음 —
+   * 참조할 수 없는 항목」으로 보였다. 값은 실재하는데 가리킬 수 없다고 말한 것이다. 짐작을 없애고
+   * 선언이 답하게 한다 — 축이 사는 자리(`path`)를 선언하는 것과 같은 이유다.
+   */
+  {
+    axis: "demandWindows",
+    path: "energy.closed",
+    idField: "startMs",
+    label: "twin.axis.demandWindows",
+    kind: "instance",
+    source: "state",
+    historical: true,
+    standardClass: {},
+    systems: ["ems"]
+  }
+];
+var TWIN_RELATIONS = [
+  /* 자리가 속한 구역 — **board 밖**(호스트의 `TwinArea`). 해소는 호스트가 한다. */
+  { from: "locations", field: "parentId", target: { kind: "external", entity: "space.area" }, via: "twin.rel.area", optional: true },
+  /* 자원이 사는 자리 */
+  { from: "equipment", field: "homeLocation", target: { kind: "axis", axis: "locations" }, via: "twin.rel.home", optional: true },
+  { from: "persons", field: "homeLocation", target: { kind: "axis", axis: "locations" }, via: "twin.rel.home", optional: true },
+  { from: "assets", field: "homeLocation", target: { kind: "axis", axis: "locations" }, via: "twin.rel.home", optional: true },
+  /* 자원의 등급 — 설비만 `kind`(타입)로 가고 사람·자산은 등급 목록으로 간다. 표준의 비대칭 그대로. */
+  { from: "persons", field: "personnelClassIds[]", target: { kind: "axis", axis: "personnelClasses" }, via: "twin.rel.class", optional: true },
+  { from: "assets", field: "assetClassIds[]", target: { kind: "axis", axis: "assetClasses" }, via: "twin.rel.class", optional: true },
+  { from: "equipment", field: "kind", target: { kind: "type", role: "equipment" }, via: "twin.rel.type" },
+  { from: "locations", field: "type", target: { kind: "type", role: "location" }, via: "twin.rel.type" },
+  /* 생산 — 레시피에서 시작해 라우트·공정·품목으로 퍼진다 */
+  { from: "recipes", field: "route", target: { kind: "axis", axis: "routes" }, via: "twin.rel.route", optional: true },
+  { from: "recipes", field: "inputs[].material", target: { kind: "axis", axis: "materials" }, via: "twin.rel.input" },
+  { from: "recipes", field: "outputs[].material", target: { kind: "axis", axis: "materials" }, via: "twin.rel.output" },
+  { from: "routes", field: "steps[]", target: { kind: "axis", axis: "operations" }, via: "twin.rel.step" },
+  /*
+   * 일정·실적의 관계 — **관측 관계다.** 선언 관계는 "그렇게 만들기로 했다" 이고, 이것은 "그렇게
+   * 일어났다" 다. 관계가 없으면 이 두 축은 지도에서 연결되지 않은 카드가 된다(그러면 걸어 들어갈 수 없다).
+   */
+  /*
+   * 오더가 무엇을 만드나 — **자재 키가 아니라 GS1 품목 참조다**(`lines[].gtin`). 자재와 이어 주는
+   * 것은 `productionSpec.binding` 이고 그 해소는 호스트가 한다 — 자리·구역과 같은 `external` 이다.
+   * 축을 직접 가리키게 적으면 없는 필드를 가리키는 선언이 된다(계약을 보고 고쳤다).
+   */
+  { from: "orders", field: "lines[].gtin", target: { kind: "external", entity: "gs1.itemRef" }, via: "twin.rel.item", optional: true },
+  { from: "tasks", field: "orderId", target: { kind: "axis", axis: "orders" }, via: "twin.rel.order", optional: true },
+  /* 작업의 `kind` 는 그 공정의 키다(라우트의 단계 이름 그대로 — `mes-kernel` 의 공정 목록이 그 증거). */
+  { from: "tasks", field: "kind", target: { kind: "axis", axis: "operations" }, via: "twin.rel.operation", optional: true },
+  { from: "tasks", field: "fromNode", target: { kind: "axis", axis: "locations" }, via: "twin.rel.from", optional: true },
+  { from: "tasks", field: "toNode", target: { kind: "axis", axis: "locations" }, via: "twin.rel.at", optional: true },
+  { from: "tasks", field: "resourceRef", target: { kind: "axis", axis: "equipment" }, via: "twin.rel.by", optional: true },
+  { from: "tasks", field: "personnel[]", target: { kind: "axis", axis: "persons" }, via: "twin.rel.crew", optional: true },
+  /*
+   * 물품의 관계 (2026-08-22) — 없으면 축이 **걸어 들어갈 수 없는 목록**이 된다.
+   *
+   * `location` 은 필수다 — 물품은 언제나 어딘가에 있다(그것이 물품의 뜻이다). 나머지는 선택이다:
+   * 물류단위에 담기지 않은 물품, 자산에 실리지 않은 팔레트가 정상이다.
+   *
+   * `parent` 는 **물품 축을 자기 자신으로** 가리킨다(팔레트에 담긴 상자 — EPCIS `AggregationEvent`).
+   * `carriedBy` 는 다른 축이다 — 반복사용 자산(GRAI)이 물류단위를 실어 나른다(§`FlowItem.carriedBy`).
+   *
+   * 관계 이름은 **소문자 한 낱말**이다(`twin.rel.<name>`) — 기존 열여덟 개가 그 규율이고 시험이 지킨다.
+   *
+   * 품목(`gtin`)은 오더와 **같은 규율**이다: 자재 키가 아니라 GS1 품목 참조이므로 축을 직접 가리키지
+   * 않고 `external` 로 둔다. 축을 가리키게 적으면 없는 필드를 가리키는 선언이 된다.
+   */
+  { from: "items", field: "location", target: { kind: "axis", axis: "locations" }, via: "twin.rel.at" },
+  { from: "items", field: "parent", target: { kind: "axis", axis: "items" }, via: "twin.rel.parent", optional: true },
+  { from: "items", field: "carriedBy", target: { kind: "axis", axis: "assets" }, via: "twin.rel.asset", optional: true },
+  { from: "items", field: "gtin", target: { kind: "external", entity: "gs1.itemRef" }, via: "twin.rel.item", optional: true },
+  /*
+   * 자격을 검증한 시험 — **여덟 갈래.** 자원(개체)과 등급 양쪽이 가리킨다: 표준이 그 둘 모두에 이
+   * 참조를 두었기 때문이다(개체는 "이 사람이 통과했다", 등급은 "이 자격은 이 시험을 요구한다").
+   *
+   * **자리(`locations`)에는 없다** — 표준이 자리를 시험 대상으로 두지 않았고 그 비대칭은 표준의
+   * 판단이다(`contract.ts` 가 "우리도 자리에 넣지 않는다" 고 적었다).
+   */
+  { from: "persons", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "personnelClasses", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "equipment", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "equipmentClasses", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "assets", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "assetClasses", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "materialDefinitions", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  { from: "materialClasses", field: "testSpecificationIds[]", target: { kind: "axis", axis: "testSpecifications" }, via: "twin.rel.test", optional: true },
+  /* 공정이 도는 자리·자원 — 항목이 아니라 **타입**을 가리킨다 */
+  { from: "operations", field: "locationType", target: { kind: "type", role: "location" }, via: "twin.rel.at", optional: true },
+  { from: "operations", field: "resourceType", target: { kind: "type", role: "equipment" }, via: "twin.rel.by", optional: true }
+];
+var TWIN_PROPERTIES = [
+  /* 공정 — 선언(ISO 8601 기간)과 관측(저널에서 계산한 분포)이 둘 다 있는 유일한 짝. */
+  {
+    axis: "operations",
+    key: "duration",
+    label: "twin.prop.duration",
+    kind: "distribution",
+    declaredField: "duration",
+    observedBy: "kpi-fold.workTime",
+    uom: "ms"
+  },
+  /* 자리 — 용량은 선언, 점유는 관측. 단위가 다른 것이 아니라 **같은 축의 두 값**이다. */
+  {
+    axis: "locations",
+    key: "capacity",
+    label: "twin.prop.capacity",
+    kind: "level",
+    declaredField: "capacity",
+    observedBy: "state.location.occupancy"
+  },
+  /* 설비 — 고장 모델은 선언, 가동은 관측(OEE). 선언 없이도 관측은 선다. */
+  {
+    axis: "equipment",
+    key: "mtbf",
+    label: "twin.prop.mtbf",
+    kind: "distribution",
+    declaredField: "mtbfMs",
+    observedBy: "oee.availability",
+    uom: "ms"
+  },
+  {
+    axis: "equipment",
+    key: "mttr",
+    label: "twin.prop.mttr",
+    kind: "distribution",
+    declaredField: "mttrMs",
+    observedBy: "oee.availability",
+    uom: "ms"
+  },
+  {
+    axis: "equipment",
+    key: "availability",
+    label: "twin.prop.availability",
+    kind: "rate",
+    observedBy: "oee.availability",
+    uom: "ratio"
+  }
+];
+var propertiesOf = (axis) => TWIN_PROPERTIES.filter((p) => p.axis === axis);
+var axisSource = (axis) => TWIN_AXES.find((a) => a.axis === axis)?.source ?? "document";
+function documentPath(axis) {
+  const info = TWIN_AXES.find((a) => a.axis === axis);
+  if (!info) throw new Error(`unknown twin axis: "${axis}"`);
+  if (axisSource(axis) !== "document" || !info.path)
+    throw new Error(`axis "${axis}" is not read from the document (source: ${axisSource(axis)}) \u2014 read it from the ${axisSource(axis)}`);
+  return info.path;
+}
+var relationsFrom = (axis) => TWIN_RELATIONS.filter((r) => r.from === axis);
+var relationsTo = (axis) => TWIN_RELATIONS.filter((r) => r.target.kind === "axis" && r.target.axis === axis);
+function axisInfo(axis) {
+  return TWIN_AXES.find((a) => a.axis === axis);
+}
+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 ?? [];
+}
+
+// src/domain-definition.ts
+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;
+}
+var INTENTS = ["transport", "process", "dwell"];
+function dupes(keys) {
+  const seen = /* @__PURE__ */ new Set();
+  const dup = /* @__PURE__ */ new Set();
+  for (const k of keys) {
+    if (seen.has(k)) dup.add(k);
+    else seen.add(k);
+  }
+  return [...dup];
+}
+function validateDomainDefinition(def) {
+  const v = [];
+  if (!def || typeof def !== "object") return ["domain definition \uC5C6\uC74C/\uAC1D\uCCB4 \uC544\uB2D8"];
+  if (typeof def.id !== "string" || !def.id) v.push("id \uB204\uB77D");
+  if (typeof def.label !== "string" || !def.label) v.push("label \uB204\uB77D");
+  if (!Array.isArray(def.locationTypes) || def.locationTypes.length === 0) v.push("locationTypes \uBE44\uC5B4\uC788\uC74C");
+  if (!Array.isArray(def.resourceTypes)) v.push("resourceTypes \uBC30\uC5F4 \uC544\uB2D8");
+  const locationKeys2 = new Set((def.locationTypes || []).map((n) => n.key));
+  const resKeys = new Set((def.resourceTypes || []).map((r) => r.key));
+  const matKeys = new Set((def.materials || []).map((m) => m.key));
+  const matByKey = new Map((def.materials || []).map((m) => [m.key, m]));
+  const opKeys = new Set((def.operations || []).map((o) => o.key));
+  const routeKeys = new Set((def.routes || []).map((r) => r.key));
+  for (const [name, arr] of [["locationTypes", def.locationTypes], ["resourceTypes", def.resourceTypes], ["materials", def.materials], ["operations", def.operations], ["routes", def.routes], ["recipes", def.recipes]]) {
+    for (const d of dupes((arr || []).map((x) => x.key))) v.push(`${name} \uD0A4 \uC911\uBCF5: ${d}`);
+  }
+  for (const o of def.operations || []) {
+    if (!INTENTS.includes(o.intent)) v.push(`operation '${o.key}' intent \uBD80\uC815: ${o.intent}`);
+    if (o.locationType && !locationKeys2.has(o.locationType)) v.push(`operation '${o.key}' locationType '${o.locationType}' \uBBF8\uC815\uC758`);
+    if (o.resourceType && !resKeys.has(o.resourceType)) v.push(`operation '${o.key}' resourceType '${o.resourceType}' \uBBF8\uC815\uC758`);
+    if (o.intent === "dwell" && o.resourceType) v.push(`operation '${o.key}' dwell \uC778\uB370 resourceType \uC9C0\uC815\uB428(\uBB34\uC790\uC6D0\uC774\uC5B4\uC57C)`);
+  }
+  for (const r of def.routes || []) {
+    if (!Array.isArray(r.steps) || r.steps.length === 0) v.push(`route '${r.key}' steps \uBE44\uC5B4\uC788\uC74C`);
+    for (const s of r.steps || []) if (!opKeys.has(s)) v.push(`route '${r.key}' step '${s}' \uBBF8\uC815\uC758 operation`);
+  }
+  for (const rc of def.recipes || []) {
+    if (rc.route && !routeKeys.has(rc.route)) v.push(`recipe '${rc.key}' route '${rc.route}' \uBBF8\uC815\uC758`);
+    if (!rc.outputs?.length) v.push(`recipe '${rc.key}' outputs \uBE44\uC5B4\uC788\uC74C`);
+    for (const p of [...rc.inputs || [], ...rc.outputs || []]) {
+      if (!matKeys.has(p.material)) v.push(`recipe '${rc.key}' material '${p.material}' \uBBF8\uC815\uC758`);
+      if (typeof p.qty !== "number" || p.qty <= 0) v.push(`recipe '${rc.key}' material '${p.material}' qty \uBD80\uC815`);
+      const mat = matByKey.get(p.material);
+      if (mat?.locationType && !locationKeys2.has(mat.locationType)) v.push(`recipe '${rc.key}' material '${p.material}' locationType '${mat.locationType}' \uBBF8\uC815\uC758`);
+    }
+  }
+  return v;
+}
+
+// src/energy-ingest.ts
+function isEnergyRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  if (!(typeof r.meterId === "string" && r.meterId.trim().length > 0 && r.epc === void 0)) return false;
+  return r.from === void 0 && r.to === 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 };
+}
+var POSITIONS = /* @__PURE__ */ new Set(["open", "closed", "intermediate", "bad"]);
+function isEnergyEquipmentRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.equipmentId === "string" && r.equipmentId.trim().length > 0 && r.epc === void 0 && r.meterId === void 0 && /* 적산을 실었으면 발전이다 — 이 문의 값은 상태이고, 적산은 자기 문이 있다. */
+  r.kWh === void 0;
+}
+function ingestEnergyEquipmentRecords(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 r = record;
+    const equipmentId = String(r?.equipmentId ?? "").trim();
+    if (!equipmentId) errors.push("equipmentId \uC5C6\uC74C \u2014 \uC5B4\uB290 \uC124\uBE44\uC758 \uC0C1\uD0DC\uC778\uC9C0 \uBAA8\uB974\uB294 \uAC12\uC740 \uC2E4\uC744 \uC218 \uC5C6\uB2E4");
+    const at = String(r?.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 \uC5B8\uC81C\uC758 \uC0C1\uD0DC\uC778\uC9C0 \uC54C \uC218 \uC5C6\uB2E4");
+    const num = (v, name, min, max) => {
+      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;
+      }
+      if (min !== void 0 && n < min) {
+        errors.push(`${name} \uAC00 ${min} \uBCF4\uB2E4 \uC791\uB2E4: ${n}`);
+        return void 0;
+      }
+      if (max !== void 0 && n > max) {
+        errors.push(`${name} \uAC00 ${max} \uBCF4\uB2E4 \uD06C\uB2E4: ${n}`);
+        return void 0;
+      }
+      return n;
+    };
+    const generatedKW = num(r?.generatedKW, "generatedKW", 0);
+    const exportKW = num(r?.exportKW, "exportKW");
+    const soc = num(r?.soc, "soc", 0, 100);
+    const chargeKW = num(r?.chargeKW, "chargeKW", 0);
+    const dischargeKW = num(r?.dischargeKW, "dischargeKW", 0);
+    const minKW = num(r?.minKW, "minKW", 0);
+    let curtailable;
+    if (r?.curtailable !== void 0 && r?.curtailable !== null) {
+      if (typeof r.curtailable !== "boolean") errors.push(`curtailable \uAC00 \uCC38/\uAC70\uC9D3\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(r.curtailable)}`);
+      else curtailable = r.curtailable;
+    }
+    const dcVoltage = num(r?.dcVoltage, "dcVoltage", 0);
+    const dcCurrent = num(r?.dcCurrent, "dcCurrent", 0);
+    const phases = (raw, name) => {
+      if (raw === void 0 || raw === null) return void 0;
+      if (!Array.isArray(raw)) {
+        errors.push(`${name} \uAC00 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4 \u2014 \uC0C1\uBCC4 \uAC12\uC774\uB77C \uBC30\uC5F4\uB85C \uBC1B\uB294\uB2E4(\uB2E8\uC0C1\uC774\uBA74 \uC6D0\uC18C \uD558\uB098): ${JSON.stringify(raw)}`);
+        return void 0;
+      }
+      if (!raw.length) {
+        errors.push(`${name} \uAC00 \uBE48 \uBC30\uC5F4\uC774\uB2E4 \u2014 \uC7B0 \uC0C1\uC774 \uC5C6\uC73C\uBA74 \uADF8 \uCE78\uC744 \uBCF4\uB0B4\uC9C0 \uC54A\uB294\uB2E4`);
+        return void 0;
+      }
+      const out = [];
+      for (const [i, v] of raw.entries()) {
+        const n = Number(v);
+        if (!Number.isFinite(n)) {
+          errors.push(`${name}[${i}] \uB97C \uC218\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(v)}`);
+          return void 0;
+        }
+        if (n < 0) {
+          errors.push(`${name}[${i}] \uAC00 \uC74C\uC218\uB2E4(${n}) \u2014 \uD06C\uAE30\uB294 \uC74C\uC218\uAC00 \uB418\uC9C0 \uC54A\uB294\uB2E4(\uBC29\uD5A5\uC740 \uB2E4\uB978 \uCD95\uC774 \uB9D0\uD55C\uB2E4)`);
+          return void 0;
+        }
+        out.push(n);
+      }
+      return out;
+    };
+    const acVoltage = phases(r?.acVoltage, "acVoltage");
+    const acCurrent = phases(r?.acCurrent, "acCurrent");
+    if (acVoltage && acCurrent && acVoltage.length !== acCurrent.length) {
+      errors.push(`acVoltage(${acVoltage.length}\uC0C1)\uC640 acCurrent(${acCurrent.length}\uC0C1)\uC758 \uC0C1 \uC218\uAC00 \uB2E4\uB974\uB2E4`);
+    }
+    let position;
+    if (r?.position !== void 0 && r?.position !== null && r?.position !== "") {
+      const p = String(r.position);
+      if (!POSITIONS.has(p)) errors.push(`position \uC774 \uD45C\uC900 \uAC12\uC774 \uC544\uB2C8\uB2E4(open\xB7closed\xB7intermediate\xB7bad): ${JSON.stringify(r.position)}`);
+      else position = p;
+    }
+    const values = { generatedKW, exportKW, soc, chargeKW, dischargeKW, curtailable, minKW, position, dcVoltage, dcCurrent, acVoltage, acCurrent };
+    if (!errors.length && Object.values(values).every((v) => v === void 0)) {
+      errors.push("\uBC14\uAFC0 \uC0C1\uD0DC\uAC00 \uD558\uB098\uB3C4 \uC5C6\uB2E4 \u2014 \uAC12 \uC5C6\uB294 \uBCF4\uACE0\uB294 \uC0AC\uC2E4\uB85C \uC801\uC744 \uAC83\uC774 \uC5C6\uB2E4");
+    }
+    if (errors.length) {
+      rejected.push({ record, errors });
+      continue;
+    }
+    const eventTime = new Date(atMs).toISOString();
+    const data = {
+      equipmentId,
+      at: eventTime,
+      ...generatedKW !== void 0 ? { generatedKW } : {},
+      ...exportKW !== void 0 ? { exportKW } : {},
+      ...soc !== void 0 ? { soc } : {},
+      ...chargeKW !== void 0 ? { chargeKW } : {},
+      ...dischargeKW !== void 0 ? { dischargeKW } : {},
+      ...curtailable !== void 0 ? { curtailable } : {},
+      ...minKW !== void 0 ? { minKW } : {},
+      ...position !== void 0 ? { position } : {},
+      ...dcVoltage !== void 0 ? { dcVoltage } : {},
+      ...dcCurrent !== void 0 ? { dcCurrent } : {},
+      ...acVoltage !== void 0 ? { acVoltage } : {},
+      ...acCurrent !== void 0 ? { acCurrent } : {}
+    };
+    accepted.push({
+      eventId: `${opts.tenantId}-energy-eq-${++seq}`,
+      eventType: ENERGY_EVENT.equipment,
+      eventTime,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function isEnergyGenerationRecord(record) {
+  if (record?.from !== void 0 || record?.to !== void 0) return false;
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.equipmentId === "string" && r.equipmentId.trim().length > 0 && r.kWh !== void 0 && r.meterId === void 0 && r.epc === void 0;
+}
+function ingestEnergyGenerationRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const r of list) {
+    const errors = [];
+    const equipmentId = String(r?.equipmentId ?? "").trim();
+    if (!equipmentId) errors.push("equipmentId \uAC00 \uC5C6\uB2E4 \u2014 \uC5B4\uB290 \uC124\uBE44\uAC00 \uB9CC\uB4E0 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    const STATE_FIELDS = ["generatedKW", "exportKW", "soc", "chargeKW", "dischargeKW", "curtailable", "minKW", "position"];
+    const alsoState = STATE_FIELDS.filter((f) => r?.[f] !== void 0);
+    if (alsoState.length) {
+      errors.push(
+        `\uC801\uC0B0\uACFC \uC124\uBE44 \uC0C1\uD0DC\uB97C \uD55C \uB808\uCF54\uB4DC\uC5D0 \uC2E4\uC5C8\uB2E4(${alsoState.join("\xB7")}) \u2014 \uC774 \uBB38\uC740 \uC801\uC0B0\uB9CC \uC77D\uC73C\uBBC0\uB85C \uADF8 \uAC12\uC774 \uC0AC\uB77C\uC9C4\uB2E4. \uAC08\uB77C \uBCF4\uB0BC \uAC83`
+      );
+    }
+    const raw = r?.kWh;
+    const kWh = Number(raw);
+    if (raw === void 0 || raw === null || !Number.isFinite(kWh)) {
+      errors.push("kWh \uAC00 \uC5C6\uB2E4 \u2014 \uC774 \uBB38\uC774 \uBC1B\uB294 \uAC12\uC740 \uC801\uC0B0 \uD558\uB098\uB2E4(\uC21C\uC2DC \uCD9C\uB825\uC740 \uC124\uBE44 \uC0C1\uD0DC\uB85C \uBCF4\uB0B8\uB2E4)");
+    } else if (kWh < 0) {
+      errors.push(`kWh \uAC00 \uC74C\uC218\uB2E4(${kWh}) \u2014 \uC801\uC0B0\uC740 \uB4A4\uB85C \uAC00\uB354\uB77C\uB3C4 \uC74C\uC218\uAC00 \uB418\uC9C0 \uC54A\uB294\uB2E4`);
+    }
+    const eventTime = String(r?.at ?? "").trim() || opts.defaultEventTime || "";
+    if (!eventTime) errors.push("at \uC774 \uC5C6\uACE0 \uAE30\uBCF8 \uC2DC\uAC01\uB3C4 \uC8FC\uC9C0 \uC54A\uC558\uB2E4 \u2014 \uC5B8\uC81C \uC7B0 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    let since;
+    const rawSince = r?.kWhSince;
+    if (rawSince !== void 0 && rawSince !== null && String(rawSince).trim()) {
+      const text = String(rawSince).trim();
+      const at = Date.parse(text);
+      if (!Number.isFinite(at)) errors.push(`kWhSince \uB97C \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(rawSince)}`);
+      else if (Number.isFinite(Date.parse(eventTime)) && at > Date.parse(eventTime)) {
+        errors.push(`kWhSince(${text}) \uAC00 \uC7B0 \uC2DC\uAC01(${eventTime})\uBCF4\uB2E4 \uB4A4\uB2E4 \u2014 \uB458 \uC911 \uD558\uB098\uAC00 \uD2C0\uB838\uB2E4`);
+      } else since = text;
+    }
+    const ACCUMULATIONS = ["lifetime", "daily", "monthly", "billing", "unknown"];
+    let accumulation;
+    const rawAcc = r?.kWhAccumulation;
+    if (rawAcc !== void 0 && rawAcc !== null && String(rawAcc).trim()) {
+      const text = String(rawAcc).trim();
+      if (!ACCUMULATIONS.includes(text)) {
+        errors.push(`kWhAccumulation \uC774 \uC544\uB294 \uAC12\uC774 \uC544\uB2C8\uB2E4(${ACCUMULATIONS.join("\xB7")}): ${JSON.stringify(rawAcc)}`);
+      } else accumulation = text;
+    }
+    if (errors.length) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = {
+      equipmentId,
+      kWh,
+      at: eventTime,
+      ...since ? { since } : {},
+      ...accumulation ? { accumulation } : {}
+    };
+    accepted.push({
+      eventId: `${opts.tenantId}-generated-${++seq}`,
+      eventType: ENERGY_EVENT.generated,
+      eventTime,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function isEnergyUsagePeriodRecord(record) {
+  const r = record;
+  return !!r && typeof r === "object" && r.meterId !== void 0 && r.from !== void 0 && r.to !== void 0 && r.kWh !== void 0;
+}
+function isEnergyGenerationPeriodRecord(record) {
+  const r = record;
+  if (!r || typeof r !== "object") return false;
+  if (r.equipmentId === void 0 || r.from === void 0 || r.to === void 0) return false;
+  return r.kWh !== void 0;
+}
+function ingestEnergyGenerationPeriodRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  for (const r of list) {
+    const errors = [];
+    const equipmentId = String(r?.equipmentId ?? "").trim();
+    if (!equipmentId) errors.push("equipmentId \uAC00 \uC5C6\uB2E4 \u2014 \uC5B4\uB290 \uC124\uBE44\uAC00 \uB0B8 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    const span = readSpan(r, errors);
+    const kWh = readAmount(r?.kWh, "kWh", errors);
+    if (kWh === void 0 && !errors.length) errors.push("kWh \uAC00 \uC5C6\uB2E4 \u2014 \uC774 \uBB38\uC774 \uBC1B\uB294 \uAC12\uC740 \uADF8 \uAE30\uAC04\uC758 \uBC1C\uC804\uB7C9\uC774\uB2E4");
+    const ACCUMULATIONS = ["lifetime", "daily", "monthly", "billing", "unknown"];
+    let accumulation;
+    const rawAcc = r?.accumulation;
+    if (rawAcc !== void 0 && rawAcc !== null && String(rawAcc).trim()) {
+      const text = String(rawAcc).trim();
+      if (!ACCUMULATIONS.includes(text)) {
+        errors.push(`accumulation \uC774 \uC544\uB294 \uAC12\uC774 \uC544\uB2C8\uB2E4(${ACCUMULATIONS.join("\xB7")}): ${JSON.stringify(rawAcc)}`);
+      } else accumulation = text;
+    }
+    const readAt = (raw, name) => {
+      if (raw === void 0 || raw === null || !String(raw).trim()) return void 0;
+      const text = String(raw).trim();
+      if (!Number.isFinite(Date.parse(text))) {
+        errors.push(`${name} \uB97C \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(raw)}`);
+        return void 0;
+      }
+      return text;
+    };
+    const observedFrom = readAt(r?.observedFrom, "observedFrom");
+    const observedTo = readAt(r?.observedTo, "observedTo");
+    if (errors.length || !span || kWh === void 0) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = {
+      equipmentId,
+      kWh,
+      periodStart: span.from,
+      periodEnd: span.to,
+      /* 관측 구간을 말하지 않으면 기간 전체를 잰 것으로 둔다 — 지난 기록은 그 원본이 하루를 마감해 준 값이다. */
+      observedFrom: observedFrom ?? span.from,
+      observedTo: observedTo ?? span.to,
+      accumulation: accumulation ?? "daily",
+      /* 밖에서 마감되어 온 것이다 — 우리가 시각 기준으로 닫은 것이 아니다. */
+      boundary: "declared"
+    };
+    const subj = resolveSubject("equipment", equipmentId, opts);
+    data.subject = subj.subject;
+    data.subjectBasis = subj.basis;
+    const futureError = futureFactError(span.to, opts);
+    if (futureError) {
+      rejected.push({ record: r, errors: [futureError] });
+      continue;
+    }
+    accepted.push({
+      eventId: periodFactId(opts.tenantId, ENERGY_EVENT.generationPeriod, subj.subject, span.from, span.to),
+      eventType: ENERGY_EVENT.generationPeriod,
+      eventTime: span.to,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function isEnergyGenerationPriceRecord(record) {
+  const r = record;
+  if (!r || typeof r !== "object") return false;
+  if (r.from === void 0 || r.to === void 0) return false;
+  if (r.meterId !== void 0 || r.equipmentId !== void 0) return false;
+  return r.unitPrice !== void 0;
+}
+function ingestEnergyGenerationPriceRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  for (const r of list) {
+    const errors = [];
+    const span = readSpan(r, errors);
+    const unitPrice = readAmount(r?.unitPrice, "unitPrice", errors);
+    if (unitPrice === void 0 && !errors.length) errors.push("unitPrice \uAC00 \uC5C6\uB2E4 \u2014 \uC774 \uBB38\uC774 \uBC1B\uB294 \uAC12\uC740 1kWh \uB2F9 \uAC12 \uD558\uB098\uB2E4");
+    const currency = String(r?.currency ?? "").trim();
+    if (!currency) errors.push("currency \uAC00 \uC5C6\uB2E4 \u2014 \uB2E8\uC704 \uC5C6\uB294 \uAC12\uC740 \uB2E4\uB978 \uAE08\uC561\uACFC \uB354\uD560 \uC218 \uC5C6\uB2E4");
+    if (errors.length || !span || unitPrice === void 0) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = { from: span.from, to: span.to, unitPrice, currency };
+    accepted.push({
+      eventId: periodFactId(opts.tenantId, ENERGY_EVENT.generationPrice, "", span.from, span.to),
+      eventType: ENERGY_EVENT.generationPrice,
+      eventTime: span.from,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function isEnergyTariffBasisRecord(record) {
+  const r = record;
+  if (!r || typeof r !== "object") return false;
+  if (r.from === void 0 || r.to === void 0) return false;
+  if (r.energyCharge !== void 0 || r.demandCharge !== void 0 || r.total !== void 0) return false;
+  return r.billingDemandKW !== void 0 || r.demandChargePerKW !== void 0;
+}
+function ingestEnergyTariffBasisRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  for (const r of list) {
+    const errors = [];
+    const span = readSpan(r, errors);
+    const billingDemandKW = readAmount(r?.billingDemandKW, "billingDemandKW", errors);
+    const demandChargePerKW = readAmount(r?.demandChargePerKW, "demandChargePerKW", errors);
+    if (billingDemandKW === void 0 && demandChargePerKW === void 0) {
+      errors.push("\uC694\uAE08 \uAE30\uC900\uC774 \uD558\uB098\uB3C4 \uC5C6\uB2E4 \u2014 \uC801\uC744 \uC0AC\uC2E4\uC774 \uC5C6\uB294 \uAE30\uC900\uC740 \uBC1B\uC9C0 \uC54A\uB294\uB2E4");
+    }
+    const currency = String(r?.currency ?? "").trim() || void 0;
+    if (demandChargePerKW !== void 0 && !currency) errors.push("demandChargePerKW \uB97C \uC2E4\uC5C8\uB294\uB370 currency \uAC00 \uC5C6\uB2E4");
+    if (r?.demandCharge !== void 0 || r?.total !== void 0) {
+      errors.push("\uAE08\uC561(demandCharge\xB7total)\uC740 \uC774 \uBB38\uC774 \uBC1B\uC9C0 \uC54A\uB294\uB2E4 \u2014 \uC815\uC0B0 \uAE08\uC561\uC740 \uCCAD\uAD6C\uC11C \uBB38\uC73C\uB85C \uBCF4\uB0B8\uB2E4");
+    }
+    if (errors.length || !span) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = {
+      from: span.from,
+      to: span.to,
+      ...billingDemandKW !== void 0 ? { billingDemandKW } : {},
+      ...demandChargePerKW !== void 0 ? { demandChargePerKW } : {},
+      ...currency ? { currency } : {}
+    };
+    accepted.push({
+      eventId: periodFactId(opts.tenantId, ENERGY_EVENT.tariffBasis, "", span.from, span.to),
+      eventType: ENERGY_EVENT.tariffBasis,
+      /* **시작 시각**이다 — 그때부터 유효하다(§ 위 주석). */
+      eventTime: span.from,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function isEnergyBillRecord(record) {
+  const r = record;
+  if (!r || typeof r !== "object") return false;
+  if (r.from === void 0 || r.to === void 0) return false;
+  return r.energyCharge !== void 0 || r.demandCharge !== void 0 || r.total !== void 0;
+}
+function futureFactError(eventTime, opts) {
+  const nowText = opts.nowISO ?? opts.defaultEventTime;
+  if (!nowText) return void 0;
+  const nowMs = Date.parse(nowText);
+  const atMs = Date.parse(eventTime);
+  if (!Number.isFinite(nowMs) || !Number.isFinite(atMs) || atMs <= nowMs) return void 0;
+  return `\uC544\uC9C1 \uC624\uC9C0 \uC54A\uC740 \uC2DC\uAC01\uC758 \uC0AC\uC2E4\uC774\uB2E4(${eventTime}) \u2014 \uB05D\uB098\uC9C0 \uC54A\uC740 \uAE30\uAC04\uC740 \uB9C8\uAC10\uB41C \uC0AC\uC2E4\uC774 \uC544\uB2C8\uB2E4`;
+}
+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("|");
+}
+function readSpan(r, errors) {
+  const from = String(r?.from ?? "").trim();
+  const to = String(r?.to ?? "").trim();
+  const fromMs = Date.parse(from);
+  const toMs = Date.parse(to);
+  if (!from || !Number.isFinite(fromMs)) errors.push(`from \uC744 \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(r?.from)}`);
+  if (!to || !Number.isFinite(toMs)) errors.push(`to \uB97C \uC2DC\uAC01\uC73C\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(r?.to)}`);
+  if (Number.isFinite(fromMs) && Number.isFinite(toMs) && !(toMs > fromMs)) {
+    errors.push(`\uAD6C\uAC04\uC774 \uB4A4\uC9D1\uD614\uAC70\uB098 \uAE38\uC774\uAC00 \uC5C6\uB2E4(${from} \u2192 ${to}) \u2014 \uC5B4\uB290 \uCABD\uC774 \uD2C0\uB838\uB294\uC9C0 \uC6B0\uB9AC\uAC00 \uC815\uD560 \uC218 \uC5C6\uB2E4`);
+  }
+  return errors.length ? void 0 : { from, to };
+}
+function readAmount(raw, name, errors) {
+  if (raw === void 0 || raw === null || String(raw).trim() === "") return void 0;
+  const v = Number(raw);
+  if (!Number.isFinite(v)) {
+    errors.push(`${name} \uB97C \uC218\uB85C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${JSON.stringify(raw)}`);
+    return void 0;
+  }
+  if (v < 0) {
+    errors.push(`${name} \uAC00 \uC74C\uC218\uB2E4(${v})`);
+    return void 0;
+  }
+  return v;
+}
+function ingestEnergyUsagePeriodRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  for (const r of list) {
+    const errors = [];
+    const meterId = String(r?.meterId ?? "").trim();
+    if (!meterId) errors.push("meterId \uAC00 \uC5C6\uB2E4 \u2014 \uC5B4\uB290 \uC9C0\uC810\uC774 \uC4F4 \uAC83\uC778\uC9C0 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4");
+    const span = readSpan(r, errors);
+    const rawKWh = r?.kWh;
+    let kWh;
+    if (rawKWh === void 0 || rawKWh === null || String(rawKWh).trim() === "") {
+      errors.push("kWh \uAC00 \uC5C6\uB2E4 \u2014 \uC774 \uBB38\uC774 \uBC1B\uB294 \uAC12\uC740 \uADF8 \uAD6C\uAC04\uC5D0 \uC4F4 \uC591\uC774\uB2E4");
+    } else {
+      kWh = readAmount(rawKWh, "kWh", errors);
+    }
+    const maxKW = readAmount(r?.maxKW, "maxKW", errors);
+    const unitPrice = readAmount(r?.unitPrice, "unitPrice", errors);
+    const currency = String(r?.currency ?? "").trim() || void 0;
+    if (unitPrice !== void 0 && !currency) errors.push("unitPrice \uB97C \uC2E4\uC5C8\uB294\uB370 currency \uAC00 \uC5C6\uB2E4 \u2014 \uB2E8\uC704 \uC5C6\uB294 \uAE08\uC561\uC740 \uB354\uD560 \uC218 \uC5C6\uB2E4");
+    let basis;
+    const rawBasis = r?.basis;
+    if (rawBasis !== void 0 && rawBasis !== null && String(rawBasis).trim()) {
+      const text = String(rawBasis).trim();
+      if (!OBSERVATION_BASIS.includes(text)) {
+        errors.push(`basis \uAC00 \uC544\uB294 \uAC12\uC774 \uC544\uB2C8\uB2E4(${OBSERVATION_BASIS.join("\xB7")}): ${JSON.stringify(rawBasis)}`);
+      } else basis = text;
+    }
+    if (errors.length || !span || kWh === void 0) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const subj = resolveSubject("meter", meterId, opts);
+    const data = {
+      meterId,
+      subject: subj.subject,
+      subjectBasis: subj.basis,
+      from: span.from,
+      to: span.to,
+      kWh,
+      ...maxKW !== void 0 ? { maxKW } : {},
+      ...unitPrice !== void 0 ? { unitPrice } : {},
+      ...currency ? { currency } : {},
+      ...basis ? { basis } : {}
+    };
+    const futureError = futureFactError(span.to, opts);
+    if (futureError) {
+      rejected.push({ record: r, errors: [futureError] });
+      continue;
+    }
+    accepted.push({
+      eventId: periodFactId(opts.tenantId, ENERGY_EVENT.usagePeriod, subj.subject, span.from, span.to),
+      eventType: ENERGY_EVENT.usagePeriod,
+      /* 구간의 **끝**이 이 사실이 성립한 시각이다 — 시작으로 달면 저널이 그 구간을 미리 안 것이 된다. */
+      eventTime: span.to,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+function ingestEnergyBillRecords(records, opts) {
+  const list = records === void 0 || records === null ? [] : Array.isArray(records) ? records : [records];
+  const accepted = [];
+  const rejected = [];
+  for (const r of list) {
+    const errors = [];
+    const span = readSpan(r, errors);
+    const energyCharge = readAmount(r?.energyCharge, "energyCharge", errors);
+    const demandCharge = readAmount(r?.demandCharge, "demandCharge", errors);
+    const total = readAmount(r?.total, "total", errors);
+    const billingDemandKW = readAmount(r?.billingDemandKW, "billingDemandKW", errors);
+    if (energyCharge === void 0 && demandCharge === void 0 && total === void 0) {
+      errors.push("\uAE08\uC561\uC774 \uD558\uB098\uB3C4 \uC5C6\uB2E4 \u2014 \uC801\uC744 \uC0AC\uC2E4\uC774 \uC5C6\uB294 \uCCAD\uAD6C\uC11C\uB294 \uBC1B\uC9C0 \uC54A\uB294\uB2E4");
+    }
+    const currency = String(r?.currency ?? "").trim() || void 0;
+    if (!currency) errors.push("currency \uAC00 \uC5C6\uB2E4 \u2014 \uB2E8\uC704 \uC5C6\uB294 \uAE08\uC561\uC740 \uB2E4\uB978 \uAE08\uC561\uACFC \uB354\uD560 \uC218 \uC5C6\uB2E4");
+    if (errors.length || !span) {
+      rejected.push({ record: r, errors });
+      continue;
+    }
+    const data = {
+      from: span.from,
+      to: span.to,
+      ...energyCharge !== void 0 ? { energyCharge } : {},
+      ...demandCharge !== void 0 ? { demandCharge } : {},
+      ...total !== void 0 ? { total } : {},
+      ...currency ? { currency } : {},
+      ...billingDemandKW !== void 0 ? { billingDemandKW } : {}
+    };
+    const futureError = futureFactError(span.to, opts);
+    if (futureError) {
+      rejected.push({ record: r, errors: [futureError] });
+      continue;
+    }
+    accepted.push({
+      eventId: periodFactId(opts.tenantId, ENERGY_EVENT.bill, "", span.from, span.to),
+      eventType: ENERGY_EVENT.bill,
+      eventTime: span.to,
+      tenantId: opts.tenantId,
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+
+// src/epcis.ts
+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"
+};
+var EPCIS_EVENT = {
+  object: "epcis.ObjectEvent",
+  aggregation: "epcis.AggregationEvent",
+  transaction: "epcis.TransactionEvent",
+  transformation: "epcis.TransformationEvent"
+};
+function isEpcisEventType(eventType) {
+  return typeof eventType === "string" && eventType.startsWith("epcis.");
+}
+function ssccUri(companyPrefix, serial) {
+  return `urn:epc:id:sscc:${companyPrefix}.${String(serial).padStart(10, "0")}`;
+}
+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 };
+  if (/(?:\/class\/|:class:)[^/:\s]+$/.test(raw)) return { 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 gdtiUri(companyPrefix, docType, serial) {
+  return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
+}
+function objectUri(namespace, objId) {
+  return underNamespace(namespace, "obj", objId);
+}
+function bizTransactionUri(namespace, transId) {
+  return underNamespace(namespace, "bt", transId);
+}
+function underNamespace(namespace, marker, id) {
+  const ns = namespace?.trim();
+  if (!ns) return void 0;
+  const v = String(id);
+  if (!v || v.includes("/") || v.includes(":")) 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?.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 ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var TZ_RE = /^[+-]\d{2}:\d{2}$/;
+var ACTIONS = ["ADD", "OBSERVE", "DELETE"];
+var EPC_CLASS_PREFIXES = ["urn:epc:idpat:", "urn:epc:class:"];
+var DL_CANONICAL = "https://id.gs1.org/";
+var CBV_URL_CLASS = /^https?:\/\/[^/\s]+\/(?:[^/\s]+\/)*class\/[^/\s]+$/;
+var CBV_URN_CLASS = /^urn:[^:\s]+:(?:[^:\s]+:)*class:[^:\s]+$/;
+var GS1_KEY_DIGITS = { sgtin: 13, sscc: 17, grai: 12, gdti: 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 classIdentifierViolation(epcClass) {
+  if (!epcClass) return `quantity epcClass \uBD80\uC815: ${epcClass}`;
+  const digits = gs1KeyDigitViolation(epcClass);
+  if (digits) return `quantity epcClass \uBD80\uC815: ${digits}`;
+  if (EPC_CLASS_PREFIXES.some((p) => epcClass.startsWith(p))) return void 0;
+  if (epcClass.startsWith(DL_CANONICAL)) return void 0;
+  if (CBV_URL_CLASS.test(epcClass) || CBV_URN_CLASS.test(epcClass)) return void 0;
+  return `quantity epcClass \uBD80\uC815: ${epcClass} \u2014 \uD074\uB798\uC2A4 \uC2DD\uBCC4\uC790\uB294 \uC18C\uC720 \uAD8C\uD55C\uC744 \uB9D0\uD560 \uC218 \uC788\uB294 \uBAA8\uC591\uC774\uC5B4\uC57C \uD55C\uB2E4 (EPC \uD074\uB798\uC2A4 urn:epc:idpat:/urn:epc:class: \xB7 CBV \xA78.3.4 http(s)://<\uB3C4\uBA54\uC778>/**/class/<id> \xB7 CBV \xA78.3.3 urn:<\uC774\uB984\uACF5\uAC04>:**:class:<id>)`;
+}
+function validateEpcisEvent(e) {
+  const v = [];
+  for (const [field, list] of [
+    ["epcList", e.epcList],
+    ["childEPCs", e.childEPCs],
+    ["inputEPCList", e.inputEPCList],
+    ["outputEPCList", e.outputEPCList],
+    ["parentID", e.parentID ? [e.parentID] : void 0]
+  ]) {
+    for (const epc of list ?? []) {
+      const bad2 = gs1KeyDigitViolation(epc);
+      if (bad2) v.push(`${field}: ${bad2}`);
+    }
+  }
+  if (e["@context"] !== EPCIS_CONTEXT) v.push("@context \uB204\uB77D/\uBD88\uC77C\uCE58");
+  if (!["ObjectEvent", "AggregationEvent", "TransactionEvent", "TransformationEvent"].includes(e.type)) v.push(`\uC54C \uC218 \uC5C6\uB294 type: ${e.type}`);
+  if (typeof e.eventTime !== "string" || !ISO_RE.test(e.eventTime)) v.push("eventTime ISO8601 \uC544\uB2D8");
+  if (typeof e.eventTimeZoneOffset !== "string" || !TZ_RE.test(e.eventTimeZoneOffset)) v.push("eventTimeZoneOffset \uD615\uC2DD \uC624\uB958");
+  if (typeof e.bizStep !== "string" || !e.bizStep) v.push("bizStep \uB204\uB77D");
+  if (e.eventID !== void 0 && (typeof e.eventID !== "string" || !e.eventID)) v.push("eventID \uAC00 \uBE48 \uBB38\uC790\uC5F4");
+  if (e.recordTime !== void 0 && (typeof e.recordTime !== "string" || !ISO_RE.test(e.recordTime))) {
+    v.push("recordTime ISO8601 \uC544\uB2D8");
+  }
+  if (e.ilmd !== void 0) {
+    const allowed = e.type === "ObjectEvent" && e.action === "ADD" || e.type === "TransformationEvent";
+    if (!allowed) v.push("ilmd \uB294 ObjectEvent(action=ADD) \uB610\uB294 TransformationEvent \uC5D0\uB9CC \uC2E4\uC744 \uC218 \uC788\uB2E4");
+  }
+  for (const sd of e.sourceList ?? []) {
+    if (!sd?.type || !sd?.source) v.push("sourceList \uD56D\uBAA9\uC5D0 type \uB610\uB294 source \uB204\uB77D");
+  }
+  for (const sd of e.destinationList ?? []) {
+    if (!sd?.type || !sd?.destination) v.push("destinationList \uD56D\uBAA9\uC5D0 type \uB610\uB294 destination \uB204\uB77D");
+  }
+  if (e.persistentDisposition !== void 0) {
+    const set = e.persistentDisposition.set ?? [];
+    const unset = e.persistentDisposition.unset ?? [];
+    if (!set.length && !unset.length) v.push("persistentDisposition \uC774 set\xB7unset \uB458 \uB2E4 \uBE44\uC5B4\uC788\uC74C");
+    const both = set.filter((x) => unset.includes(x));
+    if (both.length) v.push(`persistentDisposition \uC774 \uAC19\uC740 \uAC12\uC744 set\xB7unset \uB3D9\uC2DC \uC9C0\uC815: ${both.join(", ")}`);
+  }
+  for (const se of e.sensorElementList ?? []) {
+    if (!Array.isArray(se?.sensorReport) || se.sensorReport.length === 0) {
+      v.push("sensorElement \uC5D0 sensorReport \uAC00 \uD558\uB098\uB3C4 \uC5C6\uC74C");
+    }
+  }
+  if (e.errorDeclaration !== void 0) {
+    const d = e.errorDeclaration;
+    if (typeof d?.declarationTime !== "string" || !ISO_RE.test(d.declarationTime)) {
+      v.push("errorDeclaration.declarationTime ISO8601 \uC544\uB2D8/\uB204\uB77D");
+    }
+    if (d?.correctiveEventIDs !== void 0) {
+      if (!Array.isArray(d.correctiveEventIDs)) v.push("errorDeclaration.correctiveEventIDs \uBC30\uC5F4 \uC544\uB2D8");
+      else if (d.correctiveEventIDs.some((x) => typeof x !== "string" || !x)) {
+        v.push("errorDeclaration.correctiveEventIDs \uC5D0 \uBE48 \uAC12");
+      }
+    }
+  }
+  if (e.type === "ObjectEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!Array.isArray(e.epcList)) v.push("ObjectEvent.epcList \uB204\uB77D");
+    else if (e.epcList.length === 0 && !e.quantityList?.length) v.push("ObjectEvent: epcList/quantityList \uB458 \uB2E4 \uBE44\uC5B4\uC788\uC74C");
+  } else if (e.type === "AggregationEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!e.parentID) v.push("AggregationEvent.parentID \uB204\uB77D");
+    if (!e.childEPCs?.length && !e.childQuantityList?.length) v.push("AggregationEvent: childEPCs/childQuantityList \uB458 \uB2E4 \uBE44\uC5B4\uC788\uC74C");
+  } else if (e.type === "TransactionEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!Array.isArray(e.bizTransactionList) || e.bizTransactionList.length === 0) v.push("TransactionEvent.bizTransactionList \uB204\uB77D");
+  } else if (e.type === "TransformationEvent") {
+    if (!e.inputEPCList?.length && !e.inputQuantityList?.length) v.push("TransformationEvent: input \uBE44\uC5B4\uC788\uC74C");
+    if (!e.outputEPCList?.length && !e.outputQuantityList?.length) v.push("TransformationEvent: output \uBE44\uC5B4\uC788\uC74C");
+  }
+  const qtyLists = [
+    "quantityList" in e ? e.quantityList : void 0,
+    "childQuantityList" in e ? e.childQuantityList : void 0,
+    "inputQuantityList" in e ? e.inputQuantityList : void 0,
+    "outputQuantityList" in e ? e.outputQuantityList : void 0
+  ];
+  for (const list of qtyLists) for (const q of list ?? []) {
+    const bad2 = classIdentifierViolation(q.epcClass);
+    if (bad2) v.push(bad2);
+    const hasQty = q.quantity !== void 0 && q.quantity !== null;
+    if (!hasQty) {
+      if (q.uom !== void 0) v.push("quantity \uC5C6\uC73C\uBA74 uom \uB3C4 \uC5C6\uC5B4\uC57C \uD55C\uB2E4(\uC218\uB7C9 \uBBF8\uC9C0\uC815)");
+      continue;
+    }
+    if (typeof q.quantity !== "number" || !Number.isFinite(q.quantity) || q.quantity <= 0) {
+      v.push("quantity \uB294 \uC591\uC218\uC5EC\uC57C \uD55C\uB2E4(\uBAA8\uB974\uBA74 \uC0DD\uB7B5)");
+      continue;
+    }
+    if (q.uom === void 0 && !Number.isInteger(q.quantity)) v.push("uom \uC5C6\uB294 quantity \uB294 \uC815\uC218(\uAC1C\uC218)\uC5EC\uC57C \uD55C\uB2E4");
+    if (q.uom !== void 0 && !/^[A-Z0-9]{2,3}$/.test(q.uom)) v.push(`uom \uD615\uC2DD \uBD80\uC815(UN/CEFACT \uAD8C\uACE0 20 \uC758 2~3\uC790 \uCF54\uB4DC): ${q.uom}`);
+  }
+  return v;
+}
+
+// src/face2-adapter.ts
+function isAggregationRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.parentID === "string" && r.parentID.trim().length > 0 && r.epc === void 0;
+}
+function isTransformationRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  if (r.epc !== void 0 || r.parentID !== void 0) return false;
+  const has = (k) => Array.isArray(r[k]) && r[k].length > 0;
+  return has("inputEPCList") || has("inputQuantityList") || has("outputEPCList") || has("outputQuantityList");
+}
+function get(obj, path) {
+  return path.split(".").reduce((o, k) => o == null ? o : o[k], obj);
+}
+function resolve(v, record, field, errors) {
+  if (v === void 0) return void 0;
+  if (!v.startsWith("$.")) return v;
+  const r = get(record, v.slice(2));
+  if (r === void 0 || r === null) return void 0;
+  if (typeof r === "object") {
+    errors.push(`${field} \uAC00 \uAC12\uC774 \uC544\uB2C8\uB77C ${Array.isArray(r) ? "\uBC30\uC5F4" : "\uAC1D\uCCB4"}\uB85C \uC654\uB2E4(${v}) \u2014 \uCEE4\uB125\uD130\uAC00 \uD45C\uC900 \uAD6C\uC870\uB97C \uADF8\uB300\uB85C \uC2E4\uC5C8\uB2E4: ${JSON.stringify(r).slice(0, 80)}`);
+    return void 0;
+  }
+  return String(r);
+}
+function resolveList(v, record, field, errors) {
+  if (v === void 0) return [];
+  const r = get(record, v.startsWith("$.") ? v.slice(2) : v);
+  if (r === void 0 || r === null) return [];
+  if (!Array.isArray(r) || r.some((x) => typeof x !== "string")) {
+    errors.push(`${field} \uAC00 \uBB38\uC790\uC5F4 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4(${v}): ${JSON.stringify(r).slice(0, 80)}`);
+    return [];
+  }
+  return r.slice();
+}
+function resolveQuantityList(v, record, field, errors) {
+  if (v === void 0) return [];
+  const r = get(record, v.startsWith("$.") ? v.slice(2) : v);
+  if (r === void 0 || r === null) return [];
+  if (!Array.isArray(r) || r.some((x) => !x || typeof x !== "object" || Array.isArray(x))) {
+    errors.push(`${field} \uAC00 \uAC1D\uCCB4 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4(${v}): ${JSON.stringify(r).slice(0, 80)}`);
+    return [];
+  }
+  return r.map((x) => ({ ...x }));
+}
+function resolveObject(v, record, field, errors) {
+  if (v === void 0) return void 0;
+  const r = get(record, v.startsWith("$.") ? v.slice(2) : v);
+  if (r === void 0 || r === null) return void 0;
+  if (typeof r !== "object" || Array.isArray(r)) {
+    errors.push(`${field} \uAC00 \uAC1D\uCCB4\uAC00 \uC544\uB2C8\uB2E4(${v}): ${JSON.stringify(r).slice(0, 80)}`);
+    return void 0;
+  }
+  const o = { ...r };
+  return Object.keys(o).length ? o : void 0;
+}
+function resolveErrorDeclaration(spec, record, errors) {
+  if (!spec) return void 0;
+  const declarationTime = resolve(spec.declarationTime, record, "errorDeclaration.declarationTime", errors);
+  const reason = resolve(spec.reason, record, "errorDeclaration.reason", errors);
+  const correctiveEventIDs = resolveList(spec.correctiveEventIDs, record, "errorDeclaration.correctiveEventIDs", errors);
+  if (!declarationTime) {
+    if (reason || correctiveEventIDs.length) {
+      errors.push("errorDeclaration \uC774 \uBC18\uCBE4 \uC654\uB2E4 \u2014 \uC774\uC720\xB7\uC815\uC815 \uB300\uC0C1\uC740 \uC788\uB294\uB370 declarationTime \uC774 \uC5C6\uB2E4(\uC815\uC815 \uC2DC\uAC01\uC740 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4)");
+    }
+    return void 0;
+  }
+  return {
+    declarationTime,
+    ...reason ? { reason } : {},
+    ...correctiveEventIDs.length ? { correctiveEventIDs } : {}
+  };
+}
+function mapRecordChecked(record, mapping, eventTime) {
+  const errors = [];
+  const bizStep = resolve(mapping.bizStep, record, "bizStep", errors) ?? "";
+  const disposition = resolve(mapping.disposition, record, "disposition", errors);
+  const readPoint = resolve(mapping.readPoint, record, "readPoint", errors);
+  const bizLocation = resolve(mapping.bizLocation, record, "bizLocation", errors);
+  const errorDeclaration = resolveErrorDeclaration(mapping.errorDeclaration, record, errors);
+  if (mapping.type === "TransformationEvent") {
+    const inputEPCList = resolveList(mapping.inputEPCList, record, "inputEPCList", errors);
+    const inputQuantityList = resolveQuantityList(mapping.inputQuantityList, record, "inputQuantityList", errors);
+    const outputEPCList = resolveList(mapping.outputEPCList, record, "outputEPCList", errors);
+    const outputQuantityList = resolveQuantityList(mapping.outputQuantityList, record, "outputQuantityList", errors);
+    const transformationID = resolve(mapping.transformationID, record, "transformationID", errors);
+    if (!inputEPCList.length && !inputQuantityList.length) {
+      errors.push("\uC785\uB825\uC774 \uBE44\uC5C8\uB2E4 \u2014 \uBCC0\uD658\uC740 \uBB34\uC5C7\uC774 \uB4E4\uC5B4\uAC14\uB294\uC9C0 \uB9D0\uD574\uC57C \uD55C\uB2E4(EPCIS 2.0 \xA77.4.5)");
+    }
+    if (!outputEPCList.length && !outputQuantityList.length) {
+      errors.push("\uCD9C\uB825\uC774 \uBE44\uC5C8\uB2E4 \u2014 \uBCC0\uD658\uC740 \uBB34\uC5C7\uC774 \uB098\uC654\uB294\uC9C0 \uB9D0\uD574\uC57C \uD55C\uB2E4(EPCIS 2.0 \xA77.4.5)");
+    }
+    return {
+      event: transformationEvent({
+        eventTime,
+        bizStep,
+        disposition,
+        /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「없다」고 말하는 것이 된다.
+           개체로 말한 쪽과 수량으로 말한 쪽 중 하나만 쓰는 것이 정상이다. */
+        ...inputEPCList.length ? { inputEPCList } : {},
+        ...inputQuantityList.length ? { inputQuantityList } : {},
+        ...outputEPCList.length ? { outputEPCList } : {},
+        ...outputQuantityList.length ? { outputQuantityList } : {},
+        ...transformationID ? { transformationID } : {},
+        ...errorDeclaration ? { errorDeclaration } : {},
+        readPoint,
+        bizLocation
+      }),
+      errors
+    };
+  }
+  if (mapping.type === "AggregationEvent") {
+    const action2 = resolve(mapping.action, record, "action", errors) ?? "";
+    const parentID = resolve(mapping.parentID, record, "parentID", errors) ?? "";
+    const childEPCs = resolveList(mapping.childEPCs, record, "childEPCs", errors);
+    const childQuantityList = resolveQuantityList(mapping.childQuantityList, record, "childQuantityList", errors);
+    return {
+      event: aggregationEvent({
+        eventTime,
+        action: action2,
+        bizStep,
+        disposition,
+        parentID,
+        /* 없는 쪽은 **필드를 만들지 않는다** — 빈 배열을 실으면 「자식이 없다」고 말하는 것이 된다. */
+        ...childEPCs.length ? { childEPCs } : {},
+        ...childQuantityList.length ? { childQuantityList } : {},
+        ...errorDeclaration ? { errorDeclaration } : {},
+        readPoint,
+        bizLocation
+      }),
+      errors
+    };
+  }
+  const action = resolve(mapping.action, record, "action", errors) ?? "";
+  const epc = resolve(mapping.epc, record, "epc", errors);
+  const quantityList = resolveQuantityList(mapping.quantityList, record, "quantityList", errors);
+  if (!epc && !quantityList.length) {
+    errors.push("epc \uC640 quantityList \uAC00 \uB458 \uB2E4 \uBE44\uC5C8\uB2E4 \u2014 \uAC1C\uCCB4 \uC2DD\uBCC4\uC790\uB098 \uD074\uB798\uC2A4+\uC218\uB7C9 \uC911 \uD558\uB098\uB294 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+  }
+  const ilmd = resolveObject(mapping.ilmd, record, "ilmd", errors);
+  return {
+    event: objectEvent({
+      eventTime,
+      action,
+      bizStep,
+      disposition,
+      epcList: epc ? [epc] : [],
+      ...quantityList.length ? { quantityList } : {},
+      ...ilmd ? { ilmd } : {},
+      ...errorDeclaration ? { errorDeclaration } : {},
+      readPoint,
+      bizLocation
+    }),
+    errors
+  };
+}
+function mapRecord(record, mapping, eventTime) {
+  return mapRecordChecked(record, mapping, eventTime).event;
+}
+function ingest(records, rules, opts) {
+  const ruleByType = new Map(rules.map((r) => [r.sourceType, r]));
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const record of records) {
+    const rule = ruleByType.get(String(record["sourceType"]));
+    if (!rule) {
+      rejected.push({ record, errors: [`\uB9E4\uCE6D \uB8F0 \uC5C6\uC74C: sourceType=${record["sourceType"]}`] });
+      continue;
+    }
+    const timeErrors = [];
+    const eventTime = (opts.eventTimePath ? resolve("$." + opts.eventTimePath, record, "eventTime", timeErrors) : void 0) ?? opts.defaultEventTime;
+    const { event: ev, errors: mapErrors } = mapRecordChecked(record, rule.mapping, eventTime);
+    const errors = [...timeErrors, ...mapErrors, ...validateEpcisEvent(ev)];
+    if (errors.length) {
+      rejected.push({ record, errors });
+      continue;
+    }
+    const note = typeof record["description"] === "string" ? String(record["description"]).trim() : "";
+    accepted.push({
+      eventId: `${opts.tenantId}-ingest-${++seq}`,
+      eventType: `epcis.${ev.type}`,
+      eventTime: ev.eventTime,
+      tenantId: opts.tenantId,
+      ...note ? { description: note } : {},
+      data: ev
+    });
+  }
+  return { accepted, rejected };
+}
+
+// src/iso-duration.ts
+var RE = /^(-)?P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+function parseIsoDuration(text) {
+  if (typeof text !== "string") return void 0;
+  const s = text.trim();
+  if (!s || s === "P" || s === "PT") return void 0;
+  if (/\d+Y/.test(s)) return void 0;
+  const tIdx = s.indexOf("T");
+  const datePart = tIdx === -1 ? s : s.slice(0, tIdx);
+  if (/\d+M/.test(datePart)) return void 0;
+  const m = RE.exec(s);
+  if (!m) return void 0;
+  const [, sign, w, d, h, min, sec] = m;
+  if (!w && !d && !h && !min && !sec) return void 0;
+  const ms = (Number(w ?? 0) * 7 + Number(d ?? 0)) * 864e5 + Number(h ?? 0) * 36e5 + Number(min ?? 0) * 6e4 + Number(sec ?? 0) * 1e3;
+  if (!Number.isFinite(ms)) return void 0;
+  return sign ? -ms : ms;
+}
+
+// src/master-data.ts
+var VOCABULARY_TYPE = {
+  /** 품목·로트 클래스의 속성 — 유통기한·로트번호가 여기 온다. */
+  epcClass: "urn:epcglobal:epcis:vtype:EPCClass",
+  /** 관측 지점의 속성. */
+  readPoint: "urn:epcglobal:epcis:vtype:ReadPoint",
+  /** 업무 자리의 속성. */
+  bizLocation: "urn:epcglobal:epcis:vtype:BizLocation"
+};
+function isMasterDataRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  const r = record;
+  return typeof r.vocabularyType === "string" && !!r.vocabularyType && typeof r.id === "string" && !!r.id && isPlainObject(r.attributes);
+}
+function isPlainObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function ingestMasterData(records) {
+  const arr = Array.isArray(records) ? records : records ? [records] : [];
+  const accepted = [];
+  const rejected = [];
+  for (const r of arr) {
+    const errors = [];
+    if (!isMasterDataRecord(r)) errors.push("vocabularyType \xB7 id \xB7 attributes \uAC00 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+    else if (!Object.keys(r.attributes).length) errors.push("attributes \uAC00 \uBE44\uC5C8\uB2E4 \u2014 \uC544\uBB34 \uB73B\uC774 \uC5C6\uB294 \uC9C4\uC220\uC774\uB2E4");
+    if (errors.length) rejected.push({ record: r, errors });
+    else accepted.push({ vocabularyType: r.vocabularyType, id: r.id, attributes: { ...r.attributes } });
+  }
+  return { accepted, rejected };
+}
+function expiryFromAttributes(attrs) {
+  return readEpochMs(attrs?.[ILMD_ATTR.expiry]);
+}
+function lotFromAttributes(attrs) {
+  const v = attrs?.[ILMD_ATTR.lot];
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function readEpochMs(raw) {
+  if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
+  if (typeof raw !== "string" || !raw.trim()) return void 0;
+  const at = Date.parse(raw);
+  return Number.isNaN(at) ? void 0 : at;
+}
+
+// src/operational-ingest.ts
+var TASK_STATUS = ["created", "assigned", "in-progress", "completed"];
+var EQUIPMENT_STATUS = ["idle", "busy", "down"];
+var PERSON_STATUS = ["idle", "busy"];
+var ASSET_STATUS = ["idle", "in-use"];
+var SPECS = {
+  task: {
+    eventType: OP_EVENT.task,
+    identity: "taskId",
+    /* 종류가 없으면 성과를 종류별로 모을 수 없고(선언된 시간·수율이 종류로 붙는다) 지어낼 수도 없다. */
+    required: ["taskId", "kind", "status"],
+    fields: {
+      taskId: "string",
+      kind: "string",
+      status: "string",
+      fromNode: "string",
+      toNode: "string",
+      itemRefs: "string[]",
+      resourceRef: "string",
+      resources: "string[]",
+      personnel: "string[]",
+      assets: "string[]",
+      orderId: "string",
+      intent: "string",
+      progress: "number",
+      remainingMs: "number",
+      durationMs: "number",
+      startedAtSimMs: "number",
+      outcome: "string",
+      priority: "number",
+      startTime: "string",
+      endTime: "string",
+      materialActual: "object[]",
+      recordTime: "string"
+    },
+    enums: {
+      status: TASK_STATUS,
+      intent: ["transport", "process", "dwell"],
+      /* 품질 판정은 **있었던 작업만** — 없음은 「양품」이 아니라 「판정하지 않았다」다. */
+      outcome: ["good", "scrap"]
+    }
+  },
+  equipment: {
+    eventType: OP_EVENT.equipment,
+    identity: "moverId",
+    // vocabulary-guard: allow 저널 와이어 필드(델타의 이름이 계약이다)
+    required: ["moverId", "kind", "status"],
+    // vocabulary-guard: allow 위와 같은 이유
+    fields: {
+      moverId: "string",
+      kind: "string",
+      status: "string",
+      location: "string",
+      homeLocation: "string",
+      // vocabulary-guard: allow
+      taskId: "string",
+      held: "boolean",
+      effectiveStart: "string",
+      effectiveEnd: "string",
+      recordTime: "string",
+      /* 이동 구간 — 실 시스템도 줄 수 있는 사실이다(AGV·RTLS 가 출발·도착·소요를 낸다). 안쪽 필드까지
+         재검사하지는 않는다: 그 모양은 `EquipmentMotion` 계약이고, 여기서 두 번 지키면 두 벌이 된다. */
+      motion: "object"
+    },
+    enums: { status: EQUIPMENT_STATUS }
+  },
+  person: {
+    eventType: OP_EVENT.person,
+    identity: "personId",
+    required: ["personId", "status"],
+    fields: {
+      personId: "string",
+      status: "string",
+      personnelClassIds: "string[]",
+      taskId: "string",
+      location: "string",
+      offShift: "boolean",
+      effectiveStart: "string",
+      effectiveEnd: "string",
+      recordTime: "string"
+    },
+    enums: { status: PERSON_STATUS }
+  },
+  asset: {
+    eventType: OP_EVENT.asset,
+    identity: "assetId",
+    required: ["assetId", "status"],
+    fields: {
+      assetId: "string",
+      status: "string",
+      assetClassIds: "string[]",
+      location: "string",
+      taskId: "string",
+      carrying: "string",
+      effectiveStart: "string",
+      effectiveEnd: "string",
+      recordTime: "string"
+    },
+    enums: { status: ASSET_STATUS }
+  },
+  order: {
+    eventType: OP_EVENT.order,
+    identity: "orderId",
+    /*
+     * 요청량·이행량을 **함께** 받는다. 없으면 리듀서가 진척을 0 으로 적는데(`requested ? … : 0`),
+     * 그것은 「모른다」가 아니라 「아무것도 안 됐다」로 읽힌다 — 결측을 0 으로 메우지 않는다.
+     */
+    required: ["orderId", "kind", "status", "requested", "fulfilled"],
+    fields: {
+      orderId: "string",
+      kind: "string",
+      status: "string",
+      requested: "number",
+      fulfilled: "number",
+      gtin: "string",
+      held: "boolean",
+      lines: "object[]",
+      priority: "number",
+      startTime: "string",
+      endTime: "string",
+      allocated: "string[]",
+      bizTransaction: "string",
+      operationsRequestId: "string",
+      dockDoor: "string",
+      windowStartMs: "number",
+      recordTime: "string"
+    }
+    /* 상태·종류는 도메인이 소유한다 — 닫지 않는다. */
+  },
+  quality: {
+    eventType: OP_EVENT.quality,
+    identity: "moverId",
+    // vocabulary-guard: allow 저널 와이어 필드
+    /* 누적 카운터가 없으면 OEE 가 양품률을 못 센다 — 판정 하나만으로는 비율이 나오지 않는다. */
+    required: ["moverId", "good", "goodCount", "scrapCount"],
+    // vocabulary-guard: allow
+    fields: { moverId: "string", good: "boolean", goodCount: "number", scrapCount: "number", recordTime: "string" }
+    // vocabulary-guard: allow
+  },
+  /*
+   * **시험 결과** — 대상을 가리켜 들어온다(표준 `TestResult.TestableObjectID`).
+   *
+   * `result` 를 **요구하지 않는다**: 재기만 하고 판정하지 않는 원천이 정상이고, 요구하면 그 원천의
+   * 사실을 아예 담을 수 없다(§`TestResult.result`). 비어 있으면 커널이 선언된 기준으로 판정하고
+   * `derived` 를 세운다 — 판정하지 못하면 비워 둔다.
+   *
+   * `propertyMeasurements` 안쪽은 재검사하지 않는다 — 그 모양은 `PropertyMeasurement` 계약이고,
+   * 여기서 두 번 지키면 두 벌이 된다(설비 `motion` 과 같은 규율).
+   */
+  test: {
+    eventType: OP_EVENT.test,
+    identity: "testableObjectId",
+    /* 무엇을 어느 기준으로 시험했나 — 둘 중 하나가 없으면 그 결과는 아무 데도 붙지 못한다. */
+    required: ["testableObjectId", "specId"],
+    fields: {
+      testableObjectId: "string",
+      specId: "string",
+      result: "string",
+      at: "string",
+      expiresAt: "string",
+      derived: "boolean",
+      propertyMeasurements: "object[]",
+      recordTime: "string"
+    },
+    enums: { result: ["pass", "fail"] }
+  },
+  /*
+   * **자리의 물리 관측** — 어느 자리의 어느 속성을 언제 얼마로 쟀나.
+   *
+   * 값에 **단위를 함께** 받는다(`ValueType`). 단위 없는 물리량은 판정의 재료가 못 된다 — 3 이 섭씨인지
+   * 화씨인지 모르면 어떤 기준으로도 판정할 수 없다. 다만 **요구하지는 않는다**: 단위를 비우는 실 원본이
+   * 흔하고, 요구하면 그 원본의 관측을 아예 담지 못한다(그때 판정은 커널이 거부한다 — `outsideLimit`).
+   *
+   * `effectiveTime` 도 요구하지 않는다. 없으면 봉투의 시각이 그 자리를 대신한다(§`resolve`) — 원본이
+   * 시각을 말하지 않는 수기 점검이 실재하고, 그때 지어낸 시각보다 폴링 시각이 정직하다.
+   */
+  /*
+   * **이 목록이 전부다** — 연결된 시스템이 현재 목록을 한 바퀴 다 보낸 뒤 알린다.
+   *
+   * 둘 다 요구한다: 어느 목록인지와 그 주기를 **시작한** 시각. 시각이 없으면 무엇을 지울지 가릴 수
+   * 없고, 그때 지우면 전부 지운다 — 받지 않는 것이 옳다.
+   */
+  complete: {
+    eventType: OP_EVENT.complete,
+    identity: "completeAxis",
+    required: ["completeAxis", "since"],
+    fields: { completeAxis: "string", since: "string", recordTime: "string" }
+  },
+  observation: {
+    eventType: OP_EVENT.observation,
+    identity: "locationId",
+    /* 자리와 속성 — 둘 중 하나가 없으면 그 관측은 아무 데도 붙지 못한다. */
+    required: ["locationId", "propertyId"],
+    fields: {
+      locationId: "string",
+      propertyId: "string",
+      value: "string",
+      dataType: "string",
+      uom: "string",
+      effectiveTime: "string",
+      effectiveEndTime: "string",
+      recordTime: "string",
+      source: "string",
+      derived: "boolean"
+    }
+  }
+};
+function operationalKindOf(record) {
+  if (!record || typeof record !== "object") return void 0;
+  const r = record;
+  if (r.epc !== void 0 || r.meterId !== void 0 || r.equipmentId !== void 0) return void 0;
+  const has = (k) => typeof r[k] === "string" && r[k].trim().length > 0;
+  if (has("moverId")) return r.good !== void 0 ? "quality" : "equipment";
+  if (has("personId")) return "person";
+  if (has("assetId")) return "asset";
+  if (has("taskId")) return "task";
+  if (has("orderId")) return "order";
+  if (has("testableObjectId")) return "test";
+  if (has("locationId") && has("propertyId")) return "observation";
+  if (has("completeAxis")) return "complete";
+  return void 0;
+}
+function isOperationalRecord(record) {
+  return operationalKindOf(record) !== void 0;
+}
+function ingestOperationalRecords(records, opts) {
+  const arr = Array.isArray(records) ? records : records ? [records] : [];
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const record of arr) {
+    const kind = operationalKindOf(record);
+    if (!kind) {
+      rejected.push({
+        record,
+        errors: ["\uC5B4\uB290 \uC6B4\uC601 \uC0AC\uC2E4\uC778\uC9C0 \uBAA8\uB978\uB2E4 \u2014 \uC815\uCCB4 \uD544\uB4DC\uAC00 \uD544\uC694\uD558\uB2E4(taskId \xB7 moverId(+good=\uD488\uC9C8) \xB7 personId \xB7 assetId \xB7 orderId)"]
+        // vocabulary-guard: allow 거부 이유가 계약 필드 이름을 말한다
+      });
+      continue;
+    }
+    const spec = SPECS[kind];
+    const r = record;
+    const errors = [];
+    const ENVELOPE_FIELDS = ["at", "description"];
+    const unknown = Object.keys(r).filter((k) => !ENVELOPE_FIELDS.includes(k) && spec.fields[k] === void 0);
+    if (unknown.length) errors.push(`${kind}: \uACC4\uC57D\uC5D0 \uC5C6\uB294 \uD544\uB4DC \u2014 ${unknown.join(", ")}`);
+    for (const name of spec.required) {
+      const v = r[name];
+      if (v === void 0 || v === null || v === "") errors.push(`${kind}: ${name} \uC5C6\uC74C \u2014 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB294 \uAC12\uC774\uB2E4`);
+    }
+    const data = {};
+    for (const [name, type] of Object.entries(spec.fields)) {
+      const v = r[name];
+      if (v === void 0 || v === null || v === "") continue;
+      switch (type) {
+        case "string": {
+          if (typeof v !== "string") {
+            errors.push(`${kind}.${name} \uC774 \uBB38\uC790\uC5F4\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          const allowed = spec.enums?.[name];
+          if (allowed && !allowed.includes(v)) {
+            errors.push(`${kind}.${name} \uC774 \uCEE4\uB110\uC774 \uB2E4\uB8E8\uB294 \uB0B1\uB9D0\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)} \u2014 \uBC1B\uB294 \uAC12\uC740 ${allowed.join(" \xB7 ")}`);
+            break;
+          }
+          data[name] = v;
+          break;
+        }
+        case "number": {
+          const n = Number(v);
+          if (typeof v === "boolean" || !Number.isFinite(n)) {
+            errors.push(`${kind}.${name} \uAC00 \uC218\uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          if (name === "progress" && (n < 0 || n > 1)) {
+            errors.push(`${kind}.progress \uB294 0~1 \uBE44\uC728\uC774\uB2E4: ${n}`);
+            break;
+          }
+          if ((name === "requested" || name === "fulfilled" || name === "goodCount" || name === "scrapCount") && n < 0) {
+            errors.push(`${kind}.${name} \uAC00 \uC74C\uC218\uB2E4: ${n}`);
+            break;
+          }
+          data[name] = n;
+          break;
+        }
+        case "boolean": {
+          if (typeof v !== "boolean") {
+            errors.push(`${kind}.${name} \uAC00 \uCC38/\uAC70\uC9D3\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          data[name] = v;
+          break;
+        }
+        case "string[]": {
+          if (!Array.isArray(v) || v.some((x) => typeof x !== "string")) {
+            errors.push(`${kind}.${name} \uAC00 \uBB38\uC790\uC5F4 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          data[name] = v.slice();
+          break;
+        }
+        case "object": {
+          if (Array.isArray(v) || typeof v !== "object") {
+            errors.push(`${kind}.${name} \uAC00 \uAC1D\uCCB4\uAC00 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          data[name] = { ...v };
+          break;
+        }
+        case "object[]": {
+          if (!Array.isArray(v) || v.some((x) => !x || typeof x !== "object")) {
+            errors.push(`${kind}.${name} \uAC00 \uAC1D\uCCB4 \uBC30\uC5F4\uC774 \uC544\uB2C8\uB2E4: ${JSON.stringify(v)}`);
+            break;
+          }
+          data[name] = v.map((x) => ({ ...x }));
+          break;
+        }
+      }
+    }
+    const at = String(r.at ?? "").trim() || opts.defaultEventTime;
+    const atMs = at ? Date.parse(at) : Number.NaN;
+    if (!Number.isFinite(atMs)) {
+      errors.push(`${kind}: at \uC5C6\uC74C/\uD615\uC2DD \uC624\uB958 \u2014 \uC2DC\uAC01 \uC5C6\uC774\uB294 \uB2A6\uAC8C \uC628 \uC61B \uC0AC\uC2E4\uC744 \uAC78\uB7EC\uB0BC \uC218 \uC5C6\uB2E4`);
+    }
+    if (errors.length) {
+      rejected.push({ record, errors });
+      continue;
+    }
+    const note = typeof r.description === "string" ? String(r.description).trim() : "";
+    accepted.push({
+      eventId: `${opts.tenantId}-op-${kind}-${++seq}`,
+      eventType: spec.eventType,
+      eventTime: new Date(atMs).toISOString(),
+      tenantId: opts.tenantId,
+      ...note ? { description: note } : {},
+      data
+    });
+  }
+  return { accepted, rejected };
+}
+
+// src/operations-capability.ts
+function workingHoursBetween(calendar, fromMs, toMs, utcOffsetMinutes) {
+  if (!(toMs > fromMs)) return 0;
+  if (!calendar?.length) return (toMs - fromMs) / 36e5;
+  let minutes = 0;
+  for (let ms = fromMs; ms < toMs; ms += 6e4) if (inWorkCalendarAt(calendar, ms, utcOffsetMinutes)) minutes++;
+  return minutes / 60;
+}
+function operationsCapabilityOf(input) {
+  const fromMs = Date.parse(input.window.fromTime);
+  const toMs = Date.parse(input.window.toTime);
+  if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
+    throw new Error(`\uB2A5\uB825\uC758 \uAD6C\uAC04\uC744 \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${input.window.fromTime} ~ ${input.window.toTime}`);
+  }
+  if (toMs <= fromMs) throw new Error(`\uB2A5\uB825\uC758 \uAD6C\uAC04\uC774 \uB4A4\uC9D1\uD614\uB2E4: ${input.window.fromTime} ~ ${input.window.toTime}`);
+  const workingHours = workingHoursBetween(input.calendar ?? input.capacity.calendar, fromMs, toMs, input.utcOffsetMinutes);
+  const full = analyzeCapacity(input.capacity);
+  const usable = input.usableCapacity ? analyzeCapacity(input.usableCapacity) : void 0;
+  const amountOf = (perHour) => Number.isFinite(perHour) ? perHour * workingHours : null;
+  const committedOf = (operation) => {
+    let sum = 0;
+    for (const d of input.demands ?? []) {
+      if (d.operation !== void 0 && d.operation !== operation) continue;
+      if (!d.dueTime) continue;
+      const due = Date.parse(d.dueTime);
+      if (!Number.isFinite(due) || due < fromMs || due >= toMs) continue;
+      sum += Math.max(0, d.remaining);
+    }
+    return sum;
+  };
+  const perOperation = full.operations.map((op) => {
+    const total = amountOf(op.perHour);
+    const committed = committedOf(op.operation);
+    let unattainable = null;
+    let unattainableBy;
+    if (usable) {
+      const left = usable.operations.find((o) => o.operation === op.operation);
+      const usableAmount = amountOf(left?.perHour ?? NaN);
+      unattainable = total != null && usableAmount != null ? Math.max(0, total - usableAmount) : null;
+      if (unattainable != null && unattainable > 0 && left?.constraint) unattainableBy = left.constraint;
+    }
+    const available = total == null || unattainable == null ? null : total - committed - unattainable;
+    return {
+      operation: op.operation,
+      total,
+      committed,
+      unattainable,
+      available,
+      ...op.constraint ? { constraint: op.constraint } : {},
+      ...unattainableBy ? { unattainableBy } : {}
+    };
+  });
+  return {
+    operationsType: input.operationsType ?? "Production",
+    window: { fromTime: input.window.fromTime, toTime: input.window.toTime, workingHours },
+    perOperation,
+    ...full.bottleneck ? { bottleneck: full.bottleneck } : {},
+    ...input.publishedDate ? { publishedDate: input.publishedDate } : {}
+  };
+}
+
+// src/scenario-validate.ts
+var DISTRIBUTIONS = /* @__PURE__ */ new Set(["poisson", "uniform", "constant", "profile"]);
+var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+var bad = (errorCode, errorParams) => ({ ok: false, errorCode, errorParams });
+function validateGenerator(g, at) {
+  if (!g || typeof g !== "object") return bad("scenario-generator-invalid", { at });
+  if (!g.kind || typeof g.kind !== "string") return bad("scenario-generator-kind-required", { at });
+  const rate = g.rate;
+  if (!rate || typeof rate !== "object") return bad("scenario-rate-required", { at, kind: g.kind });
+  if (!isNum(rate.meanPerHour) || rate.meanPerHour < 0) return bad("scenario-rate-mean-invalid", { at, kind: g.kind });
+  if (!DISTRIBUTIONS.has(rate.distribution)) return bad("scenario-rate-distribution-invalid", { at, kind: g.kind, distribution: String(rate.distribution ?? "") });
+  if (rate.distribution === "profile" && !Array.isArray(rate.profile)) return bad("scenario-rate-profile-required", { at, kind: g.kind });
+  const content = g.content;
+  if (!content || typeof content !== "object") return bad("scenario-content-required", { at, kind: g.kind });
+  if (!Array.isArray(content.skuMix) || content.skuMix.length === 0) return bad("scenario-sku-mix-required", { at, kind: g.kind });
+  for (const s of content.skuMix) {
+    if (!s?.gtin || typeof s.gtin !== "string") return bad("scenario-sku-gtin-required", { at, kind: g.kind });
+    if (!isNum(s.weight) || s.weight <= 0) return bad("scenario-sku-weight-invalid", { at, kind: g.kind, gtin: String(s.gtin) });
+  }
+  const q = content.qtyPerLine;
+  if (!q || !isNum(q.min) || !isNum(q.max)) return bad("scenario-qty-required", { at, kind: g.kind });
+  if (q.min < 0 || q.max < q.min) return bad("scenario-qty-range-invalid", { at, kind: g.kind, min: q.min, max: q.max });
+  const l = content.linesPerOrder;
+  if (l && (!isNum(l.min) || !isNum(l.max) || l.min < 1 || l.max < l.min)) return bad("scenario-lines-range-invalid", { at, kind: g.kind });
+  if (g.stimulus !== void 0 && g.stimulus !== "arrival" && g.stimulus !== "order") {
+    return bad("scenario-stimulus-invalid", { at, kind: g.kind, stimulus: String(g.stimulus) });
+  }
+  return { ok: true };
+}
+function validateScenario(def) {
+  if (!def || typeof def !== "object") return bad("scenario-invalid");
+  if (def.seed !== void 0 && !isNum(def.seed)) return bad("scenario-seed-invalid");
+  if (def.speed !== void 0 && (!isNum(def.speed) || def.speed <= 0)) return bad("scenario-speed-invalid");
+  if (def.horizon !== void 0 && (!isNum(def.horizon) || def.horizon < 0)) return bad("scenario-horizon-invalid");
+  const gens = def.generators;
+  if (gens === void 0) return { ok: true };
+  if (!Array.isArray(gens)) return bad("scenario-generators-invalid");
+  for (let i = 0; i < gens.length; i++) {
+    const r = validateGenerator(gens[i], i);
+    if (!r.ok) return r;
+  }
+  return { ok: true };
+}
+
+// src/vocabulary.ts
+var RETIRED_VOCABULARY = ["mover", "Mover", "MOVER", "node", "Node", "NODE", "BoardDef", "loadBoard"];
+var VOCABULARY_EXCEPTIONS = [
+  /* ── 저널 와이어 필드 — append-only 역사이므로 이름을 바꾸지 않는다 ───────
+   * 같은 사실이 시점에 따라 다른 키로 들어가면 낡은 이름보다 나쁘다. 개명은 이벤트 스키마
+   * 버저닝과 함께 다룬다. (개명 시점 실측: moverId 8,965행 · fromNode/toNode 9,679행) */
+  { token: "moverId", why: "journal wire field \u2014 renaming would mix two keys for one fact across history" },
+  { token: "fromNode", why: "journal wire field (task.status payload)" },
+  { token: "toNode", why: "journal wire field (task.status payload)" },
+  /* ── 트윈 모델의 옛 세대 키 — 저장된 데이터라 읽어는 줘야 한다 ────────────────
+   * 설비 배열의 이름은 세 세대를 거쳤다(movers → equipmentList → equipment). 저장된 보드에는
+   * 셋이 섞여 있고(실측 23개 중 13개가 `movers`), 하나라도 안 읽으면 그 트윈 모델은 **설비가 0인 공장**
+   * 으로 조용히 읽힌다 — 화면의 설비 수가 0이 되고 용량 판정에서 자원이 사라진다. 쓰는 곳은
+   * `readBoardEquipment` 한 곳뿐이고, 거기서 새 이름으로 정규화해 내보낸다. */
+  { token: "movers", why: "legacy board key (movers \u2192 equipmentList \u2192 equipment); read-only normalization in readBoardEquipment, 13 stored boards still use it" },
+  /* ── 씬 컴포넌트 타입 — 트윈 모델에 저장된 값이고, 뜻이 어긋나지도 않는다 ──────
+   * 보드 7개가 이 타입으로 컴포넌트를 담고 있어 개명하면 그 컴포넌트가 조용히 안 그려진다.
+   * 그리고 씬에서 이 이름은 자원이 아니라 **움직임 표현**을 가리킨다(표준과 충돌 아님). */
+  { token: "twin-mover", why: "scene component type persisted in boards; names a motion representation, not a resource" },
+  { token: "TwinMover", why: "class backing the persisted scene component type above" },
+  /* ── 플랫폼·언어 어휘 — 우리 도메인 낱말이 아니다 ─────────────────────── */
+  { token: "node_modules", why: "npm path" },
+  { token: "node:", why: "Node.js builtin module specifier" },
+  { token: "nodemon", why: "tool name" },
+  { token: "Node.js", why: "platform name" },
+  { token: "NodeJS", why: "TypeScript global namespace" },
+  { token: "nodeName", why: "DOM API" },
+  { token: "childNodes", why: "DOM API" },
+  { token: "appendChild", why: "DOM API (no match, kept for clarity)" }
+];
+var GUARD_PRAGMA = "vocabulary-guard: allow";
+function retiredVocabularyIn(line) {
+  if (line.includes(GUARD_PRAGMA)) return [];
+  let rest = line;
+  for (const { token } of VOCABULARY_EXCEPTIONS) rest = rest.split(token).join(" ");
+  const hits = [];
+  for (const word of RETIRED_VOCABULARY) {
+    const re = new RegExp(`[A-Za-z_]*${word}[A-Za-z_]*`, "g");
+    for (const m of rest.matchAll(re)) hits.push(m[0]);
+  }
+  return hits;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BIZSTEP,
+  BTT,
+  BTT_DELIVERY,
+  BTT_PRODORDER,
+  CAPABILITIES,
+  CAPABILITY_KEYS,
+  CBV_BIZSTEP,
+  CMD,
+  DISP,
+  DISPOSITION_DECISION,
+  DOMAIN_CATALOG,
+  DOMAIN_SYSTEMS,
+  EMS_EQUIPMENT_TYPES,
+  EMS_LOCATION_TYPES,
+  EMS_PROPERTY,
+  EMS_PROPERTY_SPEC,
+  EMS_TYPES,
+  ENERGY_EVENT,
+  EPCIS_CONTEXT,
+  EPCIS_EVENT,
+  EQUIPMENT_LEVEL,
+  GUARD_PRAGMA,
+  ILMD_ATTR,
+  LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY,
+  MES_BIZSTEP,
+  MES_LOCATION_TYPES,
+  MES_TYPES,
+  METER_DIRECTION,
+  OBSERVATION_BASIS,
+  OP_EVENT,
+  OP_PARAM,
+  ORDER_TERMINAL_STATUS,
+  PRIORITY_UNSET,
+  RETIRED_VOCABULARY,
+  TWIN_AXES,
+  TWIN_PROPERTIES,
+  TWIN_RELATIONS,
+  UTC_OFFSET,
+  VOCABULARY_EXCEPTIONS,
+  VOCABULARY_TYPE,
+  WMS_LOCATION_TYPES,
+  WMS_TYPES,
+  YARD_BIZSTEP,
+  YMS_LOCATION_TYPES,
+  YMS_TYPES,
+  activeShiftAt,
+  activeShiftOf,
+  aggregationEvent,
+  analyzeCapacity,
+  axesOfSystem,
+  axisAppliesTo,
+  axisInfo,
+  axisSource,
+  bizTransactionUri,
+  capabilitiesForType,
+  capabilityOf,
+  classClosure,
+  classIdentifierViolation,
+  commandsOf,
+  conversionFactorOf,
+  criterionSaysNothing,
+  documentPath,
+  dueStatusOf,
+  effectivityAt,
+  electricalUpstreamOf,
+  expiryFromAttributes,
+  gdtiUri,
+  generationFractionAt,
+  graiUri,
+  gs1KeyDigitViolation,
+  hierarchyOf,
+  identityGroundingOf,
+  inWorkCalendar,
+  inWorkCalendarAt,
+  ingest,
+  ingestEnergyBillRecords,
+  ingestEnergyEquipmentRecords,
+  ingestEnergyGenerationPeriodRecords,
+  ingestEnergyGenerationPriceRecords,
+  ingestEnergyGenerationRecords,
+  ingestEnergyRecords,
+  ingestEnergyTariffBasisRecords,
+  ingestEnergyUsagePeriodRecords,
+  ingestMasterData,
+  ingestOperationalRecords,
+  isAggregationRecord,
+  isElectricalLocationType,
+  isEnergyBillRecord,
+  isEnergyEquipmentRecord,
+  isEnergyGenerationPeriodRecord,
+  isEnergyGenerationPriceRecord,
+  isEnergyGenerationRecord,
+  isEnergyRecord,
+  isEnergyTariffBasisRecord,
+  isEnergyUsagePeriodRecord,
+  isEpcisEventType,
+  isEquipmentLevel,
+  isMasterDataRecord,
+  isOperationalRecord,
+  isOrderTerminal,
+  isTransformationRecord,
+  isoDurationHours,
+  itemKeyOf,
+  judgeAgainstSpec,
+  levelOfLocationType,
+  lgtinClass,
+  localDayIndexAt,
+  localDayStartMs,
+  locationStatusOf,
+  lotFromAttributes,
+  mapRecord,
+  mapRecordChecked,
+  meetsTests,
+  minuteOfDayAt,
+  objectEvent,
+  objectUri,
+  observationAt,
+  offCalendarAt,
+  offCalendarReasonAt,
+  operationalKindOf,
+  operationsCapabilityOf,
+  outsideLimit,
+  parseEpc,
+  parseIsoDuration,
+  periodFactId,
+  priorityRank,
+  procedureViolations,
+  propertiesOf,
+  quantityIn,
+  readBoardAssets,
+  readBoardEquipment,
+  readBoardLocations,
+  relationsFrom,
+  relationsTo,
+  requiredTestsFor,
+  resolveSubject,
+  retiredVocabularyIn,
+  sgtinClass,
+  sgtinUri,
+  ssccUri,
+  stateFieldsOf,
+  subLotIdOf,
+  testEvidenceGaps,
+  testPassedAt,
+  transactionEvent,
+  transformationEvent,
+  validateDomainDefinition,
+  validateEpcisEvent,
+  validateScenario,
+  weekdayAt,
+  workingHoursBetween,
+  workingTimeOfWeek
+});