@operato/twin-kernel 0.1.0 → 0.2.1

package/dist-cjs/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   EPCIS_CONTEXT: () => EPCIS_CONTEXT,
   EventJournal: () => EventJournal,
   FlowEngine: () => FlowEngine,
+  ILMD_ATTR: () => ILMD_ATTR,
   MES_BIZSTEP: () => MES_BIZSTEP,
   MES_NODE_TYPES: () => MES_NODE_TYPES,
   MES_PART_GTINS: () => MES_PART_GTINS,
@@ -39,8 +40,11 @@ __export(index_exports, {
   MES_PRODUCT_GTINS: () => MES_PRODUCT_GTINS,
   MES_TYPES: () => MES_TYPES,
   MesKernel: () => MesKernel,
+  NODE_SATURATION_NEAR: () => NODE_SATURATION_NEAR,
   OP_EVENT: () => OP_EVENT,
-  StateProjector: () => StateProjector,
+  OP_PARAM: () => OP_PARAM,
+  ObservedReducer: () => ObservedReducer,
+  StateProjector: () => ObservedReducer,
   TwinHistory: () => TwinHistory,
   TwinObserver: () => TwinObserver,
   TwinRuntime: () => TwinRuntime,
@@ -65,9 +69,13 @@ __export(index_exports, {
   gdtiUri: () => gdtiUri,
   graiUri: () => graiUri,
   ingest: () => ingest,
+  lgtinClass: () => lgtinClass,
   mapRecord: () => mapRecord,
   monteCarloForecast: () => monteCarloForecast,
+  nodeStatusOf: () => nodeStatusOf,
   objectEvent: () => objectEvent,
+  parseEpc: () => parseEpc,
+  parseIsoDuration: () => parseIsoDuration,
   partialFitPolicy: () => partialFitPolicy,
   replay: () => replay,
   sgtinClass: () => sgtinClass,
@@ -82,9 +90,20 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/contract.ts
+var NODE_SATURATION_NEAR = 0.9;
+function nodeStatusOf(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 >= NODE_SATURATION_NEAR ? "near-full" : "available";
+}
 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 정확 추적.
@@ -111,6 +130,13 @@ var CMD = {
 };
 
 // src/domain-definition.ts
+var OP_PARAM = {
+  /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
+  yield: "yield",
+  /** 셋업·체인지오버 소요(ISO 8601 기간 문자열). ISA-95 는 셋업을 별도 세그먼트로도 표현하지만,
+   *  현재 커널은 작업에 붙는 셋업으로 다루므로 모수로 받는다. */
+  setupDuration: "setupDuration"
+};
 var INTENTS = ["transport", "process", "dwell"];
 function dupes(keys) {
   const seen = /* @__PURE__ */ new Set();
@@ -179,6 +205,9 @@ function compareStates(predicted, actual) {
 }
 
 // src/counterfactual.ts
+function clockOf(twin) {
+  return typeof twin.clockMs === "number" ? twin.clockMs : twin.getSnapshot().simClockMs;
+}
 var TwinHistory = class {
   live;
   tickMs;
@@ -189,7 +218,7 @@ var TwinHistory = class {
   }
   /** 현재를 체크포인트로 저장(호스트가 주기적으로 호출). */
   checkpoint() {
-    this.checkpoints.push({ simMs: this.live.getSnapshot().simClockMs, twin: this.live.fork() });
+    this.checkpoints.push({ simMs: clockOf(this.live), twin: this.live.fork() });
   }
   get count() {
     return this.checkpoints.length;
@@ -201,7 +230,7 @@ var TwinHistory = class {
     if (!best) return void 0;
     const t = best.twin.fork();
     let guard = 0;
-    while (t.getSnapshot().simClockMs < simMs && guard++ < 1e6) t.tick(this.tickMs);
+    while (clockOf(t) < simMs && guard++ < 1e6) t.tick(this.tickMs);
     return t;
   }
 };
@@ -215,7 +244,7 @@ function counterfactualAt(history, atSimMs, opts) {
   const baseline = base.fork();
   const run = (t) => {
     let g = 0;
-    while (t.getSnapshot().simClockMs < target && g++ < 1e6) t.tick(step);
+    while (clockOf(t) < target && g++ < 1e6) t.tick(step);
   };
   run(withAlt);
   run(baseline);
@@ -223,8 +252,11 @@ function counterfactualAt(history, atSimMs, opts) {
 }
 
 // src/forecast.ts
+function clockOf2(twin) {
+  return typeof twin.clockMs === "number" ? twin.clockMs : twin.getSnapshot().simClockMs;
+}
 function monteCarloForecast(twin, opts) {
-  const now = twin.getSnapshot().simClockMs;
+  const now = clockOf2(twin);
   const step = opts.tickMs ?? 1e3;
   const baseSeed = opts.scenario.seed ?? 1;
   const samples = [];
@@ -234,7 +266,7 @@ function monteCarloForecast(twin, opts) {
     fc.scenario.start();
     const target = now + opts.horizonMs;
     let guard = 0;
-    while (fc.getSnapshot().simClockMs < target && guard++ < 1e6) fc.tick(step);
+    while (clockOf2(fc) < target && guard++ < 1e6) fc.tick(step);
     samples.push(opts.metric(fc.getSnapshot()));
   }
   return summarize(opts.runs, samples);
@@ -247,6 +279,9 @@ function summarize(runs, samples) {
 }
 
 // src/twin-observer.ts
+function clockOf3(twin) {
+  return typeof twin.clockMs === "number" ? twin.clockMs : twin.getSnapshot().simClockMs;
+}
 var TwinObserver = class {
   live;
   opts;
@@ -257,7 +292,7 @@ var TwinObserver = class {
   }
   /** 관측 1회 — 만기 예측을 실제와 대조(발산 알림) + 새 예측 생성. 호스트가 주기적으로 호출. */
   observe() {
-    const now = this.live.getSnapshot().simClockMs;
+    const now = clockOf3(this.live);
     const due = this.pending.filter((p) => p.horizonSimMs <= now);
     this.pending = this.pending.filter((p) => p.horizonSimMs > now);
     for (const p of due) {
@@ -268,8 +303,9 @@ var TwinObserver = class {
     const step = this.opts.tickMs ?? 1e3;
     const target = now + this.opts.horizonMs;
     let guard = 0;
-    while (fc.getSnapshot().simClockMs < target && guard++ < 1e6) fc.tick(step);
-    this.pending.push({ madeAtSimMs: now, horizonSimMs: fc.getSnapshot().simClockMs, predicted: fc.getSnapshot() });
+    while (clockOf3(fc) < target && guard++ < 1e6) fc.tick(step);
+    const predicted = fc.getSnapshot();
+    this.pending.push({ madeAtSimMs: now, horizonSimMs: predicted.simClockMs, predicted });
   }
   /** 대기 중(아직 만기 안 된) 예측 수 — 진단용. */
   get pendingCount() {
@@ -277,19 +313,243 @@ var TwinObserver = class {
   }
 };
 
-// src/state-projector.ts
-var StateProjector = class {
+// 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
+};
+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 ?? "");
+  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 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"];
+function validateEpcisEvent(e) {
+  const v = [];
+  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 ?? []) {
+    if (!q.epcClass?.startsWith("urn:epc:idpat:") && !q.epcClass?.startsWith("urn:epc:class:")) v.push(`quantity epcClass \uBD80\uC815: ${q.epcClass}`);
+    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/observed-reducer.ts
+var UNKNOWN_TYPE = "unknown";
+var ObservedReducer = class {
+  /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
   master = /* @__PURE__ */ new Map();
   items = /* @__PURE__ */ new Map();
   aggregation = /* @__PURE__ */ new Map();
-  // parent SSCC → child EPCs
+  /** 아직 관측되지 않은 자식의 담김 — 물품을 지어내지 않고 보류했다가 등장할 때 붙인다. */
+  pendingParent = /* @__PURE__ */ new Map();
+  // 자식 EPC → 부모(물류단위)
   tasks = /* @__PURE__ */ new Map();
   movers = /* @__PURE__ */ new Map();
+  persons = /* @__PURE__ */ new Map();
+  assets = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
   revision = 0;
+  /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
+  corrections = [];
   constructor(board) {
-    for (const n of board.nodes) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parentId: n.parentId });
-    for (const m of board.movers) this.movers.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeNode });
+    for (const n of board.nodes) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: "master" });
+    for (const m of board.movers) this.movers.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeNode, origin: "master" });
+    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: "idle" });
+    for (const a of board.assets ?? []) this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: "idle" });
   }
   /** 마스터 동기 — 로케이션 추가/변경/제거. */
   applyMaster(u) {
@@ -298,48 +558,173 @@ var StateProjector = class {
       return;
     }
     const cur = this.master.get(u.node.id);
+    const capacity = u.node.capacity ?? cur?.capacity;
+    const parallelism = u.node.parallelism ?? cur?.parallelism;
     this.master.set(u.node.id, {
       id: u.node.id,
-      type: u.node.type ?? cur?.type ?? "unknown",
-      capacity: u.node.capacity ?? cur?.capacity ?? 0
+      type: u.node.type ?? cur?.type ?? UNKNOWN_TYPE,
+      ...capacity === void 0 ? {} : { capacity },
+      ...parallelism === void 0 ? {} : { parallelism },
+      ...u.node.parentId ?? cur?.parentId ? { parentId: u.node.parentId ?? cur?.parentId } : {},
+      /* 마스터가 말한 것은 마스터 출처다 — 관측으로 알게 된 것(origin='observed')을 덮어 승격한다. */
+      origin: "master"
     });
   }
