@operato/twin-kernel 0.0.6 → 0.2.0

package/dist/epcis.d.ts

@@ -11,9 +11,33 @@ export declare const DISP: {
 };
 export type EpcisEventType = 'ObjectEvent' | 'AggregationEvent' | 'TransactionEvent' | 'TransformationEvent';
 export type EpcisAction = 'ADD' | 'OBSERVE' | 'DELETE';
+/**
+ * 수량 요소 — **클래스 식별자 + 얼마나**. 표준이 세 경우를 규정한다(EPCIS 2.0 §7.3.3.1).
+ *
+ * | 품목 성격 | quantity | uom | 뜻 |
+ * |---|---|---|---|
+ * | 고정 계량 | 양의 **정수** | 없음 | 그 클래스의 **개수** |
+ * | 가변 계량 | 양수(정수 아니어도) | 있음 | quantity=크기, uom=물리 단위 |
+ * | 아무 것 | **없음** | 없음 | 수량을 **모른다**(미지정) |
+ *
+ * 즉 **`uom` 이 없으면 개수, 있으면 물리량**이다. 개수 단위(each 등)를 `uom` 에 넣는 것은 표준이
+ * 의도한 방식이 아니다 — 개수는 uom 없이 정수로 쓴다.
+ *
+ * 수량을 모를 때 0 으로 꾸미지 않도록 표준이 **"둘 다 생략"** 자리를 따로 두었다.
+ */
 export interface QuantityElement {
+    /** 클래스 식별자 — `urn:epc:idpat:…`(조건) 또는 `urn:epc:class:lgtin:…`(로트 클래스). */
     epcClass: string;
-    quantity: number;
+    /**
+     * 얼마나. **모르면 생략한다**(0 이 아니다).
+     * uom 없으면 양의 정수(개수), uom 있으면 양수(물리량, 소수 허용).
+     */
+    quantity?: number;
+    /**
+     * 측정 단위 — UN/CEFACT 권고 20 "Common Code" 의 2~3자 코드.
+     * 표준은 그중 **길이·면적·부피·질량**만 허용하고 폐기(X)·비권장(D) 코드를 제외한다.
+     * 예: MTR(미터) 허용 / F17(피트당 파운드힘) 불허. `quantity` 가 없으면 이 값도 없어야 한다.
+     */
     uom?: string;
 }
 export interface BizTransactionElement {
@@ -23,17 +47,110 @@ export interface BizTransactionElement {
 export interface LocationRef {
     id: string;
 }
+/**
+ * 정정 선언 — 이미 캡처된 이벤트를 취소·수정한다(EPCIS 2.0 `errorDeclaration`).
+ *
+ * 실 시스템은 잘못 보낸 이벤트를 정정한다. 받을 자리가 없으면 정정이 **또 하나의 사실**로 쌓여
+ * 재고·이력이 조용히 틀어진다(목 연동에서는 드러나지 않고 실 시스템에서 바로 터진다).
+ */
+export interface ErrorDeclaration {
+    /** 정정을 선언한 시각(ISO). 표준 필수. */
+    declarationTime: string;
+    /** 정정 이유 — CBV 어휘 URN(did_not_occur / incorrect_data). 도메인이 넓게 쓸 수 있어 열린 문자열. */
+    reason?: string;
+    /** 이 정정이 가리키는 원본 이벤트들의 `eventID`. */
+    correctiveEventIDs?: string[];
+}
+/**
+ * 이전 당사자 — 소유·보관이 누구에게서 누구로 옮겨지는가(EPCIS 2.0 §7.3.5).
+ * `type` 은 이전의 종류를 가리키는 표준 어휘(예: "owning party"), `source`/`destination` 은 그 당사자다.
+ * 3PL·위탁재고·수탁처럼 **물건은 그대로인데 권리가 옮겨지는** 일을 이것으로 표현한다.
+ */
+export interface SourceElement {
+    type: string;
+    source: string;
+}
+export interface DestinationElement {
+    type: string;
+    destination: string;
+}
+/**
+ * 지속 상태 — 이벤트 **이후에도 유효한** 업무 조건(EPCIS 2.0 §7.3.4).
+ *
+ * `disposition` 은 그 순간의 상태이고, 이쪽은 **명시적으로 해제될 때까지 유지**된다. 그래서 회수 대상처럼
+ * 매 이벤트에 다시 말하지 않아도 되는 성질을 담는다. set 과 unset 은 서로 독립이다.
+ */
+export interface PersistentDisposition {
+    /** 이 이벤트 이후 **설정**되는 조건 URI 들(해제될 때까지 유지). */
+    set?: string[];
+    /** 이 이벤트 이후 **해제**되는 조건 URI 들. */
+    unset?: string[];
+}
+/**
+ * 센서 관측 묶음 — 콜드체인·충격·습도 같은 물리 측정(EPCIS 2.0 §7.4).
+ *
+ * 하나의 `sensorMetadata`(모든 보고에 공통으로 적용되는 메타)와 **하나 이상의** `sensorReport`
+ * (개별 관측)로 이루어진다. 안의 속성은 인라인이고 어휘가 넓어, 커널은 **구조만 통과**시키고
+ * 값의 해석은 도메인에 맡긴다(없는 어휘를 발명하지 않는다).
+ */
+export interface SensorElement {
+    sensorMetadata?: Record<string, unknown>;
+    sensorReport: Record<string, unknown>[];
+}
 /** EPCIS 2.0 공통 헤더(모든 이벤트). action 은 여기 없음 — TransformationEvent 는 action 이 없다. */
 interface EpcisHeader {
     '@context': string;
     type: EpcisEventType;
+    /**
+     * 이벤트 자신의 정체성(EPCIS 2.0 `eventID`, 대문자 D).
+     *
+     * **봉투(`CanonicalEnvelope.eventId`)와 다른 것이다** — 봉투 id 는 우리 전송 단위의 id 이고, 이쪽은
+     * EPCIS 이벤트 자체의 id 다. 정정 이벤트가 원본을 `correctiveEventIDs` 로 가리켜야 하므로 이벤트
+     * 자신의 id 가 필요하다. 이름이 비슷해 혼동하기 쉬우니 봉투 id 를 그대로 재사용하지 말 것.
+     */
+    eventID?: string;
+    /** 발생 시각(ISO). */
     eventTime: string;
     eventTimeZoneOffset: string;
+    /**
+     * **기록** 시각(ISO) — 발생 시각과 별개다.
+     *
+     * 이 둘이 갈라지는 것이 실 연동의 정상이다(현장에서 일어난 뒤 늦게 도착). 소비처가 순서를 판정할 때
+     * `eventTime` 만 보면 늦게 도착한 옛 이벤트가 최신 상태를 덮는다 — 그 판정의 재료가 이 값이다.
+     */
+    recordTime?: string;
     bizStep: string;
     disposition?: string;
     readPoint?: LocationRef;
     bizLocation?: LocationRef;
     bizTransactionList?: BizTransactionElement[];
+    /** 정정 선언(있으면 이 이벤트는 앞선 이벤트를 정정하는 것이다). */
+    errorDeclaration?: ErrorDeclaration;
+    /**
+     * 개체·로트 마스터데이터 — **값이 같은 범위가 작은** 서술 속성(EPCIS 2.0 §7.3.8).
+     *
+     * 품목 마스터데이터(무게·치수)는 같은 GTIN 전부에 같은 값이지만, 이쪽은 **한 로트** 또는
+     * **한 개체**마다 다를 수 있다(대표 예: 유통기한). 그래서 물건이 처음 생겨나는 이벤트에 한 번 붙인다.
+     *
+     * 안에 들어가는 속성 이름은 **표준이 정의하지 않는다** — "이름 붙은 속성들의 집합(값은 임의 타입)"
+     * 이고 구체적 요소는 EPCIS 위에 얹히는 상위 문서가 정한다(§7.3.8). 그래서 커널은 자리만 열고 어휘를
+     * 발명하지 않으며, 받은 것을 **잃지 않고 통과**시킨다.
+     *
+     * **배치 규칙(§7.3.8)**: 개체가 존재하기 시작할 때 정의되므로 `ObjectEvent`(action=ADD)와
+     * `TransformationEvent` 에만 실을 수 있다. 변환에서는 **출력**에 적용된다(입력 아님).
+     * 그리고 객체의 생애 동안 **정적**인 것만 담는다 — 변하는 것은 이벤트의 몫이다.
+     */
+    ilmd?: Record<string, unknown>;
+    /** 이전 출발 당사자들(소유·보관 이전). */
+    sourceList?: SourceElement[];
+    /** 이전 도착 당사자들. */
+    destinationList?: DestinationElement[];
+    /** 이벤트 이후에도 유지되는 업무 조건(해제될 때까지). */
+    persistentDisposition?: PersistentDisposition;
+    /** 센서 관측 묶음(콜드체인 등). */
+    sensorElementList?: SensorElement[];
+    /** 인증 상세를 가리키는 URL(규제 산업). */
+    certificationInfo?: string;
 }
 /** action 을 갖는 이벤트(Object/Aggregation/Transaction). */
 interface EpcisActionEvent extends EpcisHeader {
@@ -69,10 +186,72 @@ export interface EpcisTransformationEvent extends EpcisHeader {
 export type EpcisEvent = EpcisObjectEvent | EpcisAggregationEvent | EpcisTransactionEvent | EpcisTransformationEvent;
 /** SSCC (물류단위: 팔레트/화물/트레일러) — 결정적 카운터 기반. */
 export declare function ssccUri(companyPrefix: string, serial: number): string;
-/** 비직렬 수량용 SGTIN 패턴(epcClass) — quantityList 에 사용. */
+/** 비직렬 수량용 SGTIN 패턴(epcClass) — 로트를 따지지 않는 품목 클래스. quantityList 에 사용. */
 export declare function sgtinClass(companyPrefix: string, itemRef: string): string;
+/**
+ * 우리가 방출하는 개체·로트 마스터데이터의 속성 이름 — **한 곳에 모은다.**
+ *
+ * 표준은 이 이름들을 정의하지 않는다(§7.3.8: 상위 문서 소관). 그래서 값을 실으려면 이름을 정해야 하는데,
+ * 흩뿌리면 곧 방언이 된다. GS1 CBV 마스터데이터 이름공간(`urn:epcglobal:cbv:mda:`)의 정식 명칭을
+ * 확인하면 **이 상수만 바꾸면 되도록** 여기 모아 둔다.
+ *
+ * ⚠ 아래 이름은 **아직 정본 확인 전**이다(CBV 마스터데이터 문서 필요). 받는 경로는 이름과 무관하게
+ * 동작하므로(받은 것을 잃지 않고 통과) 이 상수는 우리가 **생산할 때**만 쓰인다.
+ */
+export declare const ILMD_ATTR: {
+    /** 유통기한·만료(로트 단위). */
+    readonly expiry: "cbvmda:itemExpirationDate";
+    /** 로트·배치 번호(직렬 개체에 로트를 붙일 때). */
+    readonly lot: "cbvmda:lotNumber";
+};
+/**
+ * 품번 + 로트 클래스(LGTIN) — 낱개 일련번호가 없고 **로트로 관리**하는 자재의 표준 식별자.
+ *
+ * 원자재·화학·식품이 이 경우다. 로트가 식별자의 한 마디로 들어가므로 "로트별 재고" 가 별도 필드 없이
+ * epcClass 별 집계가 된다. 개체가 아니라 클래스이므로 `epcList` 가 아니라 `quantityList` 에 쓴다.
+ *
+ * 문법(EPC Tag Data Standard 2.1.0 §6.4.1):
+ *   urn:epc:class:lgtin:CompanyPrefix.ItemRefAndIndicator.Lot
+ *   예) urn:epc:class:lgtin:4012345.012345.998877
+ * 두 숫자 마디의 자릿수 합은 13(점 제외), Lot 은 GS3A3Component(URI 이스케이프 허용).
+ */
+export declare function lgtinClass(companyPrefix: string, itemRefAndIndicator: string, lot: string): string;
+/** 식별자를 뜯어 본 결과 — 소비처가 문자열을 자르지 않게 한다(자르면 규칙이 갈라진다). */
+export interface ParsedEpc {
+    /** 표준 스킴. 모르면 'unknown'(원문을 그대로 남긴다 — 추측하지 않는다). */
+    scheme: 'sgtin' | 'lgtin' | 'idpat' | 'sscc' | 'gdti' | 'grai' | 'giai' | 'sgln' | 'unknown';
+    /** 개체 단위인가(epcList 에 들어갈 것인가). 클래스 식별자는 false. */
+    instance: boolean;
+    /** 품목 클래스 키 — `CompanyPrefix.ItemRef`(sgtin/lgtin/idpat 에서). */
+    gtinKey?: string;
+    /** 로트 번호(LGTIN 에만 있다). */
+    lot?: string;
+    /** 일련번호(SGTIN·SSCC 등 개체 식별자에만). */
+    serial?: string;
+    /** 원문 — 해석에 실패해도 잃지 않는다. */
+    uri: string;
+}
+/**
+ * EPC/클래스 식별자 파서 — **표준 지식이라 커널이 소유한다.**
+ *
+ * 소비처가 `uri.split(':').pop()` 으로 자르면 규칙이 갈라진다(실제로 화면이 LGTIN 의 마지막 마디인
+ * 로트를 SKU 이름으로 표시할 위험이 있었다). 뜯는 일은 여기 한 곳에서 한다.
+ */
+export declare function parseEpc(uri: string): ParsedEpc;
 /** 거래문서 식별자 = GDTI (PO/SO/WO/어포인트먼트 등). */
 export declare function gdtiUri(companyPrefix: string, docType: string, serial: number): string;
+/** 모든 빌더가 공통으로 받는 표준 헤더 옵션(선택) — 방출부가 필요할 때 채운다. */
+export interface EpcisHeaderOptions {
+    eventID?: string;
+    recordTime?: string;
+    errorDeclaration?: ErrorDeclaration;
+    ilmd?: Record<string, unknown>;
+    sourceList?: SourceElement[];
+    destinationList?: DestinationElement[];
+    persistentDisposition?: PersistentDisposition;
+    sensorElementList?: SensorElement[];
+    certificationInfo?: string;
+}
 export declare function objectEvent(p: {
     eventTime: string;
     action: EpcisAction;
@@ -83,7 +262,7 @@ export declare function objectEvent(p: {
     readPoint?: string;
     bizLocation?: string;
     bizTransactionList?: BizTransactionElement[];
-}): EpcisObjectEvent;
+} & EpcisHeaderOptions): EpcisObjectEvent;
 export declare function aggregationEvent(p: {
     eventTime: string;
     action: EpcisAction;
@@ -94,7 +273,7 @@ export declare function aggregationEvent(p: {
     childQuantityList?: QuantityElement[];
     readPoint?: string;
     bizLocation?: string;
-}): EpcisAggregationEvent;
+} & EpcisHeaderOptions): EpcisAggregationEvent;
 export declare function transactionEvent(p: {
     eventTime: string;
     action: EpcisAction;
@@ -106,7 +285,7 @@ export declare function transactionEvent(p: {
     quantityList?: QuantityElement[];
     readPoint?: string;
     bizLocation?: string;
-}): EpcisTransactionEvent;
+} & EpcisHeaderOptions): EpcisTransactionEvent;
 /** 변환(제조) — 입력 EPC/수량 소비 → 출력 EPC/수량 생산. action 없음. */
 export declare function transformationEvent(p: {
     eventTime: string;
@@ -120,6 +299,6 @@ export declare function transformationEvent(p: {
     readPoint?: string;
     bizLocation?: string;
     bizTransactionList?: BizTransactionElement[];
-}): EpcisTransformationEvent;
+} & EpcisHeaderOptions): EpcisTransformationEvent;
 export declare function validateEpcisEvent(e: EpcisEvent): string[];
 export {};

package/dist/epcis.js

@@ -23,23 +23,118 @@ export const DISP = {
 export function ssccUri(companyPrefix, serial) {
     return `urn:epc:id:sscc:${companyPrefix}.${String(serial).padStart(10, '0')}`;
 }
-/** 비직렬 수량용 SGTIN 패턴(epcClass) — quantityList 에 사용. */
+/** 비직렬 수량용 SGTIN 패턴(epcClass) — 로트를 따지지 않는 품목 클래스. quantityList 에 사용. */
 export function sgtinClass(companyPrefix, itemRef) {
     return `urn:epc:idpat:sgtin:${companyPrefix}.${itemRef}.*`;
 }
+/**
+ * 우리가 방출하는 개체·로트 마스터데이터의 속성 이름 — **한 곳에 모은다.**
+ *
+ * 표준은 이 이름들을 정의하지 않는다(§7.3.8: 상위 문서 소관). 그래서 값을 실으려면 이름을 정해야 하는데,
+ * 흩뿌리면 곧 방언이 된다. GS1 CBV 마스터데이터 이름공간(`urn:epcglobal:cbv:mda:`)의 정식 명칭을
+ * 확인하면 **이 상수만 바꾸면 되도록** 여기 모아 둔다.
+ *
+ * ⚠ 아래 이름은 **아직 정본 확인 전**이다(CBV 마스터데이터 문서 필요). 받는 경로는 이름과 무관하게
+ * 동작하므로(받은 것을 잃지 않고 통과) 이 상수는 우리가 **생산할 때**만 쓰인다.
+ */
+export const ILMD_ATTR = {
+    /** 유통기한·만료(로트 단위). */
+    expiry: 'cbvmda:itemExpirationDate',
+    /** 로트·배치 번호(직렬 개체에 로트를 붙일 때). */
+    lot: 'cbvmda:lotNumber'
+};
+/**
+ * 품번 + 로트 클래스(LGTIN) — 낱개 일련번호가 없고 **로트로 관리**하는 자재의 표준 식별자.
+ *
+ * 원자재·화학·식품이 이 경우다. 로트가 식별자의 한 마디로 들어가므로 "로트별 재고" 가 별도 필드 없이
+ * epcClass 별 집계가 된다. 개체가 아니라 클래스이므로 `epcList` 가 아니라 `quantityList` 에 쓴다.
+ *
+ * 문법(EPC Tag Data Standard 2.1.0 §6.4.1):
+ *   urn:epc:class:lgtin:CompanyPrefix.ItemRefAndIndicator.Lot
+ *   예) urn:epc:class:lgtin:4012345.012345.998877
+ * 두 숫자 마디의 자릿수 합은 13(점 제외), Lot 은 GS3A3Component(URI 이스케이프 허용).
+ */
+export function lgtinClass(companyPrefix, itemRefAndIndicator, lot) {
+    return `urn:epc:class:lgtin:${companyPrefix}.${itemRefAndIndicator}.${encodeURIComponent(lot)}`;
+}
+/**
+ * EPC/클래스 식별자 파서 — **표준 지식이라 커널이 소유한다.**
+ *
+ * 소비처가 `uri.split(':').pop()` 으로 자르면 규칙이 갈라진다(실제로 화면이 LGTIN 의 마지막 마디인
+ * 로트를 SKU 이름으로 표시할 위험이 있었다). 뜯는 일은 여기 한 곳에서 한다.
+ */
+export function parseEpc(uri) {
+    const raw = String(uri ?? '');
+    const cls = raw.match(/^urn:epc:class:lgtin:(.+)$/);
+    if (cls) {
+        const seg = cls[1].split('.');
+        /* LGTIN 은 숫자 두 마디 + 로트. 로트에 점이 들어갈 수 있으므로 앞 둘만 떼고 나머지를 로트로. */
+        const lot = seg.slice(2).join('.');
+        return {
+            scheme: 'lgtin',
+            instance: false,
+            gtinKey: seg.slice(0, 2).join('.'),
+            lot: lot ? decodeURIComponent(lot) : undefined,
+            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 };
+}
 /** 거래문서 식별자 = GDTI (PO/SO/WO/어포인트먼트 등). */
 export function gdtiUri(companyPrefix, docType, serial) {
     return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
 }
-// ── 이벤트 빌더 (EPCIS 2.0 정규) ──────────────────────────────────────────
-function header(type, eventTime, bizStep) {
-    return { '@context': EPCIS_CONTEXT, type, eventTime, eventTimeZoneOffset: UTC_OFFSET, bizStep };
+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) {
-    return { ...header(type, eventTime, bizStep), action };
+function common(type, eventTime, action, bizStep, opts) {
+    return { ...header(type, eventTime, bizStep, opts), action };
 }
 export function objectEvent(p) {
-    const e = { ...common('ObjectEvent', p.eventTime, p.action, p.bizStep), epcList: p.epcList };
+    const e = { ...common('ObjectEvent', p.eventTime, p.action, p.bizStep, p), epcList: p.epcList };
     if (p.disposition)
         e.disposition = p.disposition;
     if (p.quantityList)
@@ -53,7 +148,7 @@ export function objectEvent(p) {
     return e;
 }
 export function aggregationEvent(p) {
-    const e = { ...common('AggregationEvent', p.eventTime, p.action, p.bizStep), parentID: p.parentID };
+    const e = { ...common('AggregationEvent', p.eventTime, p.action, p.bizStep, p), parentID: p.parentID };
     if (p.disposition)
         e.disposition = p.disposition;
     if (p.childEPCs)
@@ -68,7 +163,7 @@ export function aggregationEvent(p) {
 }
 export function transactionEvent(p) {
     const e = {
-        ...common('TransactionEvent', p.eventTime, p.action, p.bizStep),
+        ...common('TransactionEvent', p.eventTime, p.action, p.bizStep, p),
         bizTransactionList: p.bizTransactionList
     };
     if (p.disposition)
@@ -87,7 +182,7 @@ export function transactionEvent(p) {
 }
 /** 변환(제조) — 입력 EPC/수량 소비 → 출력 EPC/수량 생산. action 없음. */
 export function transformationEvent(p) {
-    const e = header('TransformationEvent', p.eventTime, p.bizStep);
+    const e = header('TransformationEvent', p.eventTime, p.bizStep, p);
     if (p.disposition)
         e.disposition = p.disposition;
     if (p.inputEPCList)
@@ -126,6 +221,58 @@ export function validateEpcisEvent(e) {
         v.push('eventTimeZoneOffset 형식 오류');
     if (typeof e.bizStep !== 'string' || !e.bizStep)
         v.push('bizStep 누락');
+    /* 선택 헤더 — 있으면 형식을 지킨다(없는 것은 위반이 아니다). */
+    if (e.eventID !== undefined && (typeof e.eventID !== 'string' || !e.eventID))
+        v.push('eventID 가 빈 문자열');
+    if (e.recordTime !== undefined && (typeof e.recordTime !== 'string' || !ISO_RE.test(e.recordTime))) {
+        v.push('recordTime ISO8601 아님');
+    }
+    /* 개체·로트 마스터데이터는 **생겨나는 순간에만** 실린다(§7.3.8) — ObjectEvent(ADD) · Transformation.
+     * 아무 이벤트에나 허용하면 "생애 동안 정적" 이라는 성질이 깨지고 이벤트마다 값이 갈라진다. */
+    if (e.ilmd !== undefined) {
+        const allowed = (e.type === 'ObjectEvent' && e.action === 'ADD') || e.type === 'TransformationEvent';
+        if (!allowed)
+            v.push('ilmd 는 ObjectEvent(action=ADD) 또는 TransformationEvent 에만 실을 수 있다');
+    }
+    /* 이전 당사자 — 종류와 당사자가 둘 다 있어야 뜻이 된다(한쪽만 있으면 누가/무엇이 빈다). */
+    for (const sd of e.sourceList ?? []) {
+        if (!sd?.type || !sd?.source)
+            v.push('sourceList 항목에 type 또는 source 누락');
+    }
+    for (const sd of e.destinationList ?? []) {
+        if (!sd?.type || !sd?.destination)
+            v.push('destinationList 항목에 type 또는 destination 누락');
+    }
+    /* 지속 상태 — 같은 조건을 동시에 설정하고 해제하면 뜻이 모순된다. */
+    if (e.persistentDisposition !== undefined) {
+        const set = e.persistentDisposition.set ?? [];
+        const unset = e.persistentDisposition.unset ?? [];
+        if (!set.length && !unset.length)
+            v.push('persistentDisposition 이 set·unset 둘 다 비어있음');
+        const both = set.filter(x => unset.includes(x));
+        if (both.length)
+            v.push(`persistentDisposition 이 같은 값을 set·unset 동시 지정: ${both.join(', ')}`);
+    }
+    /* 센서 — 관측 보고가 하나 이상 있어야 한다(표준: SHALL contain one or more sensorReport). */
+    for (const se of e.sensorElementList ?? []) {
+        if (!Array.isArray(se?.sensorReport) || se.sensorReport.length === 0) {
+            v.push('sensorElement 에 sensorReport 가 하나도 없음');
+        }
+    }
+    if (e.errorDeclaration !== undefined) {
+        const d = e.errorDeclaration;
+        /* 정정인데 언제 정정했는지 모르면 정정 순서를 판정할 수 없다 → 표준 필수. */
+        if (typeof d?.declarationTime !== 'string' || !ISO_RE.test(d.declarationTime)) {
+            v.push('errorDeclaration.declarationTime ISO8601 아님/누락');
+        }
+        if (d?.correctiveEventIDs !== undefined) {
+            if (!Array.isArray(d.correctiveEventIDs))
+                v.push('errorDeclaration.correctiveEventIDs 배열 아님');
+            else if (d.correctiveEventIDs.some(x => typeof x !== 'string' || !x)) {
+                v.push('errorDeclaration.correctiveEventIDs 에 빈 값');
+            }
+        }
+    }
     if (e.type === 'ObjectEvent') {
         if (!ACTIONS.includes(e.action))
             v.push(`action 부정: ${e.action}`);
@@ -163,10 +310,26 @@ export function validateEpcisEvent(e) {
     ];
     for (const list of qtyLists)
         for (const q of list ?? []) {
+            /* 클래스 식별자만 — 개체(urn:epc:id:)는 epcList 의 몫이다. */
             if (!q.epcClass?.startsWith('urn:epc:idpat:') && !q.epcClass?.startsWith('urn:epc:class:'))
                 v.push(`quantity epcClass 부정: ${q.epcClass}`);
-            if (typeof q.quantity !== 'number' || q.quantity < 0)
-                v.push('quantity 부정');
+            /* 세 경우(EPCIS 2.0 §7.3.3.1) — 느슨하게 통과시키면 "모름" 과 "0" 이 섞인다. */
+            const hasQty = q.quantity !== undefined && q.quantity !== null;
+            if (!hasQty) {
+                /* 수량 미지정 = "모른다". 그때 단위만 남아 있으면 뜻이 없다 → 표준은 생략을 요구한다. */
+                if (q.uom !== undefined)
+                    v.push('quantity 없으면 uom 도 없어야 한다(수량 미지정)');
+                continue;
+            }
+            if (typeof q.quantity !== 'number' || !Number.isFinite(q.quantity) || q.quantity <= 0) {
+                v.push('quantity 는 양수여야 한다(모르면 생략)');
+                continue;
+            }
+            /* uom 없으면 개수 → 정수여야 한다. uom 있으면 물리량 → 소수 허용. */
+            if (q.uom === undefined && !Number.isInteger(q.quantity))
+                v.push('uom 없는 quantity 는 정수(개수)여야 한다');
+            if (q.uom !== undefined && !/^[A-Z0-9]{2,3}$/.test(q.uom))
+                v.push(`uom 형식 부정(UN/CEFACT 권고 20 의 2~3자 코드): ${q.uom}`);
         }
     return v;
 }