@operato/twin-kernel 0.7.83 → 0.7.85

package/dist/contract.d.ts

@@ -2743,6 +2743,27 @@ export interface EnergyMeasuredData {
  * 않은 것이다. 태양광이면 대개 0 이지만 그것은 현장이 판단할 일이고, 재지 않은 것을 0 으로 적으면
  * 우리가 그 판단을 대신한 것이 된다.
  */
+/**
+ * 사실의 **주체를 무엇으로 불렀나** — 그 이름이 어디까지 통하는지가 여기서 갈린다.
+ *
+ * ── 왜 이 축이 필요한가 (2026-08-30) ──────────────────────────────────────
+ * 마감된 구간 사실은 정체성이 내용에 있다(종류·주체·시작·끝). 그런데 **주체를 설비 번호로 불렀다.**
+ * 설비 번호는 한 트윈 안에서만 통하는 이름표라, 한 도메인에 현장이 둘이면 서로 다른 설비의 같은 날이
+ * **한 사실**이 된다. 실측으로 그 일이 났다 — 두 발전소의 `002` 가 겹쳐, 여러 현장을 함께 계산하는
+ * 성과 화면에서 한쪽 발전량이 사라졌다.
+ *
+ * 고치는 방법은 두 가지였고 하나는 틀렸다. **트윈 id 를 이름에 붙이는 것은 그릇으로 정체성을 정하는
+ * 것**이라 원칙을 뒤집는다(같은 설비를 현장 트윈과 상위 집계 트윈에 두면 같은 날이 두 사실이 된다).
+ *
+ * 그래서 이름의 출처를 밝힌다.
+ *
+ *   declared    모델이 선언한 설비 정체성 — 그릇과 무관하게 고유하다
+ *   twin-local  선언이 없어 이름표를 그대로 썼다 — **이 트윈 안에서만 통한다**
+ *
+ * 커널은 없는 이름을 지어내지 않고, 겹치는 이름을 고유한 척하지도 않는다. 읽는 쪽은 `twin-local` 을
+ * 볼 때 트윈 밖에서 같다고 판정하면 안 된다.
+ */
+export type SubjectBasis = 'declared' | 'twin-local';
 export interface EnergyGenerationPeriodData {
     equipmentId: string;
     /** 이 기간에 만든 양(kWh). */
@@ -2756,6 +2777,9 @@ export interface EnergyGenerationPeriodData {
     accumulation: 'lifetime' | 'daily' | 'monthly' | 'billing';
     /** 기간의 경계가 어디서 왔나 — 원본의 기준점(`declared`)이거나 현장의 시각 기준(`offset`). */
     boundary: 'declared' | 'offset';
+    /** 이 사실이 무엇에 대한 것인가 — 정체성으로 부른 이름(§`SubjectBasis`). */
+    subject?: string;
+    subjectBasis?: SubjectBasis;
 }
 /**
  * 값이 어디서 왔나 — **관측의 근거**.
@@ -2786,6 +2810,9 @@ export interface EnergyUsagePeriodData {
     unitPrice?: number;
     currency?: string;
     basis?: ObservationBasis;
+    /** 이 사실이 무엇에 대한 것인가 — 계량 지점도 설비와 같은 문제를 갖는다(§`SubjectBasis`). */
+    subject?: string;
+    subjectBasis?: SubjectBasis;
 }
 /**
  * 청구서 — `ENERGY_EVENT.bill` 의 데이터.
@@ -3104,6 +3131,7 @@ export interface TwinModelDef {
         id: string;
         kind: string;
         homeLocation: string;
+        identity?: string;
         mtbfMs?: number;
         mttrMs?: number;
         window?: {

package/dist/ems-kernel.js

@@ -26,6 +26,8 @@
  *    **관측 시작 이후 최대**만 답하고 그 사실을 이름으로 말한다(`peakSince`). 지어내지 않는다.
  */
 import { FlowEngine } from "./flow-engine.js";
+/* 기간 사실의 이름은 유입 문과 한 규칙이다(§`periodFactId`). */
+import { periodFactId } from "./energy-ingest.js";
 import { firstFitPolicy } from "./allocation-policy.js";
 import { CMD, ENERGY_EVENT, minuteOfDayAt, localDayIndexAt, localDayStartMs } from "./contract.js";
 import { EMS_PROPERTY, METER_DIRECTION, electricalUpstreamOf, generationFractionAt } from "./ems-profile.js";
@@ -659,16 +661,25 @@ export class EmsKernel extends FlowEngine {
          */
         const total = obs.lastKWh;
         if (Number.isFinite(total) && total >= 0) {
-            this.emitOp(ENERGY_EVENT.generationPeriod, {
+            /*
+             * 이름을 **내용에서** 만든다 — 같은 하루를 커널이 닫은 것과 커넥터가 지난 기록으로 보낸 것이
+             * 한 사실이어야 한다(§`emitPeriodFact`).
+             */
+            const periodStart = new Date(startMs).toISOString();
+            const periodEnd = new Date(endMs).toISOString();
+            const subj = this.subjectOf('equipment', id);
+            this.emitPeriodFact(ENERGY_EVENT.generationPeriod, {
                 equipmentId: id,
                 kWh: total,
-                periodStart: new Date(startMs).toISOString(),
-                periodEnd: new Date(endMs).toISOString(),
+                periodStart,
+                periodEnd,
                 observedFrom: new Date(obs.fromMs).toISOString(),
                 observedTo: new Date(obs.lastMs).toISOString(),
                 accumulation: at.kind,
-                boundary
-            });
+                boundary,
+                subject: subj.subject,
+                subjectBasis: subj.basis
+            }, periodFactId(this.tenantId, ENERGY_EVENT.generationPeriod, subj.subject, periodStart, periodEnd));
             eq.generatedKWhLastPeriod = total;
             eq.generatedKWhLastPeriodEnd = new Date(endMs).toISOString();
             /* 상태만 읽는 화면이 덜 잰 값을 온전한 값으로 읽지 않게, 관측 구간을 함께 남긴다. */

package/dist/energy-ingest.d.ts

@@ -20,6 +20,21 @@ export interface EnergyIngestOptions {
     tenantId: string;
     /** 레코드에 시각이 없을 때 쓸 값 — **주지 않으면 그 레코드를 거부한다.** */
     defaultEventTime?: string;
+    /**
+     * 자원의 **선언된 정체성**을 답한다 — 없으면 `undefined`.
+     *
+     * 마감된 구간 사실의 이름에 들어갈 주체를 이것으로 정한다(§`SubjectBasis`). 커널이 이름을
+     * 지어내지 않는 것과 같은 자세다: 모델이 선언하지 않았으면 답하지 않고, 호출부가 무엇을 할지 정한다.
+     */
+    identityOf?: (kind: 'equipment' | 'meter', localId: string) => string | undefined;
+    /**
+     * 선언된 정체성이 없을 때 이름표가 **어디까지 통하는지** — 보통 이 트윈의 id.
+     *
+     * 이름에 넣는 것이 아니라 **범위를 밝히는 데** 쓴다. 이것이 있으면 사실은 `twin-local` 로 표시되고,
+     * 읽는 쪽은 그 이름을 트윈 밖에서 같다고 판정하지 않는다. 주지 않으면 범위를 모르는 것이므로
+     * 그때도 `twin-local` 이되 범위는 비어 있다.
+     */
+    scopeId?: string;
 }
 export interface EnergyIngestResult {
     accepted: CanonicalEnvelope[];
@@ -115,6 +130,34 @@ export interface EnergyUsagePeriodRecord {
     basis?: string;
 }
 export declare function isEnergyUsagePeriodRecord(record: unknown): boolean;
+/**
+ * 마감된 **발전 기간** — 「이 기간에 이 설비가 이만큼 냈다」.
+ *
+ * 라이브에서는 커널이 스스로 마감해 낸다(§`closeGenerationPeriod`). 이 문은 **지난 기록을 채울 때**
+ * 쓴다 — 원본이 날짜별 발전량을 주는 현장에서, 트윈이 없던 동안의 날들을 뒤늦게 넣는다.
+ *
+ * 상태를 바꾸지 않는다. 저널에만 적히고, 저널을 읽는 쪽(성과 계산)이 그 사실을 본다.
+ */
+export interface EnergyGenerationPeriodRecord {
+    equipmentId: string;
+    from: string;
+    to: string;
+    kWh: number;
+    /** 원본이 준 적산의 종류 — 총량을 어떻게 얻었는지가 이것으로 갈린다. */
+    accumulation?: string;
+    /** 그 기간에서 처음·마지막으로 관측한 시각. 기간 경계와 다르면 그만큼 재지 않았다. */
+    observedFrom?: string;
+    observedTo?: string;
+}
+export declare function isEnergyGenerationPeriodRecord(record: unknown): boolean;
+/**
+ * 마감된 발전 기간을 봉투로 — **사건 시각은 기간의 끝**이다(그때 성립한다).
+ *
+ * 적산의 문(`ingestEnergyGenerationRecords`)과 겹치지 않는다: 그쪽은 구간이 없는 시점의 값이고
+ * 이쪽은 구간이 있는 마감된 사실이다. 겹치면 지난 기록이 「지금 적산」으로 읽혀 트윈의 시계가
+ * 과거로 끌린다.
+ */
+export declare function ingestEnergyGenerationPeriodRecords(records: EnergyGenerationPeriodRecord | EnergyGenerationPeriodRecord[] | undefined | null, opts: EnergyIngestOptions): EnergyIngestResult;
 /** 발전 단가 — 이 기간에 낸 전기 1kWh 의 값. 날마다 바뀐다. */
 export interface EnergyGenerationPriceRecord {
     from: string;
@@ -157,5 +200,18 @@ export interface EnergyBillRecord {
     billingDemandKW?: number;
 }
 export declare function isEnergyBillRecord(record: unknown): boolean;
+/**
+ * 이 사실의 **주체를 무엇으로 부를까** — 선언이 있으면 그 이름, 없으면 이름표와 그 범위.
+ *
+ * 선언이 없을 때 트윈 범위를 이름에 넣는 이유는 **겹침을 숨기지 않기 위해서**다. 넣지 않으면 서로 다른
+ * 설비의 같은 날이 한 사실이 되고, 여러 현장을 함께 계산하는 곳에서 한쪽이 조용히 사라진다(실측).
+ * 넣되 `subjectBasis` 로 **이 이름이 트윈 안에서만 통한다**고 밝힌다 — 그릇으로 정한 이름을 고유한
+ * 척하지 않는다.
+ */
+export declare function resolveSubject(kind: 'equipment' | 'meter', localId: string, opts: EnergyIngestOptions): {
+    subject: string;
+    basis: 'declared' | 'twin-local';
+};
+export declare function periodFactId(tenantId: string, kind: string, subject: string, from: string, to: string): string;
 export declare function ingestEnergyUsagePeriodRecords(records: EnergyUsagePeriodRecord | EnergyUsagePeriodRecord[] | undefined | null, opts: EnergyIngestOptions): EnergyIngestResult;
 export declare function ingestEnergyBillRecords(records: EnergyBillRecord | EnergyBillRecord[] | undefined | null, opts: EnergyIngestOptions): EnergyIngestResult;

package/dist/energy-ingest.js

@@ -268,6 +268,9 @@ export function ingestEnergyEquipmentRecords(records, opts) {
 }
 /** 이 레코드가 발전 적산인가 — 어느 갈래로 보낼지를 한 곳에서 정한다. */
 export function isEnergyGenerationRecord(record) {
+    /* 구간이 있으면 마감된 발전 기간이지 시점의 적산이 아니다 — 겹치면 지난 기록이 「지금」으로 읽힌다. */
+    if (record?.from !== undefined || record?.to !== undefined)
+        return false;
     if (!record || typeof record !== 'object')
         return false;
     const r = record;
@@ -378,6 +381,87 @@ export function isEnergyUsagePeriodRecord(record) {
     const r = record;
     return !!r && typeof r === 'object' && r.meterId !== undefined && r.from !== undefined && r.to !== undefined && r.kWh !== undefined;
 }
+export function isEnergyGenerationPeriodRecord(record) {
+    const r = record;
+    if (!r || typeof r !== 'object')
+        return false;
+    if (r.equipmentId === undefined || r.from === undefined || r.to === undefined)
+        return false;
+    return r.kWh !== undefined;
+}
+/**
+ * 마감된 발전 기간을 봉투로 — **사건 시각은 기간의 끝**이다(그때 성립한다).
+ *
+ * 적산의 문(`ingestEnergyGenerationRecords`)과 겹치지 않는다: 그쪽은 구간이 없는 시점의 값이고
+ * 이쪽은 구간이 있는 마감된 사실이다. 겹치면 지난 기록이 「지금 적산」으로 읽혀 트윈의 시계가
+ * 과거로 끌린다.
+ */
+export function ingestEnergyGenerationPeriodRecords(records, opts) {
+    const list = records === undefined || 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 가 없다 — 어느 설비가 낸 것인지 지어낼 수 없다');
+        const span = readSpan(r, errors);
+        const kWh = readAmount(r?.kWh, 'kWh', errors);
+        if (kWh === undefined && !errors.length)
+            errors.push('kWh 가 없다 — 이 문이 받는 값은 그 기간의 발전량이다');
+        const ACCUMULATIONS = ['lifetime', 'daily', 'monthly', 'billing', 'unknown'];
+        let accumulation;
+        const rawAcc = r?.accumulation;
+        if (rawAcc !== undefined && rawAcc !== null && String(rawAcc).trim()) {
+            const text = String(rawAcc).trim();
+            if (!ACCUMULATIONS.includes(text)) {
+                errors.push(`accumulation 이 아는 값이 아니다(${ACCUMULATIONS.join('·')}): ${JSON.stringify(rawAcc)}`);
+            }
+            else
+                accumulation = text;
+        }
+        /* 관측 구간은 기간 안에 있어야 한다 — 밖이면 그 값이 이 기간의 것이 아니다. */
+        const readAt = (raw, name) => {
+            if (raw === undefined || raw === null || !String(raw).trim())
+                return undefined;
+            const text = String(raw).trim();
+            if (!Number.isFinite(Date.parse(text))) {
+                errors.push(`${name} 를 시각으로 읽을 수 없다: ${JSON.stringify(raw)}`);
+                return undefined;
+            }
+            return text;
+        };
+        const observedFrom = readAt(r?.observedFrom, 'observedFrom');
+        const observedTo = readAt(r?.observedTo, 'observedTo');
+        if (errors.length || !span || kWh === undefined) {
+            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;
+        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 };
+}
 export function isEnergyGenerationPriceRecord(record) {
     const r = record;
     if (!r || typeof r !== 'object')
@@ -515,7 +599,21 @@ export function isEnergyBillRecord(record) {
  * **이것만으로 중복이 막히지는 않는다.** 저널은 아직 이 id 를 유일성으로 쓰지 않는다(그 판단은
  * 호스트의 것이고 드라이버마다 다르다). 여기서 하는 일은 **막을 근거를 만드는 것**이다.
  */
-function periodFactId(tenantId, kind, subject, from, to) {
+/**
+ * 이 사실의 **주체를 무엇으로 부를까** — 선언이 있으면 그 이름, 없으면 이름표와 그 범위.
+ *
+ * 선언이 없을 때 트윈 범위를 이름에 넣는 이유는 **겹침을 숨기지 않기 위해서**다. 넣지 않으면 서로 다른
+ * 설비의 같은 날이 한 사실이 되고, 여러 현장을 함께 계산하는 곳에서 한쪽이 조용히 사라진다(실측).
+ * 넣되 `subjectBasis` 로 **이 이름이 트윈 안에서만 통한다**고 밝힌다 — 그릇으로 정한 이름을 고유한
+ * 척하지 않는다.
+ */
+export 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' };
+}
+export function periodFactId(tenantId, kind, subject, from, to) {
     /* 대상이 없는 사실(요금 기준·청구서·발전 단가)은 그 자리를 비운다 — 없는 것을 지어내지 않는다. */
     return [tenantId, kind, subject, from, to].join('|');
 }
@@ -588,8 +686,11 @@ export function ingestEnergyUsagePeriodRecords(records, opts) {
             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,
@@ -599,7 +700,7 @@ export function ingestEnergyUsagePeriodRecords(records, opts) {
             ...(basis ? { basis } : {})
         };
         accepted.push({
-            eventId: periodFactId(opts.tenantId, ENERGY_EVENT.usagePeriod, meterId, span.from, span.to),
+            eventId: periodFactId(opts.tenantId, ENERGY_EVENT.usagePeriod, subj.subject, span.from, span.to),
             eventType: ENERGY_EVENT.usagePeriod,
             /* 구간의 **끝**이 이 사실이 성립한 시각이다 — 시작으로 달면 저널이 그 구간을 미리 안 것이 된다. */
             eventTime: span.to,

package/dist/flow-engine.d.ts

@@ -1282,6 +1282,36 @@ export declare abstract class FlowEngine implements TwinKernel {
      */
     private _correlationId?;
     protected emit(event: EpcisEvent): void;
+    /**
+     * **마감된 구간 사실**을 낸다 — 이름을 내용에서 만든다(순번이 아니다).
+     *
+     * ── 왜 따로 있나 (2026-08-30) ────────────────────────────────────────────
+     * `emitOp` 은 이름을 순번으로 붙인다(`…-evt-3`). 관측이나 전이는 그래도 된다 — 두 번 일어나면 두
+     * 사실이다. 그런데 **마감된 구간은 같은 기간이면 한 사실이다.** 같은 하루를 커널이 자정에 닫고
+     * 커넥터가 지난 기록으로도 보내면, 순번 이름으로는 그 둘이 다른 사실이 되어 **발전량이 두 배로**
+     * 잡힌다. 유입 문은 이미 내용으로 이름을 짓고 있었는데(§`periodFactId`) 커널 자신만 아니었다 —
+     * 한 종류에 규칙이 두 벌이었다.
+     */
+    protected emitPeriodFact(eventType: string, data: unknown, eventId: string): void;
+    /**
+     * 이 트윈의 **범위 이름** — 선언된 정체성이 없을 때 이름표가 어디까지 통하는지(§`SubjectBasis`).
+     *
+     * 호스트가 세운다. 커널은 `new Kernel(domainId, …)` 으로 서므로 **자기가 어느 트윈인지 모른다** —
+     * 도메인에 현장이 둘이면 설비 번호가 겹치는데 커널만으로는 그것을 알 길이 없었다.
+     */
+    scopeId?: string;
+    /**
+     * 설비의 **선언된 정체성** — 모델이 적었으면 그 이름, 없으면 답하지 않는다.
+     *
+     * 물품과 같은 자세다(§`declaredObjectId`): 선언이 없으면 지어내지 않는다. 명시한 이름이 먼저이고,
+     * 없으면 선언된 이름공간 아래의 개체 식별자로 만든다(CBV §8.2.3·§8.2.4).
+     */
+    equipmentIdentity(equipmentId: string): string | undefined;
+    /** 유입 문과 **같은 규칙**으로 주체를 정한다 — 이름 짓는 자리가 둘이면 한쪽만 고쳐지는 날이 온다. */
+    protected subjectOf(kind: 'equipment' | 'meter', localId: string): {
+        subject: string;
+        basis: 'declared' | 'twin-local';
+    };
     protected emitOp(eventType: string, data: unknown): void;
     /**
      * 작업 전이 방출 — **커널이 아는 것을 미러도 알게** 한다.

package/dist/flow-engine.js

@@ -11,6 +11,8 @@
  */
 import { OP_EVENT, CMD, locationStatusOf, readBoardEquipment, readBoardLocations, readBoardAssets, classClosure, capabilityOf, requiredTestsFor, priorityRank, dueStatusOf, isOrderTerminal, effectivityAt, offCalendarAt, offCalendarReasonAt, minuteOfDayAt, activeShiftAt, subLotIdOf, itemKeyOf, identityGroundingOf, outsideLimit } from "./contract.js";
 import { ObservedReducer } from "./observed-reducer.js";
+/* 주체를 정하는 규칙은 유입 문과 한 벌이다 — 두 곳에 적으면 한쪽만 고쳐진다. */
+import { resolveSubject } from "./energy-ingest.js";
 import { transformationEvent, aggregationEvent, objectEvent, parseEpc, DISP, ILMD_ATTR, CBV_BIZSTEP, objectUri, bizTransactionUri, gdtiUri } from "./epcis.js";
 import { OP_PARAM } from "./domain-definition.js";
 import { parseIsoDuration } from "./iso-duration.js";
@@ -2787,6 +2789,46 @@ export class FlowEngine {
         for (const h of this.handlers)
             h(e);
     }
+    /**
+     * **마감된 구간 사실**을 낸다 — 이름을 내용에서 만든다(순번이 아니다).
+     *
+     * ── 왜 따로 있나 (2026-08-30) ────────────────────────────────────────────
+     * `emitOp` 은 이름을 순번으로 붙인다(`…-evt-3`). 관측이나 전이는 그래도 된다 — 두 번 일어나면 두
+     * 사실이다. 그런데 **마감된 구간은 같은 기간이면 한 사실이다.** 같은 하루를 커널이 자정에 닫고
+     * 커넥터가 지난 기록으로도 보내면, 순번 이름으로는 그 둘이 다른 사실이 되어 **발전량이 두 배로**
+     * 잡힌다. 유입 문은 이미 내용으로 이름을 짓고 있었는데(§`periodFactId`) 커널 자신만 아니었다 —
+     * 한 종류에 규칙이 두 벌이었다.
+     */
+    emitPeriodFact(eventType, data, eventId) {
+        this.revision++;
+        const e = { eventId, eventType, eventTime: this.now(), tenantId: this.tenantId, ...(this._correlationId ? { correlationId: this._correlationId } : {}), data };
+        for (const h of this.handlers)
+            h(e);
+    }
+    /**
+     * 이 트윈의 **범위 이름** — 선언된 정체성이 없을 때 이름표가 어디까지 통하는지(§`SubjectBasis`).
+     *
+     * 호스트가 세운다. 커널은 `new Kernel(domainId, …)` 으로 서므로 **자기가 어느 트윈인지 모른다** —
+     * 도메인에 현장이 둘이면 설비 번호가 겹치는데 커널만으로는 그것을 알 길이 없었다.
+     */
+    scopeId;
+    /**
+     * 설비의 **선언된 정체성** — 모델이 적었으면 그 이름, 없으면 답하지 않는다.
+     *
+     * 물품과 같은 자세다(§`declaredObjectId`): 선언이 없으면 지어내지 않는다. 명시한 이름이 먼저이고,
+     * 없으면 선언된 이름공간 아래의 개체 식별자로 만든다(CBV §8.2.3·§8.2.4).
+     */
+    equipmentIdentity(equipmentId) {
+        const decl = (this.boardDef?.equipment ?? []).find(e => e.id === equipmentId);
+        const explicit = String(decl?.identity ?? '').trim();
+        if (explicit)
+            return explicit;
+        return this.declaredObjectId(equipmentId);
+    }
+    /** 유입 문과 **같은 규칙**으로 주체를 정한다 — 이름 짓는 자리가 둘이면 한쪽만 고쳐지는 날이 온다. */
+    subjectOf(kind, localId) {
+        return resolveSubject(kind, localId, { tenantId: this.tenantId, scopeId: this.scopeId, identityOf: (k, id) => (k === 'equipment' ? this.equipmentIdentity(id) : undefined) });
+    }
     emitOp(eventType, data) {
         this.revision++;
         const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, ...(this._correlationId ? { correlationId: this._correlationId } : {}), data };

package/dist/index.d.ts

@@ -30,10 +30,10 @@ export { WmsKernel } from './kernel.ts';
 export { YmsKernel } from './yms-kernel.ts';
 export { MesKernel } from './mes-kernel.ts';
 export { EmsKernel, DEMAND_WINDOW_MS, demandWindowStart } from './ems-kernel.ts';
-export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord } from './energy-ingest.ts';
+export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from './energy-ingest.ts';
 export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from './operational-ingest.ts';
 export type { OperationalKind, OperationalRecord, OperationalIngestOptions } from './operational-ingest.ts';
 export { attributeEnergy, electricityCost, energyIntensity, energyOfWindows } from './energy-attribution.ts';
 export type { AttributionBasis, AttributionResult, ElectricityCost, EnergyConsumer, EnergyPool, EnergyShare, IntensityInput, IntensityResult, IntensityDenominator, TariffDeclaration, WeightKind, WindowedEnergy } from './energy-attribution.ts';
-export type { EnergyRecord, EnergyEquipmentRecord, EnergyGenerationRecord, EnergyUsagePeriodRecord, EnergyBillRecord, EnergyTariffBasisRecord, EnergyGenerationPriceRecord, EnergyIngestOptions, EnergyIngestResult } from './energy-ingest.ts';
+export type { EnergyRecord, EnergyEquipmentRecord, EnergyGenerationRecord, EnergyUsagePeriodRecord, EnergyBillRecord, EnergyTariffBasisRecord, EnergyGenerationPriceRecord, EnergyGenerationPeriodRecord, EnergyIngestOptions, EnergyIngestResult } from './energy-ingest.ts';
 export * from './vocabulary.ts';

package/dist/index.js

@@ -30,7 +30,7 @@ export { WmsKernel } from "./kernel.js";
 export { YmsKernel } from "./yms-kernel.js";
 export { MesKernel } from "./mes-kernel.js";
 export { EmsKernel, DEMAND_WINDOW_MS, demandWindowStart } from "./ems-kernel.js";
-export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord } from "./energy-ingest.js";
+export { ingestEnergyRecords, isEnergyRecord, ingestEnergyEquipmentRecords, isEnergyEquipmentRecord, ingestEnergyGenerationRecords, isEnergyGenerationRecord, ingestEnergyUsagePeriodRecords, isEnergyUsagePeriodRecord, ingestEnergyBillRecords, isEnergyBillRecord, ingestEnergyTariffBasisRecords, isEnergyTariffBasisRecord, ingestEnergyGenerationPriceRecords, isEnergyGenerationPriceRecord, ingestEnergyGenerationPeriodRecords, isEnergyGenerationPeriodRecord, resolveSubject, periodFactId } from "./energy-ingest.js";
 /* 운영 사실의 문 — 리듀서가 다루는 여섯이 들어오는 자리(미러가 시뮬보다 가난하지 않게). */
 export { ingestOperationalRecords, isOperationalRecord, operationalKindOf } from "./operational-ingest.js";
 export { attributeEnergy, electricityCost, energyIntensity, energyOfWindows } from "./energy-attribution.js";