+  /**
+   * 관측된 로케이션을 구조로 승격 — **이벤트가 가르쳐 준 것을 구조에서 지우지 않는다.**
+   *
+   * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `nodes` 에는
+   * 나타나지 않았다. 그 결과 그 자리는 스키매틱에 없고, 점유가 집계되지 않고, 병목 주목이 뜰 수
+   * 없었다 — **사실은 들어왔는데 구조가 모르는 상태.** 이제 최소 형태로 승격한다:
+   * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
+   *
+   * 출처를 표시하는 이유: 소비처가 "마스터가 말한 자리" 와 "관측으로 알게 된 자리" 를 구별해야 한다
+   * (보드에 좌표가 없고, 용량을 채워야 계획에 참여한다). 마스터 동기가 오면 `master` 로 승격된다.
+   */
+  touchLocation(id) {
+    if (!id || this.master.has(id)) return;
+    this.master.set(id, { id, type: UNKNOWN_TYPE, origin: "observed" });
+  }
+  /**
+   * 늦게 도착한 옛 이벤트를 걸러낸다 — **도착 순서 ≠ 발생 순서**.
+   *
+   * 실 연동에서는 순서가 뒤집힌다(재시도·큐·배치). 시각을 비교하지 않으면 **늦게 온 옛 이벤트가 최신
+   * 상태를 덮어써** 위치가 과거로 튄다. 표준이 발생(`eventTime`)과 기록(`recordTime`)을 나눠 둔 이유가
+   * 이것이므로, 대상별로 마지막으로 반영한 시각을 기억해 그보다 오래된 것은 무시한다.
+   *
+   * 판정 시각은 **발생 시각**을 쓴다(현장에서 일어난 순서가 사실). `recordTime` 은 같은 발생 시각이
+   * 겹칠 때의 보조 기준이다. 시각이 없으면 판정하지 않는다(있는 것만 가지고 판단한다).
+   */
+  stale(key, e) {
+    const at = Date.parse(String(e.eventTime ?? ""));
+    if (!Number.isFinite(at)) return false;
+    const recorded = Date.parse(String(e.data?.recordTime ?? ""));
+    const seen = this.lastAt.get(key);
+    if (seen === void 0) {
+      this.lastAt.set(key, { at, recorded: Number.isFinite(recorded) ? recorded : void 0 });
+      return false;
+    }
+    if (at < seen.at) return true;
+    if (at === seen.at && Number.isFinite(recorded) && seen.recorded !== void 0 && recorded < seen.recorded) return true;
+    this.lastAt.set(key, { at, recorded: Number.isFinite(recorded) ? recorded : seen.recorded });
+    return false;
+  }
+  /** 대상별 마지막 반영 시각 — 순서 판정용(대상=EPC·작업·설비·오더 id). */
+  lastAt = /* @__PURE__ */ new Map();
   /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
   apply(e) {
     this.revision++;
     if (e.eventType.startsWith("epcis.")) {
-      this.applyEpcis(e.data);
+      this.applyEpcis(e.data, e);
       return;
     }
     switch (e.eventType) {
       case OP_EVENT.task: {
         const d = e.data;
-        this.tasks.set(d.taskId, { id: d.taskId, kind: d.kind, status: d.status, fromNode: d.fromNode, toNode: d.toNode, itemRefs: d.itemRefs, resourceRef: d.resourceRef });
+        if (this.stale(`task:${d.taskId}`, e)) return;
+        this.touchLocation(d.fromNode);
+        this.touchLocation(d.toNode);
+        this.tasks.set(d.taskId, {
+          id: d.taskId,
+          kind: d.kind,
+          status: d.status,
+          fromNode: d.fromNode,
+          toNode: d.toNode,
+          itemRefs: d.itemRefs,
+          resourceRef: d.resourceRef,
+          orderId: d.orderId,
+          intent: d.intent,
+          progress: d.progress,
+          remainingMs: d.remainingMs,
+          durationMs: d.durationMs,
+          startedAtSimMs: d.startedAtSimMs,
+          ...d.personnel?.length ? { personnel: d.personnel.slice() } : {},
+          ...d.assets?.length ? { assets: d.assets.slice() } : {}
+        });
         break;
       }
       case OP_EVENT.equipment: {
         const d = e.data;
-        this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, motion: d.motion });
+        if (this.stale(`mover:${d.moverId}`, e)) return;
+        this.touchLocation(d.location);
+        const known = this.movers.get(d.moverId);
+        this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed" });
+        break;
+      }
+      case OP_EVENT.person: {
+        const d = e.data;
+        if (this.stale(`person:${d.personId}`, e)) return;
+        this.persons.set(d.personId, {
+          id: d.personId,
+          personnelClass: d.personnelClass ?? this.persons.get(d.personId)?.personnelClass,
+          status: d.status,
+          taskId: d.taskId,
+          ...d.offShift ? { offShift: true } : {}
+        });
+        break;
+      }
+      case OP_EVENT.asset: {
+        const d = e.data;
+        if (this.stale(`asset:${d.assetId}`, e)) return;
+        const cur = this.assets.get(d.assetId);
+        this.assets.set(d.assetId, {
+          id: d.assetId,
+          assetClass: d.assetClass ?? cur?.assetClass,
+          location: d.location ?? cur?.location,
+          status: d.status,
+          taskId: d.taskId,
+          ...d.carrying ? { carrying: d.carrying } : {}
+        });
+        this.touchLocation(d.location);
         break;
       }
       case OP_EVENT.order: {
         const d = e.data;
+        if (this.stale(`order:${d.orderId}`, e)) return;
         this.orders.set(d.orderId, { id: d.orderId, kind: d.kind, status: d.status, progress: d.requested ? d.fulfilled / d.requested : 0, held: d.held });
         break;
       }
     }
   }
-  applyEpcis(ev) {
+  applyEpcis(ev, envelope) {
+    if (ev.errorDeclaration) {
+      this.corrections.push({
+        declaredAt: String(ev.errorDeclaration.declarationTime ?? ""),
+        reason: ev.errorDeclaration.reason,
+        correctiveEventIDs: ev.errorDeclaration.correctiveEventIDs ?? [],
+        eventID: ev.eventID
+      });
+      return;
+    }
     if (ev.type === "AggregationEvent") {
-      if (ev.action === "ADD" && ev.childEPCs?.length) this.aggregation.set(ev.parentID, [...ev.childEPCs]);
-      else if (ev.action === "DELETE") this.aggregation.delete(ev.parentID);
+      if (ev.action === "ADD" && ev.childEPCs?.length) {
+        this.aggregation.set(ev.parentID, [...ev.childEPCs]);
+        for (const child of ev.childEPCs) {
+          const cur = this.items.get(child);
+          if (cur) {
+            this.items.set(child, { ...cur, parent: ev.parentID });
+            continue;
+          }
+          this.pendingParent.set(child, ev.parentID);
+        }
+      } else if (ev.action === "DELETE") {
+        for (const child of this.aggregation.get(ev.parentID) ?? []) {
+          const cur = this.items.get(child);
+          if (cur) this.items.set(child, { ...cur, parent: void 0 });
+          this.pendingParent.delete(child);
+        }
+        this.aggregation.delete(ev.parentID);
+      }
       return;
     }
     if (ev.type === "TransactionEvent") return;
     if (ev.type === "TransformationEvent") {
       for (const epc of ev.inputEPCList ?? []) this.remove(epc);
       const loc2 = ev.readPoint?.id ?? "";
-      for (const epc of ev.outputEPCList ?? []) this.items.set(epc, { epc, location: loc2, disposition: ev.disposition });
+      this.touchLocation(loc2);
+      for (const epc of ev.outputEPCList ?? []) {
+        this.items.set(epc, this.mergeItem(epc, { location: loc2, disposition: ev.disposition, ilmd: ev.ilmd }));
+      }
       return;
     }
     if (ev.action === "DELETE") {
@@ -347,11 +732,57 @@ var StateProjector = class {
       return;
     }
     const loc = ev.readPoint?.id;
-    const gtin = ev.quantityList?.[0]?.epcClass;
+    const q = ev.quantityList?.[0];
+    this.touchLocation(loc);
     for (const epc of ev.epcList) {
-      const cur = this.items.get(epc);
-      this.items.set(epc, { epc, gtin: gtin ?? cur?.gtin, location: loc ?? cur?.location ?? "", disposition: ev.disposition ?? cur?.disposition });
+      if (envelope && this.stale(`item:${epc}`, envelope)) continue;
+      this.items.set(epc, this.mergeItem(epc, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, q));
+    }
+    if (!ev.epcList?.length) {
+      for (const qe of ev.quantityList ?? []) {
+        if (qe?.epcClass) this.items.set(qe.epcClass, this.mergeItem(qe.epcClass, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, qe));
+      }
+    }
+  }
+  /**
+   * 물품 한 건 병합 — **아는 것을 잃지 않는다.** 새로 온 값이 우선, 없으면 기존 값 유지.
+   * 클래스 식별자(LGTIN/idpat)에서 품번·로트를 파생한다 — 소비처가 문자열을 자르지 않게.
+   */
+  /**
+   * 개체·로트 마스터데이터에서 만료 시각을 뽑는다 — **우리가 아는 이름일 때만.**
+   *
+   * 표준이 속성 이름을 정의하지 않으므로 모르는 이름은 해석하지 않는다(추측하지 않는다). 원문은
+   * `ilmd` 로 그대로 남으니 도메인이 자기 어휘로 읽을 수 있다.
+   */
+  expiryOf(ilmd) {
+    const raw = ilmd?.[ILMD_ATTR.expiry];
+    if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+    if (typeof raw === "string") {
+      const t = Date.parse(raw);
+      if (Number.isFinite(t)) return t;
     }
+    return void 0;
+  }
+  mergeItem(epc, patch, q) {
+    const cur = this.items.get(epc);
+    const parsedClass = q?.epcClass ? parseEpc(q.epcClass) : void 0;
+    const parsedSelf = parseEpc(epc);
+    const classUri = q?.epcClass ?? (parsedSelf.instance ? void 0 : epc);
+    return {
+      epc,
+      gtin: classUri ?? cur?.gtin,
+      gtinKey: parsedClass?.gtinKey ?? parsedSelf.gtinKey ?? cur?.gtinKey,
+      location: patch.location ?? cur?.location ?? "",
+      disposition: patch.disposition ?? cur?.disposition,
+      parent: cur?.parent ?? this.pendingParent.get(epc),
+      qty: q?.quantity ?? cur?.qty,
+      uom: q?.uom ?? cur?.uom,
+      /* 마스터데이터는 생겨날 때 한 번 정해진다 — 뒤 이벤트가 지우지 않게 기존 값을 남긴다. */
+      ilmd: patch.ilmd ?? cur?.ilmd,
+      expiry: this.expiryOf(patch.ilmd) ?? cur?.expiry,
+      /* 로트는 LGTIN(식별자)에서 오지만, 직렬 개체는 마스터데이터에 실려 온다. */
+      lot: parsedClass?.lot ?? parsedSelf.lot ?? (typeof patch.ilmd?.[ILMD_ATTR.lot] === "string" ? patch.ilmd[ILMD_ATTR.lot] : void 0) ?? cur?.lot
+    };
   }
   /** 이탈(DELETE) — 아이템 + 조립 자식(재귀) 제거. 화물 SSCC DELETE 시 팔레트도 함께 이탈. */
   remove(epc) {
@@ -368,8 +799,26 @@ var StateProjector = class {
     for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
     return {
       revision: this.revision,
-      nodes: [...this.master.values()].map((n) => ({ id: n.id, type: n.type, capacity: n.capacity, occupancy: occ.get(n.id) ?? 0, parentId: n.parentId })),
-      items: [...this.items.values()].map((i) => ({ epc: i.epc, gtin: i.gtin, location: i.location, disposition: i.disposition })),
+      ...this.corrections.length ? { corrections: this.corrections.map((c) => ({ ...c })) } : {},
+      nodes: [...this.master.values()].map((n) => {
+        const occupancy = occ.get(n.id) ?? 0;
+        const status = nodeStatusOf({ occupancy, capacity: n.capacity });
+        return {
+          id: n.id,
+          type: n.type,
+          occupancy,
+          ...status ? { status } : {},
+          /* 용량 미상은 **키를 만들지 않는다** — 0 으로 실으면 "자리 없음" 이라는 없는 사실이 생긴다. */
+          ...n.capacity === void 0 ? {} : { capacity: n.capacity },
+          ...n.parallelism === void 0 ? {} : { parallelism: n.parallelism },
+          ...n.parentId ? { parentId: n.parentId } : {},
+          origin: n.origin
+        };
+      }),
+      /* 들고 있는 것을 전부 내보낸다 — 축소하면 그 자리에서 정보가 사라진다. */
+      items: [...this.items.values()].map((i) => ({ ...i })),
+      persons: [...this.persons.values()].map((p) => ({ ...p })),
+      assets: [...this.assets.values()].map((a) => ({ ...a })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
       movers: [...this.movers.values()].map((m) => ({ ...m })),
       orders: [...this.orders.values()].map((o) => ({ ...o }))
@@ -404,119 +853,11 @@ var EventJournal = class {
   }
 };
 function replay(board, events) {
-  const proj = new StateProjector(board);
+  const proj = new ObservedReducer(board);
   for (const e of events) proj.apply(e);
   return proj.snapshot();
 }
 
-// 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
-};
-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}.*`;
-}
-function gdtiUri(companyPrefix, docType, serial) {
-  return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
-}
-function header(type, eventTime, bizStep) {
-  return { "@context": EPCIS_CONTEXT, type, eventTime, eventTimeZoneOffset: UTC_OFFSET, bizStep };
-}
-function common(type, eventTime, action, bizStep) {
-  return { ...header(type, eventTime, bizStep), action };
-}
-function objectEvent(p) {
-  const e = { ...common("ObjectEvent", p.eventTime, p.action, p.bizStep), 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), 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),
-    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);
-  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"];
-function validateEpcisEvent(e) {
-  const v = [];
-  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.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 ?? []) {
-    if (!q.epcClass?.startsWith("urn:epc:idpat:") && !q.epcClass?.startsWith("urn:epc:class:")) v.push(`quantity epcClass \uBD80\uC815: ${q.epcClass}`);
-    if (typeof q.quantity !== "number" || q.quantity < 0) v.push("quantity \uBD80\uC815");
-  }
-  return v;
-}
-
 // src/wms-profile.ts
 var BIZSTEP = {
   receiving: "urn:epcglobal:cbv:bizstep:receiving",
@@ -682,6 +1023,25 @@ var fefoPolicy = {
 // src/duration-estimator.ts
 var constantDuration = (ms2) => ({ estimate: () => ms2 });
 
+// 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 ms2 = (Number(w ?? 0) * 7 + Number(d ?? 0)) * 864e5 + Number(h ?? 0) * 36e5 + Number(min ?? 0) * 6e4 + Number(sec ?? 0) * 1e3;
+  if (!Number.isFinite(ms2)) return void 0;
+  return sign ? -ms2 : ms2;
+}
+
 // src/task-fold.ts
 function ms(value) {
   if (!value) return null;
@@ -931,19 +1291,41 @@ var FlowEngine = class {
   nodes = /* @__PURE__ */ new Map();
   items = /* @__PURE__ */ new Map();
   movers = /* @__PURE__ */ new Map();
+  /** 사람 — 선언하지 않으면 빈 맵(인원 제약 없는 트윈, 기존 거동). */
+  persons = /* @__PURE__ */ new Map();
+  /** 물리 자산 — 선언하지 않으면 빈 맵(자산 제약 없는 트윈, 기존 거동). */
+  assets = /* @__PURE__ */ new Map();
   tasks = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
   revision = 0;
   clockMs = 0;
   rng = mulberry32(1);
   policy;
-  /** duration 시임(선택) — 미주입 시 도메인 상수. 씬/보드 바인딩이 거리·속도 기반 estimator 주입. */
+  /** duration 시임(선택) — 미주입 시 명세, 명세도 없으면 도메인 상수. 이력 보정 추정기가 여기 들어온다. */
   durationEstimator;
+  /**
+   * 오퍼레이션 명세(선택) — 작업 종류(`FlowTask.kind` = `OperationDef.key`) → 소요·변동·모수.
+   * 도메인 정의에서 실어 온다(`loadOperations`). 없으면 커널 기본값을 쓰고 그 사실을 `specCoverage()` 가 밝힌다.
+   */
+  operationSpecs = /* @__PURE__ */ new Map();
+  /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
+  observer;
+  /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
+  observedDirty = false;
+  observeMode = false;
+  /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
+  boardDef;
+  /** 명세 소비 기록 — 무엇을 선언값으로, 무엇을 기본값으로 계산했나(정직한 자기보고). */
+  specUse = /* @__PURE__ */ new Map();
   epcSeq = 0;
   taskSeq = 0;
   orderSeq = 0;
   soSeq = 0;
   handlers = [];
+  /** 구독자 접근(관측 재방출) — emit 과 같은 목록을 쓴다(두 경로가 갈리지 않게). */
+  handlersRef() {
+    return this.handlers;
+  }
   gens = [];
   generating = false;
   speed = 1;
@@ -954,9 +1336,12 @@ var FlowEngine = class {
   }
   // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
   loadBoard(def) {
-    for (const n of def.nodes) this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, occupancy: 0, status: "idle", parentId: n.parentId });
+    this.boardDef = def;
+    for (const n of def.nodes) this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: "idle", parentId: n.parentId });
+    for (const p of def.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: "idle", taskId: null, window: p.window });
+    for (const a of def.assets ?? []) this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: "idle", taskId: null });
     for (const m of def.movers) {
-      const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+      const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
       if (m.mtbfMs !== void 0) {
         mover.mtbfMs = m.mtbfMs;
         mover.mttrMs = m.mttrMs;
@@ -987,10 +1372,82 @@ var FlowEngine = class {
    * 진행 중 개별 task 의 내부 상태는 관측만으론 복원 불가 → 재계획에 맡김(정직한 한계).
    */
   hydrateObserved(snap, orders = []) {
-    for (const n of snap.nodes) this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, occupancy: n.occupancy ?? 0, status: "idle", parentId: n.parentId });
+    for (const n of snap.nodes) {
+      this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? "idle", parentId: n.parentId });
+    }
     this.items.clear();
-    for (const it of snap.items) this.items.set(it.epc, { epc: it.epc, location: it.location, disposition: it.disposition ?? DISP.sellable, gtin: it.gtin, qty: it.qty ?? 1 });
-    for (const m of snap.movers) this.movers.set(m.id, { id: m.id, kind: m.kind, location: m.location ?? "", status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 });
+    for (const it of snap.items) {
+      this.items.set(it.epc, {
+        /* 품번 키·로트는 식별자에서 파생되므로 심지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
+        epc: it.epc,
+        location: it.location,
+        disposition: it.disposition ?? DISP.sellable,
+        gtin: it.gtin,
+        qty: it.qty ?? 1,
+        uom: it.uom,
+        parent: it.parent,
+        carriedBy: it.carriedBy,
+        expiry: it.expiry,
+        ilmd: it.ilmd
+      });
+    }
+    for (const m of snap.movers) {
+      const oee = m.oee;
+      this.movers.set(m.id, {
+        id: m.id,
+        kind: m.kind,
+        location: m.location ?? "",
+        status: m.status ?? "idle",
+        taskId: null,
+        runMs: oee?.runMs ?? 0,
+        setupMs: oee?.setupMs ?? 0,
+        downMs: oee?.downMs ?? 0,
+        goodCount: oee?.goodCount ?? 0,
+        scrapCount: oee?.scrapCount ?? 0
+      });
+    }
+    for (const p of snap.persons ?? []) {
+      this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: "idle", taskId: null });
+    }
+    for (const a of snap.assets ?? []) {
+      this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.location, status: "idle", taskId: null, carrying: a.carrying });
+    }
+    for (const t of snap.tasks ?? []) {
+      if (t.status === "completed") continue;
+      const known = typeof t.remainingMs === "number" && Number.isFinite(t.remainingMs);
+      this.tasks.set(t.id, {
+        id: t.id,
+        kind: t.kind,
+        status: known && t.status === "in-progress" ? "in-progress" : "created",
+        itemEpc: t.itemRefs?.[0] ?? "",
+        fromNode: t.fromNode ?? "",
+        toNode: t.toNode ?? "",
+        resource: known && t.status === "in-progress" ? t.resourceRef ?? null : null,
+        remainingMs: known ? t.remainingMs : t.durationMs ?? 0,
+        startedAtSimMs: t.startedAtSimMs,
+        durationMs: t.durationMs ?? (known ? t.remainingMs : 0),
+        orderId: t.orderId,
+        intent: t.intent
+      });
+      if (known && t.status === "in-progress" && t.resourceRef) {
+        const mv = this.movers.get(t.resourceRef);
+        if (mv) {
+          mv.status = "busy";
+          mv.taskId = t.id;
+        }
+      }
+      if (known && t.status === "in-progress") {
+        const restored = this.tasks.get(t.id);
+        if (restored) restored.personnel = t.personnel ? [...t.personnel] : void 0;
+        for (const id of t.personnel ?? []) {
+          const pp = this.persons.get(id);
+          if (pp) {
+            pp.status = "busy";
+            pp.taskId = t.id;
+          }
+        }
+      }
+    }
     for (const o of orders) {
       const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
       const remaining = lines.reduce((s, l) => s + l.requested, 0);
@@ -1121,7 +1578,7 @@ var FlowEngine = class {
     start: () => {
       if (this.generating) return;
       this.generating = true;
-      for (const g of this.gens) g.nextMs = this.clockMs + this.intervalMs(g.spec);
+      for (const g of this.gens) g.nextMs = this.nextFireMs(g.spec, this.clockMs);
     },
     pause: () => {
       this.generating = false;
@@ -1143,18 +1600,52 @@ var FlowEngine = class {
     this.processTasks(dt);
   }
   getSnapshot() {
+    this.settleObserved();
     return {
       revision: this.revision,
       simClockMs: this.clockMs,
-      nodes: [...this.nodes.values()].map((n) => ({ ...n })),
-      items: [...this.items.values()].map((i) => ({ epc: i.epc, gtin: i.gtin, qty: i.qty, location: i.location, disposition: i.disposition, expiry: i.expiry })),
+      /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
+       * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
+      nodes: [...this.nodes.values()].map((n) => {
+        const { status, ...rest } = n;
+        const derived = nodeStatusOf(n);
+        return { ...rest, ...derived ? { status: derived } : {}, origin: "master" };
+      }),
+      items: [...this.items.values()].map((i) => this.itemState(i)),
       movers: [...this.movers.values()].map((m) => {
-        const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held };
+        const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, origin: "master", ...this.offShift(m) ? { offShift: true } : {} };
         const t = m.taskId ? this.tasks.get(m.taskId) : void 0;
         if (t && t.status === "in-progress" && t.intent !== "process") s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: this.progressOf(t), elapsedMs: t.durationMs - t.remainingMs };
         return s;
       }),
-      tasks: [...this.tasks.values()].map((t) => ({ id: t.id, kind: t.kind, status: t.status, itemRefs: [t.itemEpc], fromNode: t.fromNode, toNode: t.toNode, resourceRef: t.resource ?? void 0, orderId: t.orderId, progress: t.status === "in-progress" ? this.progressOf(t) : void 0 })),
+      assets: [...this.assets.values()].map((a) => {
+        const st = { id: a.id, assetClass: a.assetClass, location: a.location, status: a.status, taskId: a.taskId ?? void 0 };
+        if (a.carrying) st.carrying = a.carrying;
+        return st;
+      }),
+      persons: [...this.persons.values()].map((p) => {
+        const st = { id: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? void 0 };
+        if (this.personOffShift(p)) st.offShift = true;
+        return st;
+      }),
+      /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
+       * 다른 커널을 심으면(hydrateObserved) 진행 중이던 작업을 이어 굴릴 수 없었다(미러 스냅샷은
+       * 델타에서 왔으므로 갖고 있었다 — 같은 계약을 두 구동이 다르게 채우던 자리). */
+      tasks: [...this.tasks.values()].map((t) => ({
+        id: t.id,
+        kind: t.kind,
+        status: t.status,
+        itemRefs: [t.itemEpc],
+        fromNode: t.fromNode,
+        toNode: t.toNode,
+        resourceRef: t.resource ?? void 0,
+        orderId: t.orderId,
+        ...t.intent ? { intent: t.intent } : {},
+        ...t.durationMs ? { durationMs: t.durationMs } : {},
+        ...t.status === "in-progress" ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: this.progressOf(t) } : {},
+        ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
+        ...t.assets?.length ? { assets: t.assets.slice() } : {}
+      })),
       orders: [...this.orders.values()].map((o) => ({ id: o.id, kind: o.kind, status: o.status, progress: o.requested ? o.fulfilled / o.requested : 0, held: o.held })),
       attentions: this.computeAttentions()
     };
@@ -1180,6 +1671,7 @@ var FlowEngine = class {
    * rng 는 fork 의 시나리오 load 시 재시드(드레인 예측은 생성 없어 rng 무관·결정적).
    */
   fork(tenantId = this.tenantId) {
+    this.settleObserved();
     const Ctor = this.constructor;
     const clone = new Ctor(tenantId, this.policy);
     const skip = /* @__PURE__ */ new Set(["policy", "scenario", "tenantId", "handlers", "durationEstimator"]);
@@ -1191,6 +1683,8 @@ var FlowEngine = class {
     }
     clone.rng.state = this.rng.state;
     clone.durationEstimator = this.durationEstimator;
+    clone.operationSpecs = this.operationSpecs;
+    clone.specUse = new Map([...this.specUse.entries()].map(([k, u]) => [k, { duration: u.duration, variability: u.variability, params: new Set(u.params) }]));
     return clone;
   }
   // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
@@ -1200,9 +1694,161 @@ var FlowEngine = class {
   randInt(min, max) {
     return max <= min ? min : min + Math.floor(this.rng() * (max - min + 1));
   }
-  /** task 소요 산출 — estimator 주입 시 그 값, 미주입/undefined 시 도메인 상수(fallback). "얼마"만 소비, "경로"는 씬. */
+  /**
+   * 관측 구동(P0 스파이크) — **이벤트로 커널을 굴린다.**
+   *
+   * 상태를 만드는 구동이 둘인데(시뮬 `tick` / 미러 `apply`) 지금은 **모델도 둘**이라 한쪽만 고치면
+   * 갈라진다(2026-08-01 하루에 아홉 곳). 근본 해법은 **한 상태 모델 두 구동**이고, 이것은 그 실현
+   * 가능성을 재는 스파이크다(design/plans/kernel-unification-live-observe.md P0).
+   *
+   * 여기서는 **이미 검증된 조각을 조립**한다: 투영기가 이벤트를 접고, 그 결과를 씨앗 경로
+   * (`hydrateObserved`)로 커널 상태에 심는다. 그래서 관측으로 굴린 커널을 그대로 `fork`·`tick` 할 수
+   * 있다 — "미러에서 예측한다" 가 별도 배관 없이 성립하는지가 이 스파이크의 질문이다.
+   *
+   * **비용은 정직하게**: 이벤트마다 전체를 다시 심으므로 O(상태 크기)다. P1 에서 반영 로직을 순수
+   * reduce 모듈로 추출해 투영기와 공유하면 사라진다. 지금은 계약이 성립하는지만 본다.
+   *
+   * `tick` 과 섞어 쓰지 않는다 — 섞으면 무엇이 진실인지 알 수 없다(관측이 시뮬을 덮어쓴다).
+   */
+  apply(envelope) {
+    if (!this.observer) {
+      this.observer = new ObservedReducer(this.boardDef ?? { nodes: [], movers: [] });
+      this.observeMode = true;
+    }
+    this.observer.apply(envelope);
+    for (const h of this.observedHandlers()) h(envelope);
+    this.observedDirty = true;
+    this.revision++;
+  }
+  /** 관측분을 커널 상태로 옮긴다 — 필요할 때 한 번만(같은 규칙, 같은 씨앗 경로). */
+  settleObserved() {
+    if (!this.observedDirty || !this.observer) return;
+    this.observedDirty = false;
+    this.hydrateObserved(this.observer.snapshot());
+  }
+  /** 구독자 목록 — 관측 재방출용(private handlers 에 접근). */
+  observedHandlers() {
+    return this.handlersRef();
+  }
+  /** 관측 구동으로 굴러가는 중인가 — 소비처가 "이 커널의 진실이 어디서 오나" 를 물을 수 있게. */
+  get observing() {
+    return this.observeMode;
+  }
+  /**
+   * 오퍼레이션 명세를 싣는다 — 도메인 정의(ISA-95 OperationsSegment)의 시뮬 명세를 커널이 소비하는 입구.
+   * 같은 key 를 다시 실으면 덮어쓴다(정의가 권위).
+   */
+  loadOperations(ops = []) {
+    for (const o of ops) if (o?.key) this.operationSpecs.set(o.key, o);
+  }
+  /**
+   * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
+   *
+   * 이 순서인 이유: 실측에서 배운 값이 선언값을 이기고, 선언값이 우리가 코드에 박아 둔 상수를 이긴다.
+   * 셋 중 무엇을 썼는지는 `specCoverage()` 로 드러낸다 — 상수를 쓴 것이 조용히 넘어가지 않게.
+   * "얼마"만 소비하고 "경로"는 씬이 소유한다(좌표-free 유지).
+   */
   durationOf(ctx, fallbackMs) {
-    return this.durationEstimator?.estimate(ctx) ?? fallbackMs;
+    const estimated = this.durationEstimator?.estimate(ctx);
+    if (typeof estimated === "number") {
+      this.noteSpecUse(ctx.kind, "measured");
+      return estimated;
+    }
+    if (estimated) {
+      this.noteSpecUse(ctx.kind, "measured", estimated.spread?.distribution);
+      return this.sampleSpread(estimated.meanMs, estimated.spread);
+    }
+    const spec = this.operationSpecs.get(ctx.kind);
+    const declared = parseIsoDuration(spec?.duration);
+    if (declared === void 0) {
+      this.noteSpecUse(ctx.kind, "default");
+      return fallbackMs;
+    }
+    this.noteSpecUse(ctx.kind, "declared");
+    return this.applyVariability(declared, spec?.variability);
+  }
+  /**
+   * 소요시간 변동 표본 — **엔진 난수원으로만** 뽑는다(fork 결정성). 표준 밖 확장이므로 미지정이면 상수.
+   * 모수가 모자라면(uniform 에 min/max 없음 등) 변동을 발명하지 않고 평균을 그대로 쓴다.
+   */
+  applyVariability(meanMs, v) {
+    if (!v || v.distribution === "constant") return meanMs;
+    if (v.distribution === "exponential") return -Math.log(1 - this.rng()) * meanMs;
+    const minMs = parseIsoDuration(v.min);
+    const maxMs = parseIsoDuration(v.max);
+    if (minMs === void 0 || maxMs === void 0) return meanMs;
+    return this.sampleSpread(meanMs, { distribution: v.distribution, minMs, maxMs, modeMs: parseIsoDuration(v.mode) });
+  }
+  /**
+   * 퍼짐 표본 — **엔진 난수원으로만** 뽑는다(fork 결정성). 선언 명세(ISO 표기)와 실측 분포(ms)가
+   * 같은 수식을 쓴다: 한쪽만 고치면 두 경로가 다른 답을 낸다.
+   * 모수가 모자라거나 뒤집혀 있으면 **퍼짐을 발명하지 않고** 평균을 그대로 쓴다.
+   */
+  sampleSpread(meanMs, spread) {
+    if (!spread) return meanMs;
+    const { minMs, maxMs } = spread;
+    if (!Number.isFinite(minMs) || !Number.isFinite(maxMs) || maxMs < minMs) return meanMs;
+    if (spread.distribution === "uniform") return minMs + this.rng() * (maxMs - minMs);
+    const mode = Math.min(maxMs, Math.max(minMs, spread.modeMs ?? meanMs));
+    const u = this.rng();
+    const span = maxMs - minMs;
+    if (span <= 0) return minMs;
+    const c = (mode - minMs) / span;
+    return u < c ? minMs + Math.sqrt(u * span * (mode - minMs)) : maxMs - Math.sqrt((1 - u) * span * (maxMs - mode));
+  }
+  /** 명세 모수(숫자) — 선언 없으면 undefined(0 으로 꾸미지 않는다). 소비처가 기본값을 정한다. */
+  paramNumber(opKey, id) {
+    const p = this.operationSpecs.get(opKey)?.parameters?.find((x) => x.id === id);
+    if (!p) return void 0;
+    const n = Number(p.value);
+    if (!Number.isFinite(n)) return void 0;
+    this.noteParamUse(opKey, id);
+    return n;
+  }
+  /** 명세 모수(기간) — ISO 8601 문자열을 밀리초로. 선언 없으면 undefined. */
+  paramDuration(opKey, id) {
+    const p = this.operationSpecs.get(opKey)?.parameters?.find((x) => x.id === id);
+    const ms2 = parseIsoDuration(p?.value);
+    if (ms2 !== void 0) this.noteParamUse(opKey, id);
+    return ms2;
+  }
+  noteSpecUse(kind, duration, variability) {
+    const cur = this.specUse.get(kind);
+    if (cur) {
+      cur.duration = duration;
+      if (variability) cur.variability = variability;
+      return;
+    }
+    this.specUse.set(kind, { duration, ...variability ? { variability } : {}, params: /* @__PURE__ */ new Set() });
+  }
+  noteParamUse(kind, id) {
+    const cur = this.specUse.get(kind);
+    if (cur) cur.params.add(id);
+    else this.specUse.set(kind, { duration: "default", params: /* @__PURE__ */ new Set([id]) });
+  }
+  /**
+   * 시뮬 명세 자기보고 — **어디까지 데이터로 말했고 어디부터 우리가 박아 둔 상수인가.**
+   *
+   * 시뮬레이션 결과를 받는 쪽이 이걸 봐야 한다: 소요시간이 전부 기본값이면 그 예측으로 말할 수 있는 것은
+   * "같은 조건에서의 상대 비교" 뿐이고 "몇 시에 끝난다" 는 근거가 없다. 그 구분을 숫자로 드러낸다.
+   */
+  specCoverage() {
+    const operations = [...this.specUse.entries()].map(([kind, u]) => {
+      const spec = this.operationSpecs.get(kind);
+      const variability = u.variability ?? spec?.variability?.distribution;
+      return {
+        kind,
+        duration: u.duration,
+        ...variability ? { variability } : {},
+        parameters: [...u.params].sort()
+      };
+    });
+    return {
+      operations,
+      measuredDurations: operations.filter((o) => o.duration === "measured").length,
+      declaredDurations: operations.filter((o) => o.duration === "declared").length,
+      defaultDurations: operations.filter((o) => o.duration === "default").length
+    };
   }
   /** skuMix 에서 weight 로 gtin 선택(rng) — 도착/오더 자극의 품목 결정. */
   pickGtin(mix) {
@@ -1250,6 +1896,53 @@ var FlowEngine = class {
       bizTransactionList: opts.bizTransactionList
     }));
   }
+  /**
+   * 할당(예약) — **처분 변화를 이벤트로 낸다.**
+   *
+   * 예전에는 네 곳(WMS·YMS·MES 두 경로)이 각자 `disposition = reserved` 로 상태만 바꾸고 거래
+   * 이벤트(TransactionEvent)만 냈다. 거래 이벤트는 **처분을 싣지 않으므로** 미러는 그 물건이 잡혔다는
+   * 사실을 영영 알 수 없었다(적합성 하네스가 잡았다). 저널로 복원해도, 예측 씨앗에도 안 실린다.
+   *
+   * 관측 이벤트로 낸다 — 표준이 처분 변화를 표현하는 자리다(ObjectEvent OBSERVE + disposition).
+   * 물건이 여러 자리에 흩어져 있으면 **자리별로 나눠** 낸다(한 이벤트에 한 readPoint 가 맞다).
+   *
+   * `bizStep` 은 **호출부가 정한다.** 할당 자체를 가리키는 CBV 단계(reserving)를 1차 출처로 확인하지
+   * 못했으므로 어휘를 발명하지 않고, 그 할당이 속한 업무 단계를 그대로 쓴다.
+   */
+  reserve(epcs, bizStep) {
+    this.observeDisposition(epcs, DISP.reserved, bizStep);
+  }
+  /**
+   * 처분 변화 관측 — **상태와 이벤트를 한 번에.** 둘을 따로 쓰면 반드시 갈라진다.
+   *
+   * 실제로 양쪽으로 갈라져 있었다: 할당은 상태만 바꾸고 이벤트를 안 냈고(미러가 모름), 야드 도크
+   * 도착은 이벤트만 내고 상태를 안 바꿨다(이벤트와 상태가 다른 말). 적합성 하네스가 둘 다 잡았다.
+   *
+   * 물건이 여러 자리에 있으면 자리별로 나눠 낸다(한 이벤트에 한 readPoint 가 맞다).
+   * 이미 그 처분이면 아무 일도 하지 않는다(같은 사실을 두 번 말하지 않는다).
+   */
+  observeDisposition(epcs, disposition, bizStep, at) {
+    const byLocation = /* @__PURE__ */ new Map();
+    for (const epc of epcs) {
+      const it = this.items.get(epc);
+      if (!it || it.disposition === disposition) continue;
+      it.disposition = disposition;
+      const where = at ?? it.location ?? "";
+      const bin = byLocation.get(where);
+      if (bin) bin.push(epc);
+      else byLocation.set(where, [epc]);
+    }
+    for (const [where, list] of byLocation) {
+      this.emit(objectEvent({
+        eventTime: this.now(),
+        action: "OBSERVE",
+        bizStep,
+        disposition,
+        epcList: list,
+        ...where ? { readPoint: where, bizLocation: where } : {}
+      }));
+    }
+  }
   /**
    * containment 조립(EPCIS AggregationEvent ADD) — 자식들을 부모(용기)로 집約.
    * consume 지정 시 자식이 컨테이너로 흡수되며 독립 아이템에서 이탈(dematerialize: ObjectEvent DELETE + 제거).
@@ -1267,6 +1960,11 @@ var FlowEngine = class {
           this.items.delete(c);
         }
       }
+      return;
+    }
+    for (const c of children) {
+      const it = this.items.get(c);
+      if (it) it.parent = parent;
     }
   }
   /**
@@ -1276,6 +1974,10 @@ var FlowEngine = class {
    */
   disaggregate(parent, children, opts) {
     this.emit(aggregationEvent({ eventTime: this.now(), action: "DELETE", bizStep: opts.bizStep, parentID: parent, childEPCs: children.slice(), readPoint: opts.readPoint }));
+    for (const c of children) {
+      const it = this.items.get(c);
+      if (it) it.parent = void 0;
+    }
     if (opts.materialize) {
       const m = opts.materialize;
       for (const c of children) {
@@ -1316,19 +2018,239 @@ var FlowEngine = class {
     const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, data };
     for (const h of this.handlers) h(e);
   }
+  /**
+   * 작업 전이 방출 — **커널이 아는 것을 미러도 알게** 한다.
+   *
+   * 예전에는 진척·남은 시간·의도를 싣지 않아, 미러 상태를 씨앗으로 한 예측이 "진행 중인 일이 없는
+   * 현장" 에서 출발했고, 소비처는 무자원 체류를 기록 누락으로 오해할 수밖에 없었다.
+   * 진척은 진행 중일 때만 뜻이 있으므로 그때만 싣는다(생성·완료 시점의 0/1 은 노이즈).
+   */
   emitTask(t) {
-    this.emitOp(OP_EVENT.task, { taskId: t.id, orderId: t.orderId, kind: t.kind, status: t.status, fromNode: t.fromNode, toNode: t.toNode, itemRefs: [t.itemEpc], resourceRef: t.resource ?? void 0 });
+    const inProgress = t.status === "in-progress";
+    const done = Math.max(0, (t.durationMs ?? 0) - (t.remainingMs ?? 0));
+    this.emitOp(OP_EVENT.task, {
+      taskId: t.id,
+      orderId: t.orderId,
+      kind: t.kind,
+      status: t.status,
+      fromNode: t.fromNode,
+      toNode: t.toNode,
+      itemRefs: [t.itemEpc],
+      resourceRef: t.resource ?? void 0,
+      intent: t.intent,
+      ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
+      ...t.assets?.length ? { assets: t.assets.slice() } : {},
+      ...t.durationMs ? { durationMs: t.durationMs } : {},
+      ...inProgress ? { remainingMs: t.remainingMs, startedAtSimMs: t.startedAtSimMs, progress: t.durationMs ? done / t.durationMs : void 0 } : {}
+    });
+  }
+  /** 사람 상태 전이 — 설비와 별개 채널(어휘가 다르다: 고장이 아니라 교대·투입). */
+  emitAsset(a) {
+    this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClass: a.assetClass, status: a.status, location: a.location, taskId: a.taskId ?? void 0, carrying: a.carrying });
   }
+  emitPerson(p) {
+    this.emitOp(OP_EVENT.person, { personId: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? void 0, ...this.personOffShift(p) ? { offShift: true } : {} });
+  }
+  /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
+   *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
   emitMover(m, motion) {
-    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, motion });
+    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? void 0, motion });
   }
   emitOrder(o) {
     this.emitOp(OP_EVENT.order, { orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held });
   }
   // ── 내부 mechanics ─────────────────────────────────────────────────────────
+  /**
+   * 자극 간격 — **계약이 선언한 네 분포를 실제로 판정한다.**
+   *
+   * 예전에는 `poisson` 만 구현하고 나머지는 전부 상수로 떨어졌다. 계약이 `uniform`·`profile` 을
+   * 선언하고 있었으므로, 그것을 지정한 사람은 자기가 요청한 분포로 도는 줄 알았다 — **조용한 거짓**이다.
+   *
+   *  constant  간격이 일정(평균 그대로)
+   *  poisson   무기억 도착(지수 간격) — 평균 유지
+   *  uniform   0..2×평균 균등 — 평균을 유지하면서 흔들린다(교과서적 U(0,2μ))
+   *  profile   시간대별 배율(`profile[시]`)로 도착률을 조절 — 하루 안의 수요 곡선
+   */
   intervalMs(spec) {
-    const base = 36e5 / spec.rate.meanPerHour;
-    return spec.rate.distribution === "poisson" ? -Math.log(1 - this.rng()) * base : base;
+    const perHour = spec.rate.meanPerHour * this.profileFactor(spec.rate);
+    if (!(perHour > 0)) return Number.POSITIVE_INFINITY;
+    const base = 36e5 / perHour;
+    switch (spec.rate.distribution) {
+      case "poisson":
+        return -Math.log(1 - this.rng()) * base;
+      case "uniform":
+        return this.rng() * 2 * base;
+      case "profile":
+      case "constant":
+      default:
+        return base;
+    }
+  }
+  /**
+   * 시간대 배율 — `profile[시]`. `profile` 분포일 때만 적용하며, 배열이 짧으면 **순환**한다
+   * (24개면 하루, 8개면 8시간 주기). 미지정·다른 분포면 1(무영향).
+   * 시(hour)는 **시뮬 시각 자신의 프레임**(BASE_EPOCH 기준 UTC)이다 — 계약에 표준시가 없으므로
+   * 현지 시간대 해석은 아직 하지 않는다(꾸미지 않는다).
+   */
+  /**
+   * 다음 발화 시각 — **발화가 없는 시간대를 영원한 침묵으로 만들지 않는다.**
+   *
+   * 배율 0(그 시간대 도착 없음)이면 간격이 무한이 된다. 그것을 그대로 예약하면 이후 어떤 시간대가
+   * 와도 깨어나지 않는다 — 그래서 **다음 정시로 미뤄 다시 판정**한다(시간대가 바뀌면 배율도 바뀐다).
+   * 시나리오 시작과 구동 루프가 같은 규칙을 쓰도록 한 곳에 둔다(예전에는 시작 경로만 따로였다).
+   */
+  nextFireMs(spec, from) {
+    const interval = this.intervalMs(spec);
+    if (Number.isFinite(interval)) return from + interval;
+    const hourMs = 36e5;
+    return Math.floor(from / hourMs) * hourMs + hourMs;
+  }
+  profileFactor(rate) {
+    if (rate.distribution !== "profile") return 1;
+    const p = rate.profile;
+    if (!p?.length) return 1;
+    const f = p[this.hourOfDay() % p.length];
+    return Number.isFinite(f) && f >= 0 ? f : 1;
+  }
+  /**
+   * 필요 물리 자산을 확보한다 — 인원과 **같은 규칙**(등급으로 요구, 부분 투입 없음, 확정은 나중).
+   * 자산은 사람과 달리 교대가 없고 **자리**가 있다(빈 팔레트가 어디 있는지가 다음 문제이지만,
+   * 지금은 자리를 따지지 않는다 — 따지려면 자산 이송 작업이 먼저 있어야 한다).
+   */
+  claimAssets(t) {
+    const need = this.operationSpecs.get(t.kind)?.physicalAssetSpecification;
+    if (!need?.length) return [];
+    const picked = [];
+    for (const req of need) {
+      const want = Math.max(0, Math.floor(req.quantity ?? 0));
+      if (!want) continue;
+      const avail = [...this.assets.values()].filter(
+        (a) => a.status === "idle" && !picked.includes(a.id) && (req.assetClass === void 0 || a.assetClass === req.assetClass)
+      );
+      if (avail.length < want) return null;
+      for (let i = 0; i < want; i++) picked.push(avail[i].id);
+    }
+    return picked;
+  }
+  /** 확보한 자산을 작업에 묶는다 — 싣는 물류단위(SSCC)가 있으면 연결한다(GRAI ↔ SSCC). */
+  assignAssets(t, gear) {
+    if (!gear.length) return;
+    t.assets = gear;
+    for (const id of gear) {
+      const a = this.assets.get(id);
+      if (!a) continue;
+      a.status = "in-use";
+      a.taskId = t.id;
+      if (t.itemEpc) {
+        a.carrying = t.itemEpc;
+        const it = this.items.get(t.itemEpc);
+        if (it) it.carriedBy = a.id;
+      }
+      this.emitAsset(a);
+    }
+  }
+  /**
+   * 작업이 끝나면 자산을 놓아 준다 — **사람과 다른 점: 자산은 도착 자리에 남는다**(물건이므로).
+   * 싣고 있던 것은 놓는다(빈 팔레트로 돌아간다 — 회수·재사용의 출발점).
+   */
+  releaseAssets(t) {
+    for (const id of t.assets ?? []) {
+      const a = this.assets.get(id);
+      if (!a) continue;
+      a.status = "idle";
+      a.taskId = null;
+      a.location = t.toNode || a.location;
+      if (a.carrying) {
+        const it = this.items.get(a.carrying);
+        if (it) it.carriedBy = void 0;
+      }
+      a.carrying = void 0;
+      this.emitAsset(a);
+    }
+  }
+  /**
+   * 필요 인원을 확보한다 — **등급으로 요구하고 등급으로 고른다**(특정인 지목이 아니다).
+   * 요구가 없으면 빈 배열, 모자라면 `null`(작업은 기다린다 — **부분 투입으로 시작하지 않는다**).
+   * 여기서는 고르기만 하고 잡지 않는다: 설비까지 확보된 뒤 `assignCrew` 가 확정한다
+   * (반쯤 잡고 실패하면 사람이 아무 일도 못 하면서 묶인다).
+   */
+  claimPersonnel(t) {
+    const need = this.operationSpecs.get(t.kind)?.personnelSpecification;
+    if (!need?.length) return [];
+    const picked = [];
+    for (const req of need) {
+      const want = Math.max(0, Math.floor(req.quantity ?? 0));
+      if (!want) continue;
+      const avail = [...this.persons.values()].filter(
+        (p) => p.status === "idle" && !picked.includes(p.id) && !this.personOffShift(p) && (req.personnelClass === void 0 || p.personnelClass === req.personnelClass)
+      );
+      if (avail.length < want) return null;
+      for (let i = 0; i < want; i++) picked.push(avail[i].id);
+    }
+    return picked;
+  }
+  /** 확보한 사람을 작업에 묶는다(설비까지 확정된 뒤). */
+  assignCrew(t, crew) {
+    if (!crew.length) return;
+    t.personnel = crew;
+    for (const id of crew) {
+      const p = this.persons.get(id);
+      if (!p) continue;
+      p.status = "busy";
+      p.taskId = t.id;
+      this.emitPerson(p);
+    }
+  }
+  /** 작업이 끝나면 사람을 놓아 준다 — 설비 해제와 별개 경로. */
+  releaseCrew(t) {
+    for (const id of t.personnel ?? []) {
+      const p = this.persons.get(id);
+      if (!p) continue;
+      p.status = "idle";
+      p.taskId = null;
+      this.emitPerson(p);
+    }
+  }
+  /** 사람의 교대 판정 — 자원(offShift)과 같은 규칙. */
+  personOffShift(p) {
+    const w = p.window;
+    if (!w) return false;
+    const h = this.hourOfDay();
+    return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+  }
+  /**
+   * 이 자리가 동시 처리 한도에 찼는가 — `parallelism` 을 선언한 자리만 판정한다(미선언=제약 없음).
+   * 세는 대상은 **그 자리에서 진행 중인 작업**(`toNode` 기준, in-progress). 대기 중인 작업은 세지 않는다.
+   */
+  stationFull(nodeId) {
+    if (!nodeId) return false;
+    const limit = this.nodes.get(nodeId)?.parallelism;
+    if (!(typeof limit === "number" && limit > 0)) return false;
+    let running = 0;
+    for (const t of this.tasks.values()) if (t.status === "in-progress" && t.toNode === nodeId) running++;
+    return running >= limit;
+  }
+  /** 교대 밖인가 — 자원이 지금 일하지 않는 이유 중 고장·계획정지와 구별되는 세 번째. */
+  offShift(m) {
+    const w = m.window;
+    if (!w) return false;
+    const h = this.hourOfDay();
+    return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+  }
+  /** 시뮬 시각의 시(0..23) — 운영시간·시간대 배율의 기준. */
+  hourOfDay() {
+    return new Date(BASE_EPOCH + this.clockMs).getUTCHours();
+  }
+  /**
+   * 운영시간 안인가 — `window {startHour, endHour}`. **선언만 되고 소비처가 없던 필드**를 판정한다.
+   * `startHour <= endHour` 면 같은 날 구간, 넘어가면 자정을 가로지르는 구간(야간 교대: 22→6).
+   * 미지정이면 언제나 참(24시간 가동).
+   */
+  inWindow(spec) {
+    const w = spec.window;
+    if (!w) return true;
+    const h = this.hourOfDay();
+    return w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour;
   }
   /** 지수분포 표본(고장/수리 간격) — mean 을 평균으로 하는 무기억 프로세스. */
   sampleExp(meanMs) {
@@ -1363,32 +2285,89 @@ var FlowEngine = class {
       }
     }
   }
+  /**
+   * 물품 상태 산출 — **보유값 + 식별자에서 나오는 파생값.**
+   *
+   * 품번 키(`gtinKey`)·로트(`lot`)는 식별자의 순수 함수라 저장하지 않고 여기서 낸다. 투영기와 **같은
+   * 규칙**(`parseEpc`)을 쓴다 — 두 구동이 같은 식별자를 다르게 뜯으면 같은 사실이 다르게 보인다.
+   * 로트는 LGTIN 이면 식별자 안에 있고, 직렬 개체는 마스터데이터(`ilmd`)에 실려 온다.
+   */
+  itemState(i) {
+    const parsedClass = i.gtin ? parseEpc(i.gtin) : void 0;
+    const parsedSelf = parseEpc(i.epc);
+    const lot = parsedClass?.lot ?? parsedSelf.lot ?? (typeof i.ilmd?.[ILMD_ATTR.lot] === "string" ? i.ilmd[ILMD_ATTR.lot] : void 0);
+    const gtinKey = parsedClass?.gtinKey ?? parsedSelf.gtinKey;
+    return {
+      epc: i.epc,
+      ...i.gtin ? { gtin: i.gtin } : {},
+      ...gtinKey ? { gtinKey } : {},
+      ...lot ? { lot } : {},
+      location: i.location,
+      ...i.disposition ? { disposition: i.disposition } : {},
+      ...i.parent ? { parent: i.parent } : {},
+      ...i.carriedBy ? { carriedBy: i.carriedBy } : {},
+      ...i.qty !== void 0 ? { qty: i.qty } : {},
+      ...i.uom ? { uom: i.uom } : {},
+      ...i.expiry !== void 0 ? { expiry: i.expiry } : {},
+      ...i.ilmd ? { ilmd: i.ilmd } : {}
+    };
+  }
   progressOf(t) {
     return t.durationMs <= 0 ? 1 : Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs));
   }
   generate() {
     for (const g of this.gens) {
       while (this.clockMs >= g.nextMs) {
+        const next = this.nextFireMs(g.spec, g.nextMs);
+        if (this.intervalMs(g.spec) === Number.POSITIVE_INFINITY) {
+          g.nextMs = next;
+          continue;
+        }
+        if (!this.inWindow(g.spec)) {
+          g.nextMs = next;
+          continue;
+        }
         const stimulus = g.spec.stimulus ?? (g.spec.kind === "outbound-order" ? "order" : "arrival");
         if (stimulus === "order") this.onOrder(g.spec);
         else this.onArrival(g.spec);
-        g.nextMs += this.intervalMs(g.spec);
+        g.nextMs = next;
       }
     }
   }
   processOrders() {
     for (const o of this.orders.values()) if (o.status === "created" && !o.held) this.allocate(o);
   }
+  /**
+   * 작업 진행 — **진행을 먼저, 배정을 나중에.**
+   *
+   * 예전에는 배정을 먼저 하고 같은 tick 에서 곧바로 dt 만큼 깎았다. 그래서 이제 막 시작한 작업이
+   * 시작하자마자 한 스텝 진행된 것으로 계산됐고, **방출한 모션 앵커(startedAtSimMs)와 스냅샷이 한
+   * tick 어긋났다**(적합성 하네스가 잡았다). 스텝이 커질수록 오차도 커진다.
+   */
   processTasks(dt) {
+    this.advanceTasks(dt);
+    this.assignTasks();
+  }
+  assignTasks() {
     for (const t of this.tasks.values()) {
       if (t.status !== "created") continue;
+      const crew = this.claimPersonnel(t);
+      if (crew === null) continue;
+      const gear = this.claimAssets(t);
+      if (gear === null) continue;
       if (t.intent === "dwell") {
         t.status = "in-progress";
         t.remainingMs = t.durationMs;
+        t.startedAtSimMs = this.clockMs;
+        this.assignCrew(t, crew);
+        this.assignAssets(t, gear);
         this.emitTask(t);
         continue;
       }
-      const mover = [...this.movers.values()].find((m) => m.status === "idle" && !m.held && (t.resourceType === void 0 || m.kind === t.resourceType));
+      if (this.stationFull(t.toNode)) continue;
+      const mover = [...this.movers.values()].find(
+        (m) => m.status === "idle" && !m.held && !this.offShift(m) && (t.resourceType === void 0 || m.kind === t.resourceType)
+      );
       if (!mover) continue;
       if (t.setupMs && t.changeoverKey !== void 0 && mover.lastChangeoverKey !== void 0 && mover.lastChangeoverKey !== t.changeoverKey) {
         t.appliedSetupMs = t.setupMs;
@@ -1400,10 +2379,16 @@ var FlowEngine = class {
       t.status = "in-progress";
       t.resource = mover.id;
       t.remainingMs = t.durationMs;
+      t.startedAtSimMs = this.clockMs;
+      this.assignCrew(t, crew);
+      this.assignAssets(t, gear);
       this.emitTask(t);
       if (t.intent === "process") this.emitMover(mover);
       else this.emitMover(mover, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
     }
+  }
+  /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */
+  advanceTasks(dt) {
     for (const t of this.tasks.values()) {
       if (t.status !== "in-progress") continue;
       if (t.resource && this.movers.get(t.resource)?.status === "down") continue;
@@ -1411,6 +2396,8 @@ var FlowEngine = class {
       if (t.remainingMs > 0) continue;
       this.onTaskComplete(t);
       t.status = "completed";
+      this.releaseCrew(t);
+      this.releaseAssets(t);
       if (!t.resource) {
         this.emitTask(t);
         continue;
@@ -1450,11 +2437,23 @@ var WmsKernel = class extends FlowEngine {
     const qtyList = [{ epcClass: gtin, quantity: qty }];
     const poTxn = [{ type: BTT.po, bizTransaction: po }];
     const expiry = this.clockMs + SHELF_MS - this.epcSeq % 5 * SHELF_JITTER_MS;
-    this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry });
+    const ilmd = { [ILMD_ATTR.expiry]: expiry };
+    this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry, ilmd });
     dock.occupancy++;
     this.emit(transactionEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, bizTransactionList: poTxn, epcList: [epc], quantityList: qtyList, readPoint: dock.id }));
     this.emit(aggregationEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, parentID: epc, childQuantityList: qtyList, readPoint: dock.id }));
-    this.emit(objectEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, disposition: DISP.in_progress, epcList: [epc], quantityList: qtyList, readPoint: dock.id, bizLocation: dock.id, bizTransactionList: poTxn }));
+    this.emit(objectEvent({
+      eventTime,
+      action: "ADD",
+      bizStep: BIZSTEP.receiving,
+      disposition: DISP.in_progress,
+      epcList: [epc],
+      quantityList: qtyList,
+      readPoint: dock.id,
+      bizLocation: dock.id,
+      bizTransactionList: poTxn,
+      ilmd
+    }));
     const binId = this.policy.selectPlacement({ item: { epc, gtin, qty }, slots: this.slotViews("storage") });
     if (!binId) return;
     const id = `task-${++this.taskSeq}`;
@@ -1528,12 +2527,12 @@ var WmsKernel = class extends FlowEngine {
       const available = [...this.items.values()].filter((i) => i.gtin === line.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "storage").map((i) => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
       const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
       for (const epc of chosen) {
-        this.items.get(epc).disposition = DISP.reserved;
         o.allocated.push(epc);
         chosenAll.push(epc);
       }
     }
     if (chosenAll.length === 0) return;
+    this.reserve(chosenAll, BIZSTEP.storing);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: BIZSTEP.picking, bizTransactionList: [{ type: BTT.so, bizTransaction: o.bizTransaction }], epcList: chosenAll.slice() }));
     for (const epc of chosenAll) {
       const it = this.items.get(epc);
@@ -1677,7 +2676,7 @@ var YmsKernel = class extends FlowEngine {
       if (!staging || avail.length < CARGO_PER_TRAILER) return;
       this.trailerCargo.set(trailer.epc, avail.slice(0, CARGO_PER_TRAILER).map((i) => i.epc));
     }
-    trailer.disposition = DISP.reserved;
+    this.reserve([trailer.epc], bizStep);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep, bizTransactionList: [{ type: BTT_DELIVERY, bizTransaction: o.bizTransaction }], epcList: [trailer.epc], readPoint: door.id }));
     const dockKind = mode === "drop" ? "pull" : "spot-live";
     const task = { id: `task-${++this.taskSeq}`, kind: dockKind, status: "created", itemEpc: trailer.epc, fromNode: trailer.location, toNode: door.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: dockKind, fromNode: trailer.location, toNode: door.id }, TRAVEL_MS2), orderId: o.id };
@@ -1711,7 +2710,7 @@ var YmsKernel = class extends FlowEngine {
       const outbound = order2?.kind === "appointment-out";
       const staging = this.nodeByType("staging");
       const cargo = this.trailerCargo.get(trailer.epc) ?? [];
-      this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading, disposition: DISP.in_progress, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+      this.observeDisposition([trailer.epc], DISP.in_progress, outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading, to.id);
       if (outbound) {
         if (cargo.length && staging) {
           this.aggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.loading, readPoint: to.id, consume: { readPoint: staging.id, disposition: DISP.in_transit } });
@@ -1744,13 +2743,13 @@ var YmsKernel = class extends FlowEngine {
 };
 
 // src/mes-kernel.ts
-var CYCLE_MS = 4e4;
-var SETUP_MS = 15e3;
+var DEFAULT_CYCLE_MS = 4e4;
+var DEFAULT_SETUP_MS = 15e3;
 var MES_CMD = { changeover: "mes.changeover" };
 var CP2 = "0614141";
 var WIP_ITEMREF = "066666";
 var WIP_GTIN = sgtinClass(CP2, WIP_ITEMREF);
-var YIELD = 0.8;
+var DEFAULT_YIELD = 0.8;
 var PART_A = { itemRef: "055551", gtin: sgtinClass(CP2, "055551") };
 var PART_B = { itemRef: "055552", gtin: sgtinClass(CP2, "055552") };
 var PRODUCTS = [
@@ -1774,6 +2773,7 @@ var MesKernel = class extends FlowEngine {
   constructor(tenantId, policy = firstFitPolicy, mesSpec) {
     super(tenantId, policy);
     this.mesSpec = mesSpec;
+    if (mesSpec?.definition?.operations) this.loadOperations(mesSpec.definition.operations);
   }
   productOf(gtin) {
     return PRODUCTS.find((p) => p.gtin === gtin);
@@ -1781,7 +2781,7 @@ var MesKernel = class extends FlowEngine {
   /**
    * MES 도메인 커맨드(Tier 2) — mes.changeover: 설비를 제품 gtin 으로 강제 전환.
    * 자동 체인지오버(task.changeoverKey 상이 시 셋업)의 수동 버전 — 운영자가 사전 전환(툴링 교체) 지시.
-   * 이미 그 제품이면 no-op, 아니면 셋업(SETUP_MS, OEE 가용성 손실) + lastChangeoverKey 각인
+   * 이미 그 제품이면 no-op, 아니면 셋업(기본값, OEE 가용성 손실) + lastChangeoverKey 각인
    * (이후 그 제품 task 는 자동 셋업 생략). command → 변이 → State 델타(폐루프).
    */
   handleCommand(cmd) {
@@ -1791,7 +2791,7 @@ var MesKernel = class extends FlowEngine {
       const m = this.movers.get(a.resourceId);
       if (!m) return { commandId: cmd.commandId, accepted: false, errorCode: "resource-not-found", errorParams: { resourceId: a.resourceId }, error: `resource-not-found: ${a.resourceId}` };
       if (m.lastChangeoverKey !== a.gtin) {
-        m.setupMs += SETUP_MS;
+        m.setupMs += DEFAULT_SETUP_MS;
         m.lastChangeoverKey = a.gtin;
         this.emitMover(m);
       }
@@ -1836,10 +2836,8 @@ var MesKernel = class extends FlowEngine {
       if (chosen.length < line.qty) return;
       picks.push(...chosen);
     }
-    for (const epc of picks) {
-      this.items.get(epc).disposition = DISP.reserved;
-      o.allocated.push(epc);
-    }
+    for (const epc of picks) o.allocated.push(epc);
+    this.reserve(picks, MES_BIZSTEP.producing);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
     this.emitStation(o, s0, o.allocated[0], product.gtin);
     o.status = "op-" + s0.kind;
@@ -1848,7 +2846,7 @@ var MesKernel = class extends FlowEngine {
   /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(process), 이종 자원, 제품 전환 셋업. */
   emitStation(o, stage, itemEpc, changeoverKey) {
     const node = this.nodeByType(stage.node);
-    const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: node.id, toNode: node.id, resourceKind: stage.resource }, CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: SETUP_MS, intent: "process" };
+    const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: node.id, toNode: node.id, resourceKind: stage.resource }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: this.paramDuration(stage.kind, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: "process" };
     this.tasks.set(task.id, task);
     this.emitTask(task);
   }
@@ -1873,7 +2871,7 @@ var MesKernel = class extends FlowEngine {
     }
     const fgStore = this.nodeByType("fg-store");
     const wip = order.allocated[0];
-    const good = this.rng() < YIELD;
+    const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outputEpc = sgtinUri(CP2, product.ref, ++this.prodSeq);
@@ -1936,10 +2934,8 @@ var MesKernel = class extends FlowEngine {
       if (chosen.length < line.qty) return;
       picks.push(...chosen);
     }
-    for (const epc of picks) {
-      this.items.get(epc).disposition = DISP.reserved;
-      o.allocated.push(epc);
-    }
+    for (const epc of picks) o.allocated.push(epc);
+    this.reserve(picks, MES_BIZSTEP.producing);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
     this.emitStationDef(o, ops[0], o.allocated[0]);
     o.status = "op-" + ops[0].key;
@@ -1947,7 +2943,7 @@ var MesKernel = class extends FlowEngine {
   }
   emitStationDef(o, op, itemEpc) {
     const node = this.nodeByType(op.nodeType);
-    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: node.id, toNode: node.id, resourceKind: op.resourceType }, CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: SETUP_MS, intent: op.intent };
+    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: node.id, toNode: node.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
     this.tasks.set(task.id, task);
     this.emitTask(task);
   }
@@ -1974,7 +2970,7 @@ var MesKernel = class extends FlowEngine {
     }
     const fgStore = this.nodeByType("fg-store");
     const wip = order.allocated[0];
-    const good = this.rng() < YIELD;
+    const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outEpc = this.serialOf(rc.outputs[0].material, ++this.prodSeq);
@@ -2002,6 +2998,7 @@ var MesKernel = class extends FlowEngine {
   EPCIS_CONTEXT,
   EventJournal,
   FlowEngine,
+  ILMD_ATTR,
   MES_BIZSTEP,
   MES_NODE_TYPES,
   MES_PART_GTINS,
@@ -2009,7 +3006,10 @@ var MesKernel = class extends FlowEngine {
   MES_PRODUCT_GTINS,
   MES_TYPES,
   MesKernel,
+  NODE_SATURATION_NEAR,
   OP_EVENT,
+  OP_PARAM,
+  ObservedReducer,
   StateProjector,
   TwinHistory,
   TwinObserver,
@@ -2035,9 +3035,13 @@ var MesKernel = class extends FlowEngine {
   gdtiUri,
   graiUri,
   ingest,
+  lgtinClass,
   mapRecord,
   monteCarloForecast,
+  nodeStatusOf,
   objectEvent,
+  parseEpc,
+  parseIsoDuration,
   partialFitPolicy,
   replay,
   sgtinClass,