@operato/twin-kernel 0.3.0 → 0.4.1

package/dist-cjs/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   BTT_PRODORDER: () => BTT_PRODORDER,
   CAPABILITIES: () => CAPABILITIES,
   CAPABILITY_KEYS: () => CAPABILITY_KEYS,
+  CBV_BIZSTEP: () => CBV_BIZSTEP,
   CMD: () => CMD,
   DISP: () => DISP,
   DOMAIN_CATALOG: () => DOMAIN_CATALOG,
@@ -36,6 +37,7 @@ __export(index_exports, {
   GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
   LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
   MES_BIZSTEP: () => MES_BIZSTEP,
   MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
   MES_PART_GTINS: () => MES_PART_GTINS,
@@ -46,6 +48,7 @@ __export(index_exports, {
   OP_EVENT: () => OP_EVENT,
   OP_PARAM: () => OP_PARAM,
   ObservedReducer: () => ObservedReducer,
+  PRIORITY_UNSET: () => PRIORITY_UNSET,
   RETIRED_VOCABULARY: () => RETIRED_VOCABULARY,
   StateProjector: () => ObservedReducer,
   TwinHistory: () => TwinHistory,
@@ -60,43 +63,63 @@ __export(index_exports, {
   YMS_LOCATION_TYPES: () => YMS_LOCATION_TYPES,
   YMS_TYPES: () => YMS_TYPES,
   YmsKernel: () => YmsKernel,
+  activeShiftAt: () => activeShiftAt,
+  activeShiftOf: () => activeShiftOf,
   aggregationEvent: () => aggregationEvent,
+  analyzeCapacity: () => analyzeCapacity,
   capabilitiesForType: () => capabilitiesForType,
   classClosure: () => classClosure,
   compareStates: () => compareStates,
   computeOee: () => computeOee,
   constantDuration: () => constantDuration,
+  conversionFactorOf: () => conversionFactorOf,
   counterfactualAt: () => counterfactualAt,
   deriveAttentions: () => deriveAttentions,
+  dueStatusOf: () => dueStatusOf,
+  effectivityAt: () => effectivityAt,
   fefoPolicy: () => fefoPolicy,
   firstFitPolicy: () => firstFitPolicy,
+  foldJobResponses: () => foldJobResponses,
   foldTaskRecords: () => foldTaskRecords,
   gdtiUri: () => gdtiUri,
   graiUri: () => graiUri,
   hierarchyOf: () => hierarchyOf,
+  inWorkCalendar: () => inWorkCalendar,
+  inWorkCalendarAt: () => inWorkCalendarAt,
   ingest: () => ingest,
   isEquipmentLevel: () => isEquipmentLevel,
+  isoDurationHours: () => isoDurationHours,
+  itemKeyOf: () => itemKeyOf,
   lgtinClass: () => lgtinClass,
   locationStatusOf: () => locationStatusOf,
   mapRecord: () => mapRecord,
+  minuteOfDayAt: () => minuteOfDayAt,
   monteCarloForecast: () => monteCarloForecast,
   objectEvent: () => objectEvent,
+  offCalendarAt: () => offCalendarAt,
+  offCalendarReasonAt: () => offCalendarReasonAt,
   parseEpc: () => parseEpc,
   parseIsoDuration: () => parseIsoDuration,
   partialFitPolicy: () => partialFitPolicy,
+  priorityRank: () => priorityRank,
+  quantityIn: () => quantityIn,
   readBoardAssets: () => readBoardAssets,
   readBoardEquipment: () => readBoardEquipment,
   readBoardLocations: () => readBoardLocations,
   replay: () => replay,
+  replaySegments: () => replaySegments,
   retiredVocabularyIn: () => retiredVocabularyIn,
   sgtinClass: () => sgtinClass,
   sgtinUri: () => sgtinUri,
   ssccUri: () => ssccUri,
   stateFieldsOf: () => stateFieldsOf,
+  subLotIdOf: () => subLotIdOf,
   transactionEvent: () => transactionEvent,
   transformationEvent: () => transformationEvent,
   validateDomainDefinition: () => validateDomainDefinition,
-  validateEpcisEvent: () => validateEpcisEvent
+  validateEpcisEvent: () => validateEpcisEvent,
+  weekdayAt: () => weekdayAt,
+  workingTimeOfWeek: () => workingTimeOfWeek
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -185,17 +208,19 @@ function hierarchyOf(s) {
     }
   };
 }
+function effectivityAt(p, at) {
+  if (!p || !at) return void 0;
+  const atMs = Date.parse(at);
+  if (!Number.isFinite(atMs)) return void 0;
+  const from = p.effectiveStart ? Date.parse(p.effectiveStart) : NaN;
+  if (Number.isFinite(from) && atMs < from) return "not-yet";
+  const to = p.effectiveEnd ? Date.parse(p.effectiveEnd) : NaN;
+  if (Number.isFinite(to) && atMs > to) return "expired";
+  return void 0;
+}
 function classClosure(directIds, defs, at) {
   const byId = new Map((defs ?? []).map((d) => [d.id, d]));
-  const atMs = at ? Date.parse(at) : NaN;
-  const inWindow = (d) => {
-    if (!d || !Number.isFinite(atMs)) return true;
-    const from = d.effectiveStart ? Date.parse(d.effectiveStart) : NaN;
-    const to = d.effectiveEnd ? Date.parse(d.effectiveEnd) : NaN;
-    if (Number.isFinite(from) && atMs < from) return false;
-    if (Number.isFinite(to) && atMs > to) return false;
-    return true;
-  };
+  const inWindow = (d) => !d || effectivityAt(d, at) === void 0;
   const out = /* @__PURE__ */ new Set();
   const stack = [...directIds ?? []];
   while (stack.length) {
@@ -208,6 +233,155 @@ function classClosure(directIds, defs, at) {
   }
   return out;
 }
+var PRIORITY_UNSET = Number.POSITIVE_INFINITY;
+function priorityRank(p) {
+  return typeof p === "number" && Number.isFinite(p) ? p : PRIORITY_UNSET;
+}
+function dueStatusOf(x, nowIso) {
+  if (!x.endTime || !nowIso) return void 0;
+  const due = Date.parse(x.endTime);
+  const now = Date.parse(nowIso);
+  if (!Number.isFinite(due) || !Number.isFinite(now)) return void 0;
+  return now > due ? "late" : "on-time";
+}
+function subLotIdOf(classUri, location) {
+  return `${classUri}@${location}`;
+}
+function itemKeyOf(item) {
+  return item.subLotId ?? item.epc;
+}
+function quantityIn(item, uom, definitions) {
+  const hit = item.quantities?.find((q) => (q.uom ?? void 0) === (uom ?? void 0));
+  if (hit) return hit.value;
+  if ((item.uom ?? void 0) === (uom ?? void 0)) return item.qty;
+  return convertQuantity(item, uom, definitions);
+}
+var MATERIAL_PROPERTY = {
+  /** 기준 단위 하나당 이 단위의 양. `uom` 이 대상 단위. */
+  perBaseUnit: "perBaseUnit"
+};
+function conversionFactorOf(def, uom) {
+  if (!def || !uom) return void 0;
+  for (const p of def.properties ?? []) {
+    if (p.id !== MATERIAL_PROPERTY.perBaseUnit || p.uom !== uom) continue;
+    const n = typeof p.value === "number" ? p.value : Number(p.value);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return void 0;
+}
+function convertQuantity(item, uom, definitions) {
+  if (!definitions || !uom) return void 0;
+  if (typeof item.qty !== "number" || !Number.isFinite(item.qty)) return void 0;
+  if (item.uom) return void 0;
+  const def = definitions.get(item.definitionId ?? item.gtin ?? "");
+  const factor = conversionFactorOf(def, uom);
+  return factor === void 0 ? void 0 : item.qty * factor;
+}
+function minutesOfDay(hhmm) {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm ?? "");
+  if (!m) return void 0;
+  const h = Number(m[1]);
+  const mi = Number(m[2]);
+  if (h > 23 || mi > 59) return void 0;
+  return h * 60 + mi;
+}
+var isAbsolute = (e) => !!(e.startDateTime || e.finishDateTime);
+var needsDate = (e) => isAbsolute(e) || !!e.daysOfWeek?.length;
+function onDeclaredDay(e, minuteOfDay, weekday) {
+  if (!e.daysOfWeek?.length) return true;
+  const from = minutesOfDay(e.fromTime);
+  const to = minutesOfDay(e.toTime);
+  const crosses = from !== void 0 && to !== void 0 && from > to;
+  const startedDay = crosses && minuteOfDay < to ? (weekday + 6) % 7 : weekday;
+  return e.daysOfWeek.includes(startedDay);
+}
+function weekdayAt(ms2, utcOffsetMinutes) {
+  return new Date(ms2 + (utcOffsetMinutes ?? 0) * 6e4).getUTCDay();
+}
+function coversInstant(e, atMs) {
+  const from = e.startDateTime ? Date.parse(e.startDateTime) : NaN;
+  const to = e.finishDateTime ? Date.parse(e.finishDateTime) : NaN;
+  if (!Number.isFinite(from) && !Number.isFinite(to)) return false;
+  if (Number.isFinite(from) && atMs < from) return false;
+  if (Number.isFinite(to) && atMs >= to) return false;
+  return true;
+}
+function coversMinute(e, minuteOfDay) {
+  const from = minutesOfDay(e.fromTime);
+  const to = minutesOfDay(e.toTime);
+  if (from === void 0 || to === void 0) return false;
+  return from <= to ? minuteOfDay >= from && minuteOfDay < to : minuteOfDay >= from || minuteOfDay < to;
+}
+function inWorkCalendar(entries, minuteOfDay) {
+  return judgeCalendar(entries, (e) => coversMinute(e, minuteOfDay), false);
+}
+function inWorkCalendarAt(entries, atMs, utcOffsetMinutes) {
+  const minute = minuteOfDayAt(atMs, utcOffsetMinutes);
+  const day = weekdayAt(atMs, utcOffsetMinutes);
+  const covers = (e) => {
+    if (isAbsolute(e)) return coversInstant(e, atMs);
+    if (!coversMinute(e, minute)) return false;
+    return onDeclaredDay(e, minute, day);
+  };
+  return judgeCalendar(entries, covers, true);
+}
+function judgeCalendar(entries, covers, withAbsolute) {
+  if (!entries?.length) return true;
+  const usable = withAbsolute ? entries : entries.filter((e) => !needsDate(e));
+  if (!usable.length) return true;
+  const working = usable.filter((e) => (e.entryType ?? "working") === "working");
+  const off = usable.filter((e) => e.entryType === "non-working");
+  if (off.some(covers)) return false;
+  if (!working.length) return true;
+  return working.some(covers);
+}
+function activeShiftOf(entries, minuteOfDay) {
+  if (!entries?.length) return void 0;
+  if (!inWorkCalendar(entries, minuteOfDay)) return void 0;
+  for (const e of entries) {
+    if (needsDate(e) || (e.entryType ?? "working") !== "working" || !e.id) continue;
+    if (coversMinute(e, minuteOfDay)) return e.id;
+  }
+  return void 0;
+}
+function activeShiftAt(entries, atMs, utcOffsetMinutes) {
+  if (!entries?.length) return void 0;
+  if (!inWorkCalendarAt(entries, atMs, utcOffsetMinutes)) return void 0;
+  const minute = minuteOfDayAt(atMs, utcOffsetMinutes);
+  const day = weekdayAt(atMs, utcOffsetMinutes);
+  for (const e of entries) {
+    if (isAbsolute(e) || (e.entryType ?? "working") !== "working" || !e.id) continue;
+    if (!coversMinute(e, minute)) continue;
+    if (!onDeclaredDay(e, minute, day)) continue;
+    return e.id;
+  }
+  return void 0;
+}
+function minuteOfDayAt(ms2, utcOffsetMinutes) {
+  const d = new Date(ms2 + (utcOffsetMinutes ?? 0) * 6e4);
+  return d.getUTCHours() * 60 + d.getUTCMinutes();
+}
+function offCalendarReasonAt(r, ms2, utcOffsetMinutes) {
+  if (!offCalendarAt(r, ms2, utcOffsetMinutes)) return void 0;
+  const entries = r.workCalendar;
+  if (!entries?.length) return "off-hours";
+  const minute = minuteOfDayAt(ms2, utcOffsetMinutes);
+  const day = weekdayAt(ms2, utcOffsetMinutes);
+  for (const e of entries) {
+    if (e.entryType !== "non-working") continue;
+    const covered = isAbsolute(e) ? coversInstant(e, ms2) : coversMinute(e, minute) && onDeclaredDay(e, minute, day);
+    if (covered) return "non-working";
+  }
+  return "off-hours";
+}
+function offCalendarAt(r, ms2, utcOffsetMinutes) {
+  const minute = minuteOfDayAt(ms2, utcOffsetMinutes);
+  if (r.workCalendar?.length) return !inWorkCalendarAt(r.workCalendar, ms2, utcOffsetMinutes);
+  const w = r.window;
+  if (!w) return false;
+  const h = Math.floor(minute / 60);
+  return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+}
 var OP_EVENT = {
   task: "task.status",
   equipment: "equipment.status",
@@ -245,7 +419,7 @@ function readBoardLocations(def) {
 }
 function readBoardEquipment(def) {
   const d = def;
-  const list = d.equipment ?? d.equipmentList ?? [];
+  const list = d.equipment ?? d.equipmentList ?? d.movers ?? [];
   return list.map((e) => normalizeHomeLocation(e));
 }
 function normalizeHomeLocation(entry) {
@@ -326,8 +500,8 @@ function diffBy(predicted, actual, idOf, valOf) {
   return out.sort((x, y) => x.id.localeCompare(y.id));
 }
 function compareStates(predicted, actual) {
-  const itemLocation = diffBy(predicted.items, actual.items, (i) => i.epc, (i) => i.location);
-  const itemDisposition = diffBy(predicted.items, actual.items, (i) => i.epc, (i) => i.disposition);
+  const itemLocation = diffBy(predicted.items, actual.items, itemKeyOf, (i) => i.location);
+  const itemDisposition = diffBy(predicted.items, actual.items, itemKeyOf, (i) => i.disposition);
   const locationOccupancy = diffBy(predicted.locations, actual.locations, (n) => n.id, (n) => n.occupancy);
   const orderStatus = diffBy(predicted.orders, actual.orders, (o) => o.id, (o) => o.status);
   const hasDrift = itemLocation.length > 0 || itemDisposition.length > 0 || locationOccupancy.length > 0 || orderStatus.length > 0;
@@ -454,6 +628,12 @@ var DISP = {
   non_sellable: "urn:epcglobal:cbv:disp:non_sellable_other"
   // 불량/scrap
 };
+var CBV_BIZSTEP = {
+  /** 공정에 자재가 들어갔다 — ISA-95 `MaterialUse: Consumed`. */
+  consuming: "urn:epcglobal:cbv:bizstep:consuming",
+  /** 새 물품이 생겨 계보가 시작된다 — ISA-95 `MaterialUse: Produced`. */
+  commissioning: "urn:epcglobal:cbv:bizstep:commissioning"
+};
 function ssccUri(companyPrefix, serial) {
   return `urn:epc:id:sscc:${companyPrefix}.${String(serial).padStart(10, "0")}`;
 }
@@ -659,6 +839,12 @@ function validateEpcisEvent(e) {
 
 // src/observed-reducer.ts
 var UNKNOWN_TYPE = "unknown";
+function effectiveOf(r) {
+  return {
+    ...r?.effectiveStart ? { effectiveStart: r.effectiveStart } : {},
+    ...r?.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {}
+  };
+}
 var ObservedReducer = class {
   /** 로케이션 마스터 — 출처를 함께 들고 있다(마스터가 말한 자리 vs 관측으로 알게 된 자리). */
   master = /* @__PURE__ */ new Map();
@@ -675,11 +861,86 @@ var ObservedReducer = class {
   revision = 0;
   /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
   corrections = [];
+  /**
+   * 자원별 **교대 선언** — 미러가 "지금 근무 중인가" 를 스스로 판정하기 위한 재료.
+   *
+   * 상태(`EquipmentState`)에 넣지 않는다: 시뮬 스냅샷도 이것을 내보내지 않으므로 넣으면 두 구동이
+   * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
+   */
+  shifts = /* @__PURE__ */ new Map();
+  /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
+  utcOffsetMinutes;
   constructor(board) {
+    this.utcOffsetMinutes = board.utcOffsetMinutes;
     for (const n of readBoardLocations(board)) 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 readBoardEquipment(board)) this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, origin: "master" });
-    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {} });
-    for (const a of readBoardAssets(board)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {} });
+    for (const m of readBoardEquipment(board)) this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...effectiveOf(m), origin: "master" });
+    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...effectiveOf(p) });
+    for (const m of readBoardEquipment(board)) this.rememberShift(`eq:${m.id}`, m);
+    for (const p of board.persons ?? []) this.rememberShift(`person:${p.id}`, p);
+    for (const a of readBoardAssets(board)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...effectiveOf(a) });
+  }
+  /**
+   * **구조를 갈아탄다** — 관측된 사실은 지키고 토폴로지만 새 선언으로 바꾼다.
+   *
+   * 공장은 바뀐다. 도장 부스를 넷 더 놓고, 라인을 하나 접는다. 그런데 지금까지는 구조가 바뀌면
+   * **그 트윈의 저널을 통째로 지우는 것**이 유일한 길이었다 — 안 지우면 옛 이벤트를 새 공장에 대고
+   * 접게 되어 이력이 거짓말을 한다. 역사를 잃거나 거짓말을 하거나, 둘뿐이었다.
+   *
+   * 셋째 길이 이것이다: 이벤트가 **자기 구조를 달고** 다니고, 재생은 구조가 바뀌는 지점에서 여기를
+   * 불러 갈아탄 뒤 이어 접는다. 그러면 "그때 그 공장의 사실" 로 계속 읽힌다.
+   *
+   * ── 무엇을 지키고 무엇을 버리는가 ───────────────────────────────────────
+   * **관측은 지킨다** — 물품·오더·작업·집합은 구조와 무관한 사실이다(팔레트는 부스를 늘려도 그대로다).
+   * **사라진 자원은 버린다** — 없어진 설비의 상태를 계속 들고 있으면 화면이 없는 설비를 그린다.
+   * 다만 **몇 개를 버렸는지 돌려준다.** 조용히 사라지면 사용자는 수가 줄어든 것을 눈치채지 못한다.
+   *
+   * 관측으로 알게 된 자리(`origin: 'observed'`)는 **새 마스터에 없어도 남긴다** — 마스터가 모르는
+   * 자리에서 물건이 실제로 보였다는 사실은 구조를 바꾼다고 사라지지 않는다.
+   */
+  adoptStructure(board) {
+    this.utcOffsetMinutes = board.utcOffsetMinutes;
+    const locations = readBoardLocations(board);
+    const declaredLocationIds = new Set(locations.map((n) => n.id));
+    let locationsAdded = 0;
+    let locationsDropped = 0;
+    for (const [id, cur] of [...this.master]) {
+      if (declaredLocationIds.has(id) || cur.origin === "observed") continue;
+      this.master.delete(id);
+      locationsDropped++;
+    }
+    for (const n of locations) {
+      if (!this.master.has(n.id)) locationsAdded++;
+      this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: "master" });
+    }
+    const equipment = readBoardEquipment(board);
+    const assets = readBoardAssets(board);
+    const persons = board.persons ?? [];
+    const dropMissing = (map, declared) => {
+      const ids = new Set(declared.map((d) => d.id));
+      let dropped = 0;
+      for (const id of [...map.keys()]) if (!ids.has(id)) {
+        map.delete(id);
+        dropped++;
+      }
+      return dropped;
+    };
+    const equipmentDropped = dropMissing(this.equipment, equipment);
+    const personsDropped = dropMissing(this.persons, persons);
+    const assetsDropped = dropMissing(this.assets, assets);
+    for (const m of equipment) {
+      if (!this.equipment.has(m.id))
+        this.equipment.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, ...effectiveOf(m), origin: "master" });
+      this.rememberShift(`eq:${m.id}`, m);
+    }
+    for (const p of persons) {
+      if (!this.persons.has(p.id))
+        this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...effectiveOf(p) });
+      this.rememberShift(`person:${p.id}`, p);
+    }
+    for (const a of assets)
+      if (!this.assets.has(a.id))
+        this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...effectiveOf(a) });
+    return { locationsAdded, locationsDropped, equipmentDropped, personsDropped, assetsDropped };
   }
   /** 마스터 동기 — 로케이션 추가/변경/제거. */
   applyMaster(u) {
@@ -727,6 +988,7 @@ var ObservedReducer = class {
    */
   stale(key, e) {
     const at = Date.parse(String(e.eventTime ?? ""));
+    if (Number.isFinite(at) && (this.observedAtMs === void 0 || at > this.observedAtMs)) this.observedAtMs = at;
     if (!Number.isFinite(at)) return false;
     const recorded = Date.parse(String(e.data?.recordTime ?? ""));
     const seen = this.lastAt.get(key);
@@ -741,6 +1003,14 @@ var ObservedReducer = class {
   }
   /** 대상별 마지막 반영 시각 — 순서 판정용(대상=EPC·작업·설비·오더 id). */
   lastAt = /* @__PURE__ */ new Map();
+  /**
+   * **미러의 "지금"** — 지금까지 들은 것 중 가장 늦은 발생 시각.
+   *
+   * 미러는 스스로 시간을 굴리지 않지만, 시각으로만 일어나는 사실(유효 기간 만료)을 판정하려면 기준이
+   * 필요하다. 미러의 정직한 기준은 **"내가 마지막으로 들은 시점"** 이다. 아무것도 못 들었으면
+   * 판정하지 않는다(모르면 단정하지 않는다).
+   */
+  observedAtMs;
   /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
   apply(e) {
     this.revision++;
@@ -770,7 +1040,12 @@ var ObservedReducer = class {
           startedAtSimMs: d.startedAtSimMs,
           ...d.personnel?.length ? { personnel: d.personnel.slice() } : {},
           ...d.assets?.length ? { assets: d.assets.slice() } : {},
-          ...d.resources?.length ? { resources: d.resources.slice() } : {}
+          ...d.resources?.length ? { resources: d.resources.slice() } : {},
+          /* 실제 자재 이동 — 인원·설비와 같은 채널로 온다(실적을 한 곳에서 읽는다). */
+          ...d.materialActual?.length ? { materialActual: d.materialActual.map((r) => ({ ...r })) } : {},
+          ...d.priority !== void 0 ? { priority: d.priority } : {},
+          ...d.startTime ? { startTime: d.startTime } : {},
+          ...d.endTime ? { endTime: d.endTime } : {}
         });
         break;
       }
@@ -780,7 +1055,8 @@ var ObservedReducer = class {
         this.touchLocation(d.location);
         const known = this.equipment.get(d.moverId);
         const homeLocation = d.homeLocation ?? known?.homeLocation;
-        this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...homeLocation ? { homeLocation } : {}, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed" });
+        const eqPeriod = d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known);
+        this.equipment.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, ...homeLocation ? { homeLocation } : {}, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed", ...eqPeriod, ...d.held ? { held: true } : {} });
         break;
       }
       case OP_EVENT.person: {
@@ -795,7 +1071,11 @@ var ObservedReducer = class {
           ...d.location ?? known?.location ? { location: d.location ?? known?.location } : {},
           ...known?.properties ? { properties: known.properties } : {},
           ...known?.testSpecificationIds ? { testSpecificationIds: known.testSpecificationIds } : {},
-          ...d.offShift ? { offShift: true } : {}
+          /* 델타의 `offShift` 는 **선언이 없을 때만** 받는다 — 선언이 있으면 `snapshot()` 이 시각으로
+             판정하고, 저장값을 함께 두면 교대 안으로 돌아왔을 때 옛 `true` 가 남는다(두 출처 = 갈라짐).
+             남겨 두는 이유는 캘린더 없는 옛 저널 재생이다. */
+          ...d.offShift && !this.shifts.has(`person:${d.personId}`) ? { offShift: true } : {},
+          ...d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known)
         });
         break;
       }
@@ -809,7 +1089,8 @@ var ObservedReducer = class {
           location: d.location ?? cur?.location,
           status: d.status,
           taskId: d.taskId,
-          ...d.carrying ? { carrying: d.carrying } : {}
+          ...d.carrying ? { carrying: d.carrying } : {},
+          ...d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(cur)
         });
         this.touchLocation(d.location);
         break;
@@ -825,6 +1106,9 @@ var ObservedReducer = class {
           requested: d.requested,
           fulfilled: d.fulfilled,
           ...d.lines?.length ? { lines: d.lines.map((l) => ({ ...l })) } : {},
+          ...d.priority !== void 0 ? { priority: d.priority } : {},
+          ...d.startTime ? { startTime: d.startTime } : {},
+          ...d.endTime ? { endTime: d.endTime } : {},
           held: d.held
         });
         break;
@@ -877,15 +1161,19 @@ var ObservedReducer = class {
       return;
     }
     const loc = ev.readPoint?.id;
-    const q = ev.quantityList?.[0];
+    const all = ev.quantityList ?? [];
+    const q = all[0];
     this.touchLocation(loc);
     for (const epc of ev.epcList) {
       if (envelope && this.stale(`item:${epc}`, envelope)) continue;
-      this.items.set(epc, this.mergeItem(epc, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, q));
+      this.items.set(epc, this.mergeItem(epc, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, q, all));
     }
     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));
+        if (!qe?.epcClass) continue;
+        const mine = all.filter((x) => x.epcClass === qe.epcClass);
+        const subLotId = `${qe.epcClass}@${loc}`;
+        this.items.set(subLotId, this.mergeItem(qe.epcClass, { location: loc, disposition: ev.disposition, ilmd: ev.ilmd }, qe, mine, subLotId));
       }
     }
   }
@@ -908,13 +1196,14 @@ var ObservedReducer = class {
     }
     return void 0;
   }
-  mergeItem(epc, patch, q) {
-    const cur = this.items.get(epc);
+  mergeItem(epc, patch, q, all, subLotId) {
+    const cur = this.items.get(subLotId ?? 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,
+      ...subLotId ? { subLotId } : {},
       gtin: classUri ?? cur?.gtin,
       gtinKey: parsedClass?.gtinKey ?? parsedSelf.gtinKey ?? cur?.gtinKey,
       location: patch.location ?? cur?.location ?? "",
@@ -922,6 +1211,19 @@ var ObservedReducer = class {
       parent: cur?.parent ?? this.pendingParent.get(epc),
       qty: q?.quantity ?? cur?.qty,
       uom: q?.uom ?? cur?.uom,
+      /*
+       * 선언된 수량 전부 — 값이 없는 항목은 담지 않는다(모름을 0 으로 만들지 않는다).
+       *
+       * **한 항목뿐이면 담지 않는다.** 그 하나는 `qty`/`uom` 이 이미 무손실로 들고 있고, 1개짜리
+       * 배열을 더 두면 같은 사실이 두 곳에 생긴다(그리고 시뮬은 그 배열을 만들지 않아 두 구동이
+       * 갈라진다 — 적합성 하네스가 실제로 잡았다). `quantities` 의 뜻은 **추가 단위**다.
+       * 읽을 때는 단위를 가리지 않는 `quantityIn` 을 쓴다(단일이든 복수든 같은 답).
+       */
+      quantities: (() => {
+        const declared = (all ?? []).filter((x) => typeof x.quantity === "number");
+        if (declared.length < 2) return cur?.quantities;
+        return declared.map((x) => ({ value: x.quantity, ...x.uom ? { uom: x.uom } : {} }));
+      })(),
       /* 마스터데이터는 생겨날 때 한 번 정해진다 — 뒤 이벤트가 지우지 않게 기존 값을 남긴다. */
       ilmd: patch.ilmd ?? cur?.ilmd,
       expiry: this.expiryOf(patch.ilmd) ?? cur?.expiry,
@@ -939,6 +1241,47 @@ var ObservedReducer = class {
     }
   }
   /** 현재 투영 State — 자리 점유는 아이템 위치 집계로 유도(pure projection). */
+  /**
+   * 마지막으로 들은 발생 시각(ms) — **관측 구동의 "지금".**
+   *
+   * 시각으로만 바뀌는 사실(납기 초과·유효 기간·교대)을 판정하려면 기준이 필요하고, 관측 모드에는
+   * 굴러가는 시계가 없다. 정직한 기준은 "내가 마지막으로 들은 시점" 이다. 아무것도 못 들었으면
+   * `undefined` — 없는 기준으로 단정하지 않는다.
+   */
+  get lastObservedMs() {
+    return this.observedAtMs;
+  }
+  /** 선언된 교대만 기억한다 — 아무 선언이 없으면 키를 만들지 않는다(24시간 가용이 기존 거동). */
+  rememberShift(key, r) {
+    if (!r.workCalendar?.length && !r.window) return;
+    this.shifts.set(key, {
+      ...r.window ? { window: r.window } : {},
+      ...r.workCalendar?.length ? { workCalendar: r.workCalendar } : {}
+    });
+  }
+  /**
+   * 지금 근무 시간 밖인가 — 시뮬과 **같은 함수**(`offCalendarAt`)를 미러의 시각으로 부른다.
+   *
+   * 판정을 델타로 받지 않는 이유는 유효 기간과 같다: 교대 경계는 **이벤트 없이 시각만으로** 넘어가므로,
+   * 유휴 상태로 경계를 지난 자원은 실어 보낸 옛 판정에 머문다. 아무것도 못 들었으면 판정하지 않는다.
+   */
+  offShiftPart(key) {
+    const decl = this.shifts.get(key);
+    if (!decl || this.observedAtMs === void 0) return {};
+    if (offCalendarAt(decl, this.observedAtMs, this.utcOffsetMinutes)) {
+      const why = offCalendarReasonAt(decl, this.observedAtMs, this.utcOffsetMinutes);
+      return { offShift: true, ...why ? { offShiftReason: why } : {} };
+    }
+    const shift = activeShiftAt(decl.workCalendar, this.observedAtMs, this.utcOffsetMinutes);
+    return shift ? { shift } : {};
+  }
+  /** 유효 기간 밖이면 그 이유를 붙인다 — 미러의 시각 기준은 `observedAtMs`(마지막으로 들은 시점). */
+  effectivityPart(r) {
+    if (!r.effectiveStart && !r.effectiveEnd) return {};
+    if (this.observedAtMs === void 0) return {};
+    const e = effectivityAt(r, new Date(this.observedAtMs).toISOString());
+    return e ? { effectivity: e } : {};
+  }
   snapshot() {
     const occ = /* @__PURE__ */ new Map();
     for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
@@ -962,10 +1305,12 @@ var ObservedReducer = class {
       }),
       /* 들고 있는 것을 전부 내보낸다 — 축소하면 그 자리에서 정보가 사라진다. */
       items: [...this.items.values()].map((i) => ({ ...i })),
-      persons: [...this.persons.values()].map((p) => ({ ...p })),
-      assets: [...this.assets.values()].map((a) => ({ ...a })),
+      /* 유효 기간 판정은 **저장하지 않고 여기서 낸다** — 시뮬과 **같은 함수**(`effectivityAt`)를 부른다.
+         만료는 이벤트 없이 시각만으로 일어나므로, 델타로 받아 두면 유휴 자원이 영원히 유효하게 남는다. */
+      persons: [...this.persons.values()].map((p) => ({ ...p, ...this.effectivityPart(p), ...this.offShiftPart(`person:${p.id}`) })),
+      assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a) })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
-      equipment: [...this.equipment.values()].map((m) => ({ ...m })),
+      equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`) })),
       orders: [...this.orders.values()].map((o) => ({ ...o }))
     };
   }
@@ -993,8 +1338,8 @@ var EventJournal = class {
     return this.events.slice(revision);
   }
   /** sim 시각(ISO eventTime) 이하 이벤트. */
-  untilSimTime(iso) {
-    return this.events.filter((e) => e.eventTime <= iso);
+  untilSimTime(iso2) {
+    return this.events.filter((e) => e.eventTime <= iso2);
   }
 };
 function replay(board, events) {
@@ -1002,6 +1347,16 @@ function replay(board, events) {
   for (const e of events) proj.apply(e);
   return proj.snapshot();
 }
+function replaySegments(segments) {
+  if (!segments.length) throw new Error("\uC7AC\uC0DD\uD560 \uB9C8\uB514\uAC00 \uC5C6\uB2E4 \u2014 \uAD6C\uC870\uB97C \uD558\uB098\uB3C4 \uC8FC\uC9C0 \uC54A\uC558\uB2E4");
+  const proj = new ObservedReducer(segments[0].board);
+  const shifts = [];
+  for (let i = 0; i < segments.length; i++) {
+    if (i > 0) shifts.push({ index: i, ...proj.adoptStructure(segments[i].board) });
+    for (const e of segments[i].events) proj.apply(e);
+  }
+  return { state: proj.snapshot(), shifts };
+}
 
 // src/wms-profile.ts
 var BIZSTEP = {
@@ -1227,6 +1582,46 @@ function foldTaskRecords(rows) {
   return { records: [...byTask.values()], rowsRead, latestMs };
 }
 
+// src/job-response.ts
+var iso = (ms2) => typeof ms2 === "number" ? new Date(ms2).toISOString() : void 0;
+var dataOf = (r) => {
+  const p = r.payload;
+  return r.data ?? p?.data ?? p ?? {};
+};
+function foldJobResponses(rows) {
+  const { records } = foldTaskRecords(rows);
+  const extra = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const d = dataOf(r);
+    const id = typeof d.taskId === "string" ? d.taskId : void 0;
+    if (!id) continue;
+    const cur = extra.get(id) ?? {};
+    if (Array.isArray(d.personnel)) cur.personnel = d.personnel;
+    if (Array.isArray(d.resources)) cur.resources = d.resources;
+    else if (typeof d.resourceRef === "string" && !cur.resources) cur.resources = [d.resourceRef];
+    if (Array.isArray(d.assets)) cur.assets = d.assets;
+    if (Array.isArray(d.materialActual)) cur.material = d.materialActual;
+    extra.set(id, cur);
+  }
+  return records.map((rec) => {
+    const x = extra.get(rec.taskId) ?? {};
+    const jobState = rec.completedMs !== void 0 ? "completed" : rec.startedMs !== void 0 ? "running" : "ready";
+    const one = (ids) => ids?.length ? ids.map((id) => ({ id, quantity: 1 })) : void 0;
+    return {
+      id: rec.taskId,
+      ...rec.facets.order ? { jobOrderId: rec.facets.order } : {},
+      ...rec.facets.kind ? { workType: rec.facets.kind } : {},
+      jobState,
+      ...iso(rec.startedMs) ? { startTime: iso(rec.startedMs) } : {},
+      ...iso(rec.completedMs) ? { endTime: iso(rec.completedMs) } : {},
+      ...one(x.personnel) ? { personnelActual: one(x.personnel) } : {},
+      ...one(x.resources) ? { equipmentActual: one(x.resources) } : {},
+      ...one(x.assets) ? { physicalAssetActual: one(x.assets) } : {},
+      ...x.material?.length ? { materialActual: x.material.map((m) => ({ ...m })) } : {}
+    };
+  });
+}
+
 // src/face2-adapter.ts
 function get(obj, path) {
   return path.split(".").reduce((o, k) => o == null ? o : o[k], obj);
@@ -1327,8 +1722,108 @@ var TwinRuntime = class {
   }
 };
 
+// src/capacity.ts
+function isoDurationHours(iso2) {
+  if (!iso2) return 0;
+  const m = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?)?$/.exec(iso2);
+  if (!m) throw new Error(`\uAE30\uAC04 \uD45C\uAE30\uB97C \uC77D\uC744 \uC218 \uC5C6\uB2E4: ${iso2}`);
+  return Number(m[1] ?? 0) * 24 + Number(m[2] ?? 0) + Number(m[3] ?? 0) / 60 + Number(m[4] ?? 0) / 3600;
+}
+function paramOf(op, id) {
+  return op.parameters?.find((p) => p.id === id)?.value;
+}
+function workingTimeOfWeek(calendar, weekStartMs, utcOffsetMinutes) {
+  if (!calendar?.length) return { hoursPerWeek: 7 * 24, daysPerWeek: 7 };
+  let minutes = 0;
+  const touched = /* @__PURE__ */ new Set();
+  for (let m = 0; m < 7 * 24 * 60; m++) {
+    if (!inWorkCalendarAt(calendar, weekStartMs + m * 6e4, utcOffsetMinutes)) continue;
+    minutes++;
+    touched.add(Math.floor((m + (utcOffsetMinutes ?? 0)) / (24 * 60)));
+  }
+  const declared = /* @__PURE__ */ new Set();
+  for (const e of calendar) if (e.entryType !== "non-working") for (const d of e.daysOfWeek ?? []) declared.add(d);
+  return { hoursPerWeek: minutes / 60, daysPerWeek: declared.size || touched.size };
+}
+function availabilityOf(records) {
+  const ratios = records.map((r) => r.mtbfMs && r.mttrMs ? r.mtbfMs / (r.mtbfMs + r.mttrMs) : 1);
+  return ratios.length ? ratios.reduce((a, b) => a + b, 0) / ratios.length : 1;
+}
+function analyzeCapacity(input) {
+  const { hoursPerWeek, daysPerWeek } = workingTimeOfWeek(input.calendar, input.sampleWeekStartMs, input.utcOffsetMinutes);
+  const demandPerHour = hoursPerWeek > 0 ? input.unitsPerDay * daysPerWeek / hoursPerWeek : 0;
+  const equipmentByKind = /* @__PURE__ */ new Map();
+  for (const e of input.equipment ?? []) {
+    const list = equipmentByKind.get(e.kind) ?? [];
+    list.push(e);
+    equipmentByKind.set(e.kind, list);
+  }
+  const countByClass = (rows, field) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const r of rows ?? []) for (const c of r[field] ?? []) out.set(c, (out.get(c) ?? 0) + 1);
+    return out;
+  };
+  const personsByClass = countByClass(input.persons, "personnelClassIds");
+  const assetsByClass = countByClass(input.assets, "assetClassIds");
+  const slotsByLocationType = /* @__PURE__ */ new Map();
+  for (const l of input.locations ?? [])
+    if (l.type) slotsByLocationType.set(l.type, (slotsByLocationType.get(l.type) ?? 0) + Math.max(l.capacity ?? 1, 1));
+  const order = input.route?.length ? input.route.map((k) => input.operations.find((o) => o.key === k)).filter((o) => !!o) : [...input.operations];
+  let downstream = 1;
+  const reversed = [];
+  for (const op of [...order].reverse()) {
+    const cycleHours = isoDurationHours(op.duration) + isoDurationHours(paramOf(op, "setupDuration"));
+    downstream *= Number(paramOf(op, "yield") ?? 1);
+    const requiredPerHour = downstream > 0 ? demandPerHour / downstream : Infinity;
+    const requirements = [];
+    const add = (axis, className, quantity, available, availability) => {
+      const q = Math.max(quantity, 1);
+      requirements.push({
+        axis,
+        className,
+        quantity: q,
+        available,
+        availability,
+        perHour: cycleHours > 0 ? Math.floor(available / q) / cycleHours * availability : Infinity
+      });
+    };
+    const equipSpecs = op.equipmentSpecification?.length ? op.equipmentSpecification.map((s) => ({ className: s.equipmentClass ?? op.resourceType ?? "", quantity: s.quantity })) : op.resourceType ? [{ className: op.resourceType, quantity: 1 }] : [];
+    for (const s of equipSpecs) {
+      if (!s.className) continue;
+      const records = equipmentByKind.get(s.className) ?? [];
+      add("equipment", s.className, s.quantity, records.length, availabilityOf(records));
+    }
+    for (const s of op.personnelSpecification ?? [])
+      if (s.personnelClass) add("personnel", s.personnelClass, s.quantity, personsByClass.get(s.personnelClass) ?? 0, 1);
+    for (const s of op.physicalAssetSpecification ?? [])
+      if (s.assetClass) add("asset", s.assetClass, s.quantity, assetsByClass.get(s.assetClass) ?? 0, 1);
+    if (op.locationType) add("location", op.locationType, 1, slotsByLocationType.get(op.locationType) ?? 0, 1);
+    const constraint = requirements.length ? requirements.reduce((a, b) => a.perHour <= b.perHour ? a : b) : void 0;
+    const perHour = constraint ? constraint.perHour : Infinity;
+    reversed.push({ operation: op.key, cycleHours, perHour, requiredPerHour, ok: perHour >= requiredPerHour, constraint, requirements });
+  }
+  const operations = reversed.reverse();
+  const tightest = operations.length ? operations.reduce((a, b) => a.perHour / a.requiredPerHour <= b.perHour / b.requiredPerHour ? a : b) : void 0;
+  const headroom = operations.length ? Math.min(...operations.map((o) => o.perHour / o.requiredPerHour)) : Infinity;
+  return {
+    workingHoursPerWeek: hoursPerWeek,
+    workingDaysPerWeek: daysPerWeek,
+    demandPerHour,
+    operations,
+    ...tightest ? { bottleneck: { operation: tightest.operation, axis: tightest.constraint?.axis, className: tightest.constraint?.className } } : {},
+    maxUnitsPerDay: input.unitsPerDay * headroom,
+    ok: operations.every((o) => o.ok)
+  };
+}
+
 // src/flow-engine.ts
 var BASE_EPOCH = Date.parse("2026-01-01T00:00:00Z");
+function effectiveOnly(r) {
+  return {
+    ...r.effectiveStart ? { effectiveStart: r.effectiveStart } : {},
+    ...r.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {}
+  };
+}
 function mulberry32(seed) {
   let a = seed >>> 0;
   const fn = () => {
@@ -1342,7 +1837,7 @@ function mulberry32(seed) {
   } });
   return fn;
 }
-function deriveAttentions(view, acked) {
+function deriveAttentions(view, acked, nowIso) {
   const out = [];
   for (const m of view.equipment) {
     if (m.status === "down") {
@@ -1377,6 +1872,30 @@ function deriveAttentions(view, acked) {
       }
     }
   }
+  const QUEUE_FLOOR = 5;
+  const shutdown = (view.equipment?.length ?? 0) > 0 && view.equipment.every((m) => m.offShift);
+  if (view.tasks?.length && !shutdown) {
+    const waiting = /* @__PURE__ */ new Map();
+    const working = /* @__PURE__ */ new Map();
+    for (const t of view.tasks) {
+      const bucket = t.status === "created" || t.status === "assigned" ? waiting : t.status === "in-progress" ? working : void 0;
+      if (bucket) bucket.set(t.kind, (bucket.get(t.kind) ?? 0) + 1);
+    }
+    for (const [operation, queued] of waiting) {
+      if (queued < QUEUE_FLOOR) continue;
+      const active = working.get(operation) ?? 0;
+      const ratio = queued / Math.max(active, 1);
+      if (active > 0 && ratio < 3) continue;
+      out.push({
+        id: `work-backlog:${operation}`,
+        kind: "work-backlog",
+        severity: active === 0 || ratio >= 6 ? "high" : "medium",
+        anchor: { operation },
+        params: { operation, queued, active, ratio: Math.round(ratio * 10) / 10 },
+        recommendedActions: [{ code: "advice.add-resource" }, { code: "advice.downstream-priority" }]
+      });
+    }
+  }
   for (const m of view.equipment) {
     const total = (m.goodCount ?? 0) + (m.scrapCount ?? 0);
     if (total >= 10) {
@@ -1406,6 +1925,21 @@ function deriveAttentions(view, acked) {
       suggestedAction: { code: "act.resume-order", command: CMD.orderResume, args: { orderId: o.id } }
     });
   }
+  for (const o of view.orders) {
+    if (o.status === "completed" || o.status === "fulfilled") continue;
+    if (dueStatusOf(o, nowIso) !== "late") continue;
+    const overdueMs = Date.parse(nowIso) - Date.parse(o.endTime);
+    out.push({
+      id: `late:${o.id}`,
+      kind: "order-late",
+      severity: overdueMs >= 36e5 ? "critical" : "high",
+      anchor: { orderId: o.id },
+      params: { orderId: o.id, endTime: o.endTime, overdueMs, ...o.priority !== void 0 ? { priority: o.priority } : {} },
+      /* 조치는 권고만 둔다 — 지연을 커널이 스스로 해소할 수단이 없다(자원을 늘리거나 우선순위를
+         올리는 것은 사람의 결정이다). 없는 조치를 만들어 붙이지 않는다. */
+      recommendedActions: [{ code: "advice.raise-priority" }, { code: "advice.add-resource" }]
+    });
+  }
   if (acked) {
     for (const a of out) if (acked.has(a.id)) a.state = "acknowledged";
   }
@@ -1438,6 +1972,11 @@ var FlowEngine = class {
   equipment = /* @__PURE__ */ new Map();
   /** 등급 정의(표준 `<X>Class`) — 상속·유효기간 판정의 재료. 선언 안 하면 비어 있고, 소속 그대로 판정한다. */
   classDefs = {};
+  /**
+   * 품목 정의 색인(표준 `MaterialDefinition`) — 단위 환산의 **유일한 근거**.
+   * 비어 있으면 환산하지 않는다(계수를 모르는데 값을 만들지 않는다).
+   */
+  materialDefs = /* @__PURE__ */ new Map();
   /** 사람 — 선언하지 않으면 빈 맵(인원 제약 없는 트윈, 기존 거동). */
   persons = /* @__PURE__ */ new Map();
   /** 물리 자산 — 선언하지 않으면 빈 맵(자산 제약 없는 트윈, 기존 거동). */
@@ -1485,11 +2024,12 @@ var FlowEngine = class {
   loadBoard(def) {
     this.boardDef = def;
     for (const n of readBoardLocations(def)) this.locations.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: "idle", parentId: n.parentId });
-    this.classDefs = { personnel: def.personnelClasses, equipment: def.equipmentClasses, asset: def.assetClasses };
-    for (const p of def.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", taskId: null, window: p.window, ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {} });
-    for (const a of readBoardAssets(def)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", taskId: null, ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {} });
+    this.classDefs = { personnel: def.personnelClasses, equipment: def.equipmentClasses, asset: def.assetClasses, material: def.materialClasses };
+    this.materialDefs = new Map((def.materialDefinitions ?? []).filter((d) => d?.id).map((d) => [d.id, d]));
+    for (const p of def.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", taskId: null, window: p.window, ...p.workCalendar ? { workCalendar: p.workCalendar } : {}, ...p.homeLocation ? { location: p.homeLocation } : {}, ...p.properties ? { properties: p.properties } : {}, ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {}, ...effectiveOnly(p) });
+    for (const a of readBoardAssets(def)) this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.homeLocation, status: "idle", taskId: null, ...a.properties ? { properties: a.properties } : {}, ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {}, ...effectiveOnly(a) });
     for (const m of readBoardEquipment(def)) {
-      const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
+      const eq = { id: m.id, kind: m.kind, location: m.homeLocation, homeLocation: m.homeLocation, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
       if (m.mtbfMs !== void 0) {
         eq.mtbfMs = m.mtbfMs;
         eq.mttrMs = m.mttrMs;
@@ -1519,20 +2059,38 @@ var FlowEngine = class {
    * 오더는 남은 데맨드(라인별 requested-fulfilled)를 'created' 로 복원(현재 재고에서 재계획).
    * 진행 중 개별 task 의 내부 상태는 관측만으론 복원 불가 → 재계획에 맡김(정직한 한계).
    */
+  /**
+   * **이어서 센다** — 재기동 뒤 저널을 이어 쓸 때.
+   *
+   * 커널은 리비전을 0부터 센다. 새로 시작하는 우주라면 맞지만, **이어지는 현실**(sim-world)에서는
+   * 그 번호가 이미 저널에 있는 행과 겹친다 — 같은 트윈에 revision 7이 두 개 생기고, 재생 순서가
+   * 뒤섞이며, 시간여행이 엉뚱한 시점을 답한다. 조용히 깨지는 종류다(오류가 안 난다).
+   *
+   * 그래서 이어 쓰기 전에 마지막 번호를 알려 준다. **뒤로는 못 간다** — 뒤로 가는 것은 곧 겹치는
+   * 것이고, 그것을 허용하면 이 함수가 막으려던 일이 이 함수를 통해 일어난다.
+   */
+  resumeRevision(from) {
+    if (!Number.isFinite(from) || from < 0) throw new Error(`\uC774\uC5B4 \uC140 \uB9AC\uBE44\uC804\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uB2E4: ${from}`);
+    if (from < this.revision) throw new Error(`\uB9AC\uBE44\uC804\uC744 \uB4A4\uB85C \uB418\uB3CC\uB9B4 \uC218 \uC5C6\uB2E4: ${this.revision} \u2192 ${from} (\uACB9\uCE58\uB294 \uBC88\uD638\uAC00 \uC0DD\uAE34\uB2E4)`);
+    this.revision = from;
+  }
   hydrateObserved(snap, orders = []) {
     for (const n of snap.locations) {
       this.locations.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, {
+      this.items.set(itemKeyOf(it), {
         /* 품번 키·로트는 식별자에서 파생되므로 심지 않는다(스냅샷이 다시 낸다 — 두 벌을 두면 어긋난다). */
         epc: it.epc,
         location: it.location,
         disposition: it.disposition ?? DISP.sellable,
+        ...it.subLotId ? { subLotId: it.subLotId } : {},
+        ...it.definitionId ? { definitionId: it.definitionId } : {},
         gtin: it.gtin,
         qty: it.qty ?? 1,
         uom: it.uom,
+        ...it.quantities?.length ? { quantities: it.quantities } : {},
         parent: it.parent,
         carriedBy: it.carriedBy,
         expiry: it.expiry,
@@ -1541,7 +2099,9 @@ var FlowEngine = class {
     }
     for (const m of snap.equipment) {
       const oee = m.oee;
+      const prev = this.equipment.get(m.id);
       this.equipment.set(m.id, {
+        ...prev ?? {},
         id: m.id,
         kind: m.kind,
         location: m.location ?? "",
@@ -1552,22 +2112,102 @@ var FlowEngine = class {
         setupMs: oee?.setupMs ?? 0,
         downMs: oee?.downMs ?? 0,
         goodCount: oee?.goodCount ?? 0,
-        scrapCount: oee?.scrapCount ?? 0
+        scrapCount: oee?.scrapCount ?? 0,
+        /* 계획 정지를 이어받는다 — 잃으면 씨앗이 **정비 중인 설비를 가용으로 놓고** 미래를 굴린다
+           (예측이 낙관 쪽으로 치우친다). 씨앗 왕복 대조가 이것을 잡았다. */
+        ...m.held ? { held: true } : {},
+        /* 관측 스냅샷이 들고 있는 것은 관측을 따른다(미러가 보드에서 읽어 실어 온다). */
+        ...m.properties ? { properties: m.properties } : {},
+        ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {},
+        ...effectiveOnly(m)
       });
     }
     for (const p of snap.persons ?? []) {
-      this.persons.set(p.id, { id: p.id, personnelClassIds: p.personnelClassIds, status: "idle", taskId: null });
+      const prev = this.persons.get(p.id);
+      this.persons.set(p.id, {
+        ...prev ?? {},
+        id: p.id,
+        personnelClassIds: p.personnelClassIds ?? prev?.personnelClassIds,
+        status: "idle",
+        taskId: null,
+        ...p.location ? { location: p.location } : {},
+        ...p.properties ? { properties: p.properties } : {},
+        ...p.testSpecificationIds ? { testSpecificationIds: p.testSpecificationIds } : {},
+        ...effectiveOnly(p)
+      });
     }
     for (const a of snap.assets ?? []) {
-      this.assets.set(a.id, { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: "idle", taskId: null, carrying: a.carrying });
+      const prev = this.assets.get(a.id);
+      this.assets.set(a.id, {
+        ...prev ?? {},
+        id: a.id,
+        assetClassIds: a.assetClassIds ?? prev?.assetClassIds,
+        location: a.location,
+        status: "idle",
+        taskId: null,
+        carrying: a.carrying,
+        ...a.properties ? { properties: a.properties } : {},
+        ...a.testSpecificationIds ? { testSpecificationIds: a.testSpecificationIds } : {},
+        ...effectiveOnly(a)
+      });
     }
+    const observedOrders = orders.length ? orders : (snap.orders ?? []).filter((o) => o.requested !== void 0).map((o) => ({
+      orderId: o.id,
+      kind: o.kind,
+      status: o.status,
+      requested: o.requested,
+      fulfilled: o.fulfilled ?? 0,
+      held: o.held,
+      lines: o.lines,
+      /* 약속한 시각과 우선순위를 함께 옮긴다 — 없으면 관측 커널이 **"늦었나" 를 판단할 재료가
+         없다.** 라이브 트윈이 납기 초과를 한 번도 보고하지 못한 원인 중 하나였다. */
+      ...o.endTime ? { endTime: o.endTime } : {},
+      ...o.startTime ? { startTime: o.startTime } : {},
+      ...o.priority !== void 0 ? { priority: o.priority } : {}
+    }));
+    for (const o of observedOrders) {
+      const lines = (o.lines ?? []).map((l) => ({ gtin: l.gtin, requested: l.requested - (l.fulfilled ?? 0) })).filter((l) => l.requested > 0);
+      const remaining = lines.length ? lines.reduce((s, l) => s + l.requested, 0) : Math.max(0, (o.requested ?? 0) - (o.fulfilled ?? 0));
+      if (remaining <= 0) continue;
+      this.orders.set(o.orderId, {
+        id: o.orderId,
+        kind: o.kind,
+        status: "created",
+        requested: remaining,
+        fulfilled: 0,
+        bizTransaction: "",
+        allocated: [],
+        picked: [],
+        shipmentEpc: null,
+        lines,
+        /* **보류를 이어받는다** — 잃으면 씨앗이 사람이 일부러 멈춘 오더를 다시 계획해 내보낸다.
+           씨앗 왕복 대조가 이것을 잡았다(그 전에는 사람이 코드를 읽어야만 알 수 있었다). */
+        ...o.held ? { held: true } : {},
+        ...o.endTime ? { endTime: o.endTime } : {},
+        ...o.startTime ? { startTime: o.startTime } : {},
+        ...o.priority !== void 0 ? { priority: o.priority } : {}
+      });
+    }
+    const seededOrderIds = new Set(this.orders.keys());
+    let orphaned = 0;
     for (const t of snap.tasks ?? []) {
       if (t.status === "completed") continue;
+      const ref = t.itemRefs?.[0];
+      if (ref && !this.itemByRef(ref)) {
+        orphaned++;
+        continue;
+      }
+      if (t.orderId && !seededOrderIds.has(t.orderId)) {
+        orphaned++;
+        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",
+        /* 이미 일어난 자재 이동은 **씨앗에도 남는다** — 잃으면 실적이 재기동마다 지워진다. */
+        ...t.materialActual?.length ? { materialActual: t.materialActual.map((r) => ({ ...r })) } : {},
         itemEpc: t.itemRefs?.[0] ?? "",
         fromNode: t.fromNode ?? "",
         toNode: t.toNode ?? "",
@@ -1597,12 +2237,10 @@ var FlowEngine = class {
         }
       }
     }
-    const observedOrders = orders.length ? orders : (snap.orders ?? []).filter((o) => o.requested !== void 0).map((o) => ({ orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled ?? 0, held: o.held, lines: o.lines }));
-    for (const o of observedOrders) {
-      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);
-      if (remaining <= 0) continue;
-      this.orders.set(o.orderId, { id: o.orderId, kind: o.kind, status: "created", requested: remaining, fulfilled: 0, bizTransaction: "", allocated: [], picked: [], shipmentEpc: null, lines });
+    if (orphaned) {
+      console.warn(
+        `[twin-kernel] seed skipped ${orphaned} in-flight task(s) whose item is no longer in state \u2014 they cannot be continued (the item was consumed/shipped, or the observation did not carry it).`
+      );
     }
   }
   /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
@@ -1633,6 +2271,15 @@ var FlowEngine = class {
    * State 델타를 유발한다(command → 행위 → 관측 폐루프).
    */
   _acked = /* @__PURE__ */ new Set();
+  /**
+   * 완료 시점에 **주체가 사라져 접은 작업 수** — 조용한 누락이 되지 않게 센다.
+   *
+   * 물품이 포장·출하·소비로 없어지는 것은 정상이지만, 그 물품을 향한 작업이 남아 있었다는 것은
+   * 상류에 어긋남이 있다는 신호다. 0 이 아니면 그 사실을 소비처가 볼 수 있어야 한다.
+   */
+  abandonedTasks = 0;
+  /** 주목 신호가 **처음 성립한 시각**(id → ISO). 조건이 사라지면 지운다 — 재발은 새 시작이다. */
+  _attentionSince = /* @__PURE__ */ new Map();
   // 확인(ack)된 주목 신호 id — 조건 지속돼도 acknowledged 로 표시(재발 시 재활성)
   dispatch(cmd) {
     const ok = () => ({ commandId: cmd.commandId, accepted: true });
@@ -1754,6 +2401,8 @@ var FlowEngine = class {
     return {
       revision: this.revision,
       simClockMs: this.clockMs,
+      nowTime: this.now(),
+      // 트윈의 "지금" — 관측 모드면 마지막으로 들은 시각(§nowMs)
       /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
        * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
       locations: [...this.locations.values()].map((n) => {
@@ -1763,7 +2412,7 @@ var FlowEngine = class {
       }),
       items: [...this.items.values()].map((i) => this.itemState(i)),
       equipment: [...this.equipment.values()].map((m) => {
-        const s = { id: m.id, kind: m.kind, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, origin: "master", ...this.offShift(m) ? { offShift: true } : {} };
+        const s = { id: m.id, kind: m.kind, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, ...m.properties ? { properties: m.properties } : {}, ...m.testSpecificationIds ? { testSpecificationIds: m.testSpecificationIds } : {}, origin: "master", ...this.offShift(m) ? { offShift: true, ...this.offReason(m) } : {}, ...this.effectivePart(m), ...this.shiftOf(m) ? { shift: this.shiftOf(m) } : {} };
         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;
@@ -1773,6 +2422,7 @@ var FlowEngine = class {
         if (a.carrying) st.carrying = a.carrying;
         if (a.properties) st.properties = a.properties;
         if (a.testSpecificationIds) st.testSpecificationIds = a.testSpecificationIds;
+        Object.assign(st, this.effectivePart(a));
         return st;
       }),
       persons: [...this.persons.values()].map((p) => {
@@ -1780,7 +2430,13 @@ var FlowEngine = class {
         if (p.location) st.location = p.location;
         if (p.properties) st.properties = p.properties;
         if (p.testSpecificationIds) st.testSpecificationIds = p.testSpecificationIds;
-        if (this.personOffShift(p)) st.offShift = true;
+        if (this.personOffShift(p)) {
+          st.offShift = true;
+          Object.assign(st, this.offReason(p));
+        }
+        const sh = this.shiftOf(p);
+        if (sh) st.shift = sh;
+        Object.assign(st, this.effectivePart(p));
         return st;
       }),
       /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
@@ -1800,7 +2456,11 @@ var FlowEngine = class {
         ...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() } : {},
-        ...t.resources?.length ? { resources: t.resources.slice() } : {}
+        ...t.resources?.length ? { resources: t.resources.slice() } : {},
+        ...t.materialActual?.length ? { materialActual: t.materialActual.map((r) => ({ ...r })) } : {},
+        ...t.priority !== void 0 ? { priority: t.priority } : {},
+        ...t.startTime ? { startTime: t.startTime } : {},
+        ...t.endTime ? { endTime: t.endTime } : {}
       })),
       orders: [...this.orders.values()].map((o) => ({
         id: o.id,
@@ -1810,6 +2470,9 @@ var FlowEngine = class {
         requested: o.requested,
         fulfilled: o.fulfilled,
         ...o.lines?.length ? { lines: o.lines.map((l) => ({ gtin: l.gtin, requested: l.requested })) } : {},
+        ...o.priority !== void 0 ? { priority: o.priority } : {},
+        ...o.startTime ? { startTime: o.startTime } : {},
+        ...o.endTime ? { endTime: o.endTime } : {},
         held: o.held
       })),
       attentions: this.computeAttentions()
@@ -1821,12 +2484,26 @@ var FlowEngine = class {
    * 도메인별 추가 판단은 서브클래스가 override 로 확장(super.computeAttentions() 합성).
    */
   computeAttentions() {
+    const now = this.now();
     const out = deriveAttentions(
-      { equipment: [...this.equipment.values()], locations: [...this.locations.values()], orders: [...this.orders.values()] },
-      this._acked
+      {
+        equipment: [...this.equipment.values()],
+        locations: [...this.locations.values()],
+        orders: [...this.orders.values()],
+        tasks: [...this.tasks.values()]
+      },
+      this._acked,
+      now
+      // 지연 판정의 "지금" — 관측 중이면 마지막으로 들은 시각이다(§nowMs)
     );
     const present = new Set(out.map((a) => a.id));
+    for (const a of out) {
+      const first = this._attentionSince.get(a.id) ?? now;
+      this._attentionSince.set(a.id, first);
+      a.timeStamp = first;
+    }
     for (const id of [...this._acked]) if (!present.has(id)) this._acked.delete(id);
+    for (const id of [...this._attentionSince.keys()]) if (!present.has(id)) this._attentionSince.delete(id);
     return out;
   }
   /**
@@ -1853,8 +2530,42 @@ var FlowEngine = class {
     return clone;
   }
   // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
+  /**
+   * 이 커널의 **지금**(ms) — 시각으로 바뀌는 모든 판정의 단일 기준.
+   *
+   * ── 관측 모드에서 시계가 멈춰 있었다 ────────────────────────────────────
+   * `apply()` 는 `clockMs` 를 밀지 않는다(관측은 시간을 굴리지 않는다). 그래서 라이브 트윈의 "지금" 이
+   * **BASE_EPOCH(2026-01-01)에 얼어 있었다.** 실 이벤트는 실제 시각을 달고 오므로 결과가 이렇게 된다:
+   *  · **납기 초과를 영원히 보고하지 않는다** — 실 납기가 항상 미래로 보인다
+   *  · 폐기·도입예정 판정이 틀린다(§EffectivePeriod)
+   *  · 교대 판정이 틀린다(§offCalendarAt)
+   * 셋 다 "시각으로만 바뀌는 사실" 이라 같은 결함이었다. 그래서 기준을 **한 곳**으로 모은다.
+   *
+   * 관측 중이면 **마지막으로 들은 발생 시각**을 쓴다(미러의 `lastObservedMs` 와 같은 기준 — 규칙 한 벌).
+   * 아직 아무것도 못 들었으면 시뮬 기준으로 떨어진다(그때는 판정할 사실도 없다).
+   */
+  nowMs() {
+    const observed = this.observeMode ? this.observer?.lastObservedMs : void 0;
+    return observed ?? BASE_EPOCH + this.clockMs;
+  }
   now() {
-    return new Date(BASE_EPOCH + this.clockMs).toISOString();
+    return new Date(this.nowMs()).toISOString();
+  }
+  /**
+   * 자극이 선언한 **약속**을 오더 필드로 — 표준 `OperationsRequest.Priority`·`StartTime`·`EndTime`.
+   *
+   * **base 에 한 곳만 둔다.** 오더를 만드는 곳이 도메인마다 있어(WMS 판매오더·MES 작업지시·YMS
+   * 어포인트먼트) 각자 계산하면 시간축이나 규약이 갈린다 — 실제로 한 번 갈렸다(납기를 `clockMs` 로
+   * 재고 `now()` 와 비교해 갓 만든 오더가 56년 늦은 것으로 판정됐다).
+   *
+   * 선언이 없으면 **빈 객체**를 준다 — 없는 약속을 만들지 않는다.
+   */
+  promiseOf(spec) {
+    const at = this.now();
+    return {
+      ...spec.priority !== void 0 ? { priority: spec.priority } : {},
+      ...spec.promisedLeadMinutes !== void 0 ? { startTime: at, endTime: new Date(Date.parse(at) + spec.promisedLeadMinutes * 6e4).toISOString() } : {}
+    };
   }
   randInt(min, max) {
     return max <= min ? min : min + Math.floor(this.rng() * (max - min + 1));
@@ -1906,6 +2617,41 @@ var FlowEngine = class {
   loadOperations(ops = []) {
     for (const o of ops) if (o?.key) this.operationSpecs.set(o.key, o);
   }
+  /**
+   * 라우트(공정 순서) — 수율을 거슬러 올릴 때 필요하다. 기본은 모른다(선언 순서를 쓴다).
+   * 생산 정의를 가진 커널이 override 해서 자기 라우트를 답한다.
+   */
+  routeKeys() {
+    return void 0;
+  }
+  /**
+   * **이 공장이 하루 몇 대를 낼 수 있는가** — 굴려 보지 않고 답한다.
+   *
+   * 커널이 직접 답하는 이유: 필요한 사실이 전부 여기 있다(공정 명세·설비와 신뢰도·인원·물리자산·
+   * 자리·근무 달력·시각 기준). 밖에서 모으면 그 값을 옮겨 적게 되고, 한쪽만 바뀌는 순간 "충분하다"
+   * 가 조용히 거짓이 된다. 계산 자체는 순수 함수(`analyzeCapacity`)에 맡긴다.
+   *
+   * 달력은 **자원이 선언한 것**을 쓴다. 자원마다 다른 달력을 쓰는 현장이면 대표를 고를 수 없으므로
+   * 그 사실을 결과에 실어 보낸다(`mixedCalendars`) — 조용히 하나를 골라 계산하면 천장이 틀린 채로
+   * 그럴듯해 보인다.
+   */
+  capacity(opts) {
+    const calendars = /* @__PURE__ */ new Map();
+    for (const m of this.equipment.values()) if (m.workCalendar?.length) calendars.set(JSON.stringify(m.workCalendar), m.workCalendar);
+    const analysis = analyzeCapacity({
+      operations: [...this.operationSpecs.values()],
+      ...this.routeKeys() ? { route: this.routeKeys() } : {},
+      equipment: [...this.equipment.values()].map((m) => ({ kind: m.kind, mtbfMs: m.mtbfMs, mttrMs: m.mttrMs })),
+      persons: [...this.persons.values()],
+      assets: [...this.assets.values()],
+      locations: [...this.locations.values()],
+      ...calendars.size === 1 ? { calendar: [...calendars.values()][0] } : {},
+      ...this.boardDef?.utcOffsetMinutes !== void 0 ? { utcOffsetMinutes: this.boardDef.utcOffsetMinutes } : {},
+      sampleWeekStartMs: opts.sampleWeekStartMs,
+      unitsPerDay: opts.unitsPerDay
+    });
+    return { ...analysis, mixedCalendars: calendars.size > 1 };
+  }
   /**
    * task 소요 산출 — 우선순위: **① 추정기(이력 보정) → ② 명세(ISA-95 Duration + 변동) → ③ 도메인 상수.**
    *
@@ -2015,8 +2761,18 @@ var FlowEngine = class {
       defaultDurations: operations.filter((o) => o.duration === "default").length
     };
   }
-  /** skuMix 에서 weight 로 gtin 선택(rng) — 도착/오더 자극의 품목 결정. */
+  /**
+   * `skuMix` 에서 weight 로 gtin 선택(rng) — 도착·오더 자극의 품목 결정.
+   *
+   * **빈 목록이면 고르지 않는다**(`undefined`). 예전에는 `mix[mix.length - 1].gtin` 으로 떨어져
+   * `mix[-1]` 이 undefined 가 되고 거기서 던졌다 — 그 예외가 서버까지 올라가 **정확도 추세 전체를
+   * 죽였다**(품목 구성을 선언하지 않은 자극 하나가 예측 전체를 껐다).
+   *
+   * 없는 품목을 지어내지 않는다: 무엇을 만들지 모르면 **만들지 않는 것**이 맞고, 부르는 쪽이
+   * 그 사실을 알고 건너뛴다.
+   */
   pickGtin(mix) {
+    if (!mix?.length) return void 0;
     const total = mix.reduce((s, m) => s + m.weight, 0);
     let r = this.rng() * total;
     for (const m of mix) {
@@ -2206,21 +2962,26 @@ var FlowEngine = class {
       ...t.personnel?.length ? { personnel: t.personnel.slice() } : {},
       ...t.assets?.length ? { assets: t.assets.slice() } : {},
       ...t.resources?.length ? { resources: t.resources.slice() } : {},
+      /* 실제 자재 이동 — 인원·설비와 같은 채널(실적을 한 곳에서 읽는다). */
+      ...t.materialActual?.length ? { materialActual: t.materialActual.map((r) => ({ ...r })) } : {},
       ...t.durationMs ? { durationMs: t.durationMs } : {},
+      ...t.priority !== void 0 ? { priority: t.priority } : {},
+      ...t.startTime ? { startTime: t.startTime } : {},
+      ...t.endTime ? { endTime: t.endTime } : {},
       ...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, assetClassIds: a.assetClassIds, status: a.status, location: a.location, taskId: a.taskId ?? void 0, carrying: a.carrying });
+    this.emitOp(OP_EVENT.asset, { assetId: a.id, assetClassIds: a.assetClassIds, status: a.status, location: a.location, taskId: a.taskId ?? void 0, carrying: a.carrying, ...effectiveOnly(a) });
   }
   emitPerson(p) {
-    this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? void 0, ...p.location ? { location: p.location } : {}, ...this.personOffShift(p) ? { offShift: true } : {} });
+    this.emitOp(OP_EVENT.person, { personId: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? void 0, ...p.location ? { location: p.location } : {}, ...effectiveOnly(p) });
   }
   /** 설비 상태 전이 — `taskId` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
    *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
   emitEquipment(m, motion) {
-    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, taskId: m.taskId ?? void 0, motion });
+    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, ...m.homeLocation ? { homeLocation: m.homeLocation } : {}, taskId: m.taskId ?? void 0, motion, ...m.held ? { held: true } : {}, ...effectiveOnly(m) });
   }
   /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
@@ -2231,6 +2992,9 @@ var FlowEngine = class {
       requested: o.requested,
       fulfilled: o.fulfilled,
       held: o.held,
+      ...o.priority !== void 0 ? { priority: o.priority } : {},
+      ...o.startTime ? { startTime: o.startTime } : {},
+      ...o.endTime ? { endTime: o.endTime } : {},
       ...o.lines?.length ? { lines: o.lines.map((l) => ({ gtin: l.gtin, requested: l.requested })) } : {}
     });
   }
@@ -2301,7 +3065,8 @@ var FlowEngine = class {
       if (!want) continue;
       const avail = [...this.assets.values()].filter(
         /* 인원과 같은 규칙 — 상속을 타고 닫아 판정하고 유효기간 밖은 제외한다. 요구는 등급 하나+수량. */
-        (a) => a.status === "idle" && !picked.includes(a.id) && (req.assetClass === void 0 || classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass))
+        (a) => a.status === "idle" && !picked.includes(a.id) && !this.outOfEffect(a) && // 폐기한 팔레트는 풀에서 빠진다
+        (req.assetClass === void 0 || classClosure(a.assetClassIds, this.classDefs.asset, this.now()).has(req.assetClass))
       );
       if (avail.length < want) return null;
       for (let i = 0; i < want; i++) picked.push(avail[i].id);
@@ -2319,7 +3084,7 @@ var FlowEngine = class {
       a.taskId = t.id;
       if (t.itemEpc) {
         a.carrying = t.itemEpc;
-        const it = this.items.get(t.itemEpc);
+        const it = this.itemByRef(t.itemEpc);
         if (it) it.carriedBy = a.id;
       }
       this.emitAsset(a);
@@ -2350,6 +3115,194 @@ var FlowEngine = class {
    * 여기서는 고르기만 하고 잡지 않는다: 설비까지 확보된 뒤 `assignCrew` 가 확정한다
    * (반쯤 잡고 실패하면 사람이 아무 일도 못 하면서 묶인다).
    */
+  /**
+   * 필요 자재를 확보한다 — **ISA-95 `OperationsSegment.MaterialSpecification`**(`use: 'consumed'`).
+   *
+   * ── 4대 자원 중 자재만 게이트가 없었다 ────────────────────────────────────
+   * 인원·자산·설비는 모자라면 기다리는데 **자재는 없어도 작업이 시작됐다.** 그래서 부품이 떨어져
+   * 라인이 서는 상황이 예측에 아예 나타나지 않았다 — 트레일러 조립 공장에서 그것은 가장 흔한 정지다.
+   *
+   * 인원·자산과 **같은 규칙**이다: 등급(또는 품목)으로 요구하고, **부분 확보 없이 전량 아니면 대기.**
+   * 자재는 **작업이 일어나는 자리에 있어야** 한다(다른 창고의 부품은 지금 쓸 수 없다).
+   *
+   * 소비 시점은 **작업 시작**이다 — 자재는 들어가는 순간 없어진다(완료 시점에 빼면 그 사이 다른
+   * 작업이 같은 부품을 또 잡는다). 산출(`produced`)은 여기서 다루지 않는다(완료 시점의 일이다).
+   */
+  claimMaterials(t) {
+    const need = (this.operationSpecs.get(t.kind)?.materialSpecification ?? []).filter((m) => m.use === "consumed");
+    if (!need.length) return [];
+    const at = t.toNode;
+    const picked = [];
+    const takenSoFar = /* @__PURE__ */ new Map();
+    for (const req of need) {
+      let remaining = Math.max(0, req.quantity ?? 0);
+      if (!remaining) continue;
+      for (const it of this.items.values()) {
+        if (remaining <= 0) break;
+        if (it.location !== at) continue;
+        if (!this.materialMatches(it, req)) continue;
+        const already = takenSoFar.get(it.epc) ?? 0;
+        const avail = Math.max(0, (it.qty ?? 1) - already);
+        if (avail <= 0) continue;
+        const take = Math.min(avail, remaining);
+        picked.push({ epc: it.epc, take });
+        takenSoFar.set(it.epc, already + take);
+        remaining -= take;
+      }
+      if (remaining > 0) return null;
+    }
+    return picked;
+  }
+  /** 이 물품이 명세를 만족하나 — 품목 지목이 우선, 없으면 등급(상속을 타고 닫는다). */
+  materialMatches(it, req) {
+    const defId = it.definitionId ?? it.gtin;
+    if (req.materialDefinition) return defId === req.materialDefinition;
+    if (req.materialClass) {
+      const def = defId ? this.materialDefs.get(defId) : void 0;
+      return classClosure(def?.materialClassIds, this.classDefs.material, this.now()).has(req.materialClass);
+    }
+    return true;
+  }
+  /**
+   * 산출 자재를 만든다 — ISA-95 `MaterialSpecification`(`use: 'produced'`).
+   *
+   * **소비의 짝이다**: 자재는 작업이 시작될 때 들어가고 끝날 때 나온다. 산출이 없으면 조립 공정이
+   * 부품만 먹고 아무것도 내놓지 않아, 다음 공정이 영원히 재료를 기다린다(라인 전체가 한 칸에서 멈춘다).
+   *
+   * 산출물의 자리는 **작업이 끝난 자리**(`toNode`)다. 식별자는 품목 식별자에 작업 id 를 붙여 만든다 —
+   * **EPC 처럼 보이게 꾸미지 않는다**(상류가 준 직렬번호와 구별돼야 한다). 상류가 진짜 식별자를
+   * 말해 주면 그것이 들어올 자리는 관측 경로다.
+   *
+   * 같은 품목이 그 자리에 이미 있으면 **수량을 더한다** — 새 줄을 만들면 같은 자리의 같은 로트가
+   * 둘로 갈려 재고가 부푼다(§MaterialSubLot 에서 겪은 것과 반대 방향의 같은 오류).
+   */
+  produceMaterials(t) {
+    const made = (this.operationSpecs.get(t.kind)?.materialSpecification ?? []).filter((m) => m.use === "produced");
+    if (!made.length) return;
+    for (const spec of made) {
+      const qty = Math.max(0, spec.quantity ?? 0);
+      if (!qty) continue;
+      const gtin = spec.materialDefinition;
+      if (!gtin) continue;
+      const at = t.toNode;
+      const key = subLotIdOf(gtin, at);
+      const existing = this.items.get(key);
+      const total = (existing?.qty ?? 0) + qty;
+      if (existing) existing.qty = total;
+      else {
+        this.items.set(key, { epc: gtin, subLotId: key, gtin, qty: total, location: at, disposition: DISP.in_progress, ...spec.uom ? { uom: spec.uom } : {} });
+        const n = this.locations.get(at);
+        if (n) n.occupancy++;
+      }
+      this.recordMaterialActual(t, gtin, "produced", qty, spec.uom);
+      this.emit(objectEvent({
+        eventTime: this.now(),
+        action: "ADD",
+        bizStep: CBV_BIZSTEP.commissioning,
+        disposition: DISP.in_progress,
+        epcList: [],
+        quantityList: [{ epcClass: gtin, quantity: total, ...spec.uom ? { uom: spec.uom } : {} }],
+        readPoint: at,
+        bizLocation: at
+      }));
+    }
+  }
+  /**
+   * 이 작업이 **딛고 선 것**이 아직 있나 — 없으면 무엇이 없는지 답한다.
+   *
+   * 작업은 혼자 서지 못한다: 옮길 **물품**과, (있다면) 그것을 시킨 **오더** 위에 선다. 진행 중에
+   * 둘 중 하나가 사라질 수 있다 — 물품은 포장·출하·소비로, 오더는 이미 이행돼 씨앗이 심지 않아서.
+   *
+   * 그때 도메인 훅은 없는 것을 딛으려다 던진다(`order.gtin` · `item.location`). 그 예외 하나가
+   * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
+   * 여기서 묻고, 없으면 그 작업만 접는다.
+   */
+  missingContextOf(t) {
+    if (t.itemEpc && !this.itemByRef(t.itemEpc)) return "item";
+    if (t.orderId && !this.orders.has(t.orderId)) return "order";
+    if (!this.canComplete(t)) return "domain";
+    return void 0;
+  }
+  /**
+   * 이 도메인이 이 작업을 **끝맺을 수 있나** — 코어가 모르는 조건은 도메인이 답한다.
+   *
+   * 코어는 물품과 오더까지만 안다. 그런데 도메인은 더 필요할 수 있다 — MES 는 완료 시점에 **오더와
+   * 제품 정의**를 딛고 서고, 그 중 하나만 없어도 던진다. 코어가 그 조건을 추측하면 도메인마다 다른
+   * 가정을 코어에 박게 되므로(방언), **묻는다.**
+   *
+   * 기본은 `true` — 대부분의 작업은 코어가 확인한 것으로 충분하다.
+   */
+  canComplete(_t) {
+    return true;
+  }
+  /**
+   * 작업이 가리키는 물품을 찾는다 — **참조와 키가 다를 수 있다.**
+   *
+   * 물품 맵의 키는 `itemKeyOf`(직렬 물품은 `epc`, 로트의 부분은 `subLotId`)인데, 작업은 로트 식별자
+   * (`itemEpc`)로 가리킨다. 비직렬 로트에서는 둘이 **다르다** — 그래서 그냥 `get` 하면 못 찾는다.
+   * 실제로 그 회귀를 냈다: 예측(씨앗) 경로에서 `item.location = …` 이 `undefined` 위에서 던져
+   * **정확도 추세 전체가 서버 오류로 죽었다.**
+   *
+   * **부분이 여럿이면 풀지 않는다** — 어느 부분을 가리키는지 알 수 없고, 아무거나 고르면 그 뒤
+   * 이동·처분이 엉뚱한 자리에 적힌다. 그때는 참조가 부족한 것이고, 부르는 쪽이 그 사실을 말해야 한다.
+   */
+  itemByRef(ref) {
+    const exact = this.items.get(ref);
+    if (exact) return exact;
+    let hit;
+    for (const it of this.items.values()) {
+      if (it.epc !== ref) continue;
+      if (hit) return void 0;
+      hit = it;
+    }
+    return hit;
+  }
+  /**
+   * 실제 자재 이동을 작업에 적어 둔다 — ISA-95 `JobResponse.MaterialActual`.
+   * 같은 품목·같은 쓰임은 **한 줄로 합친다**(줄을 늘리면 실적을 세는 쪽이 중복을 걷어내야 한다).
+   */
+  recordMaterialActual(t, definitionId, use, quantity, uom) {
+    if (!definitionId || !(quantity > 0)) return;
+    const rows = t.materialActual ??= [];
+    const hit = rows.find((r) => r.definitionId === definitionId && r.use === use && r.uom === uom);
+    if (hit) hit.quantity += quantity;
+    else rows.push({ definitionId, use, quantity, ...uom ? { uom } : {} });
+  }
+  /** 확보한 자재를 **작업 시작 시점에 소비**한다 — 수량이 0 이 되면 물품 자체가 사라진다. */
+  consumeMaterials(t, taken) {
+    if (!taken.length) return;
+    const whole = [];
+    for (const { epc, take } of taken) {
+      const it = this.items.get(epc);
+      if (!it) continue;
+      const left = (it.qty ?? 1) - take;
+      if (left > 0) {
+        it.qty = left;
+        this.recordMaterialActual(t, it.definitionId ?? it.gtin, "consumed", take, it.uom);
+        this.emit(objectEvent({
+          eventTime: this.now(),
+          action: "OBSERVE",
+          bizStep: CBV_BIZSTEP.consuming,
+          disposition: DISP.in_progress,
+          epcList: [],
+          quantityList: [{ epcClass: it.gtin ?? it.epc, quantity: left, uom: it.uom }],
+          readPoint: it.location,
+          bizLocation: it.location
+        }));
+        continue;
+      }
+      this.recordMaterialActual(t, it.definitionId ?? it.gtin, "consumed", take, it.uom);
+      whole.push(epc);
+    }
+    if (whole.length) {
+      this.transform(whole, [], {
+        bizStep: CBV_BIZSTEP.consuming,
+        disposition: DISP.in_progress,
+        transformationId: t.id,
+        readPoint: this.items.get(whole[0])?.location ?? t.toNode
+      });
+    }
+  }
   claimPersonnel(t) {
     const need = this.operationSpecs.get(t.kind)?.personnelSpecification;
     if (!need?.length) return [];
@@ -2358,7 +3311,8 @@ var FlowEngine = class {
       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) && /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
+        (p) => p.status === "idle" && !picked.includes(p.id) && !this.personOffShift(p) && !this.outOfEffect(p) && // 입사 전·퇴사 후는 이 시각의 모델에 없다
+        /* 자격은 **상속을 타고 닫아** 판정한다 — 사람은 여러 등급에 속할 수 있고(표준), 등급은
            다른 등급을 상속한다. "생산직 2명" 요구를 "용접 자격자" 가 만족해야 한다.
            유효기간 밖의 등급은 닫힘에서 빠진다(만료된 자격으로 배정되지 않는다). */
         (req.personnelClass === void 0 || classClosure(p.personnelClassIds, this.classDefs.personnel, this.now()).has(req.personnelClass))
@@ -2375,7 +3329,8 @@ var FlowEngine = class {
    */
   claimEquipment(t) {
     const free = (kind, picked2 = []) => [...this.equipment.values()].filter(
-      (m) => m.status === "idle" && !m.held && !this.offShift(m) && !picked2.includes(m.id) && /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
+      (m) => m.status === "idle" && !m.held && !this.offShift(m) && !this.outOfEffect(m) && // 도입 전·폐기 후는 이 시각의 모델에 없다
+      !picked2.includes(m.id) && /* 설비의 소속은 아직 단수(`kind`)다 — 저널에 기록이 쌓여 복수화를 별도 작업으로 두었다.
          다만 등급 정의가 있으면 **상속은 지금도 탄다**: 'welder-6axis' 가 'welder' 를 상속하면
          'welder' 요구를 만족한다. 단수/복수와 상속은 다른 축이므로 하나를 기다리지 않는다. */
       (kind === void 0 || classClosure(m.kind ? [m.kind] : [], this.classDefs.equipment, this.now()).has(kind))
@@ -2419,10 +3374,7 @@ var FlowEngine = class {
   }
   /** 사람의 교대 판정 — 자원(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);
+    return this.offCalendar(p);
   }
   /**
    * 이 자리가 동시 처리 한도에 찼는가 — `parallelism` 을 선언한 자리만 판정한다(미선언=제약 없음).
@@ -2438,14 +3390,71 @@ var FlowEngine = class {
   }
   /** 교대 밖인가 — 자원이 지금 일하지 않는 이유 중 고장·계획정지와 구별되는 세 번째. */
   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);
+    return this.offCalendar(m);
+  }
+  /** 왜 쉬는가 — 휴일·휴게(non-working)인지 주말·교대 사이(off-hours)인지(§OffCalendarReason). */
+  offReason(r) {
+    const why = offCalendarReasonAt(r, this.nowMs(), this.boardDef?.utcOffsetMinutes);
+    return why ? { offShiftReason: why } : {};
+  }
+  /**
+   * 유효 기간 밖인가 — **네 번째 이유**(§Effectivity). 설비·사람·자산이 같은 규칙을 쓴다.
+   *
+   * 시뮬 시각을 ISO 로 풀어 계약의 `effectivityAt` 에 넘긴다. **판정은 커널에 두지 않는다** —
+   * 호스트(라이브 관측)도 같은 판정을 해야 하고, 규칙이 두 벌이면 갈라진다.
+   */
+  effectivityOf(r) {
+    if (!r.effectiveStart && !r.effectiveEnd) return void 0;
+    return effectivityAt(r, this.now());
+  }
+  /**
+   * 지금 어느 교대인가 — 계약의 `activeShiftOf` 에 위임한다(미러도 같은 함수를 쓴다).
+   * 선언이 없으면 `undefined`: 교대를 나눠 놓지 않은 현장에 이름을 지어내지 않는다.
+   */
+  shiftOf(r) {
+    if (!r.workCalendar?.length) return void 0;
+    return activeShiftAt(r.workCalendar, this.nowMs(), this.boardDef?.utcOffsetMinutes);
+  }
+  /** 유효 기간 밖이라 이 시각의 모델에 참여하지 않는가 — 배정 게이트가 쓰는 형태. */
+  outOfEffect(r) {
+    return this.effectivityOf(r) !== void 0;
+  }
+  /**
+   * 스냅샷·델타에 실을 조각 — **선언한 기간과 판정을 함께** 낸다.
+   *
+   * 판정만 내면 화면이 "왜" 를 말할 수 없고(언제 폐기됐나), 기간만 내면 소비처마다 다시 판정해 갈라진다.
+   * 선언이 없으면 아무것도 붙이지 않는다(대부분의 자원이 그렇다 — 필드를 늘리지 않는다).
+   */
+  effectivePart(r) {
+    if (!r.effectiveStart && !r.effectiveEnd) return {};
+    const e = this.effectivityOf(r);
+    return {
+      ...r.effectiveStart ? { effectiveStart: r.effectiveStart } : {},
+      ...r.effectiveEnd ? { effectiveEnd: r.effectiveEnd } : {},
+      ...e ? { effectivity: e } : {}
+    };
+  }
+  /**
+   * 지금 근무 시간 밖인가 — **캘린더가 있으면 그것으로, 없으면 옛 `window` 로** 판정한다.
+   *
+   * `window`(시 단위 하나)는 캘린더의 특수한 경우다. 둘을 한 함수로 모아 두면 인원·설비가 같은 규칙을
+   * 쓴다(예전에는 같은 식이 두 곳에 복사돼 있었다 — 한쪽만 고치면 조용히 갈라진다).
+   */
+  offCalendar(r) {
+    return offCalendarAt(r, this.nowMs(), this.boardDef?.utcOffsetMinutes);
+  }
+  /**
+   * 시뮬 시각의 분(0..1439) — 캘린더 판정의 기준.
+   *
+   * **보드가 선언한 기준으로 읽는다**(`utcOffsetMinutes`). 예전에는 UTC 로 읽어서 Rosarito(UTC−7)의
+   * 06시 교대가 7시간 틀렸다 — 시각대만 적고 기준을 안 적으면 반드시 이렇게 된다.
+   */
+  minuteOfDay() {
+    return minuteOfDayAt(this.nowMs(), this.boardDef?.utcOffsetMinutes);
   }
   /** 시뮬 시각의 시(0..23) — 운영시간·시간대 배율의 기준. */
   hourOfDay() {
-    return new Date(BASE_EPOCH + this.clockMs).getUTCHours();
+    return new Date(this.nowMs()).getUTCHours();
   }
   /**
    * 운영시간 안인가 — `window {startHour, endHour}`. **선언만 되고 소비처가 없던 필드**를 판정한다.
@@ -2505,6 +3514,8 @@ var FlowEngine = class {
     const gtinKey = parsedClass?.gtinKey ?? parsedSelf.gtinKey;
     return {
       epc: i.epc,
+      ...i.subLotId ? { subLotId: i.subLotId } : {},
+      ...i.definitionId ? { definitionId: i.definitionId } : {},
       ...i.gtin ? { gtin: i.gtin } : {},
       ...gtinKey ? { gtinKey } : {},
       ...lot ? { lot } : {},
@@ -2514,6 +3525,7 @@ var FlowEngine = class {
       ...i.carriedBy ? { carriedBy: i.carriedBy } : {},
       ...i.qty !== void 0 ? { qty: i.qty } : {},
       ...i.uom ? { uom: i.uom } : {},
+      ...i.quantities?.length ? { quantities: i.quantities } : {},
       ...i.expiry !== void 0 ? { expiry: i.expiry } : {},
       ...i.ilmd ? { ilmd: i.ilmd } : {}
     };
@@ -2541,7 +3553,9 @@ var FlowEngine = class {
     }
   }
   processOrders() {
-    for (const o of this.orders.values()) if (o.status === "created" && !o.held) this.allocate(o);
+    const pending = [...this.orders.values()].filter((o) => o.status === "created" && !o.held);
+    if (pending.some((o) => o.priority !== void 0)) pending.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
+    for (const o of pending) this.allocate(o);
   }
   /**
    * 작업 진행 — **진행을 먼저, 배정을 나중에.**
@@ -2555,18 +3569,23 @@ var FlowEngine = class {
     this.assignTasks();
   }
   assignTasks() {
-    for (const t of this.tasks.values()) {
+    const queue = [...this.tasks.values()];
+    if (queue.some((t) => t.priority !== void 0)) queue.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority));
+    for (const t of queue) {
       if (t.status !== "created") continue;
       const crew = this.claimPersonnel(t);
       if (crew === null) continue;
       const gear = this.claimAssets(t);
       if (gear === null) continue;
+      const stock = this.claimMaterials(t);
+      if (stock === 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.consumeMaterials(t, stock);
         this.emitTask(t);
         continue;
       }
@@ -2591,6 +3610,7 @@ var FlowEngine = class {
       if (rigs.length > 1) t.resources = rigs.slice();
       this.assignCrew(t, crew);
       this.assignAssets(t, gear);
+      this.consumeMaterials(t, stock);
       this.emitTask(t);
       if (t.intent === "process") this.emitEquipment(eq);
       else this.emitEquipment(eq, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
@@ -2603,6 +3623,33 @@ var FlowEngine = class {
       if (t.resource && this.equipment.get(t.resource)?.status === "down") continue;
       t.remainingMs -= dt;
       if (t.remainingMs > 0) continue;
+      const missing = this.missingContextOf(t);
+      if (missing) {
+        this.abandonedTasks++;
+        if (this.abandonedTasks === 1) {
+          const why = missing === "item" ? "the item it moves is no longer in state (consumed, shipped, or the observation did not carry it)" : missing === "order" ? "the order it belongs to is no longer in state (already fulfilled, so the seed did not restore it)" : "the domain cannot complete it (its order or product definition is missing)";
+          console.warn(`[twin-kernel] "${this.tenantId}": folding task ${t.id} \u2014 ${why}. Further such tasks are counted, not logged.`);
+        }
+        this.tasks.delete(t.id);
+        this.releaseCrew(t);
+        this.releaseAssets(t);
+        if (t.resource) {
+          const rig = this.equipment.get(t.resource);
+          if (rig) {
+            rig.status = "idle";
+            rig.taskId = null;
+          }
+        }
+        for (const id of t.resources ?? []) {
+          const m = this.equipment.get(id);
+          if (m) {
+            m.status = "idle";
+            m.taskId = null;
+          }
+        }
+        continue;
+      }
+      this.produceMaterials(t);
       this.onTaskComplete(t);
       t.status = "completed";
       this.releaseCrew(t);
@@ -2651,6 +3698,7 @@ var WmsKernel = class extends FlowEngine {
     if (!dock) return;
     const epc = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
     const gtin = this.pickGtin(spec.content.skuMix);
+    if (!gtin) return;
     const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max);
     const po = gdtiUri(COMPANY_PREFIX, "401", ++this.poSeq);
     const eventTime = this.now();
@@ -2688,7 +3736,9 @@ var WmsKernel = class extends FlowEngine {
   onOrder(spec) {
     const lpl = spec.content.linesPerOrder;
     if (!lpl) {
-      this.createSalesOrder([{ gtin: this.pickGtin(spec.content.skuMix), qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) }]);
+      const only = this.pickGtin(spec.content.skuMix);
+      if (!only) return;
+      this.createSalesOrder([{ gtin: only, qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) }], spec);
       return;
     }
     const n = Math.min(this.randInt(lpl.min, lpl.max), spec.content.skuMix.length);
@@ -2696,10 +3746,12 @@ var WmsKernel = class extends FlowEngine {
     let pool = spec.content.skuMix;
     for (let i = 0; i < n && pool.length > 0; i++) {
       const gtin = this.pickGtin(pool);
+      if (!gtin) break;
       lines.push({ gtin, qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) });
       pool = pool.filter((m) => m.gtin !== gtin);
     }
-    this.createSalesOrder(lines);
+    if (!lines.length) return;
+    this.createSalesOrder(lines, spec);
   }
   /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
   handleCommand(cmd) {
@@ -2712,7 +3764,12 @@ var WmsKernel = class extends FlowEngine {
     }
     return super.handleCommand(cmd);
   }
-  createSalesOrder(lines) {
+  /**
+   * 오더 생성 — 약속(`promised`)이 있으면 **납기와 우선순위를 함께 싣는다**(표준 `EndTime`·`Priority`).
+   * 없으면 싣지 않는다: 없는 약속을 만들면 그 뒤 모든 지연 판정이 거짓 위에 선다.
+   */
+  /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
+  createSalesOrder(lines, spec) {
     const id = `order-${++this.orderSeq}`;
     const so = gdtiUri(COMPANY_PREFIX, "402", ++this.soSeq);
     const requested = lines.reduce((s, l) => s + l.qty, 0);
@@ -2726,7 +3783,8 @@ var WmsKernel = class extends FlowEngine {
       allocated: [],
       picked: [],
       shipmentEpc: null,
-      lines: lines.map((l) => ({ gtin: l.gtin, requested: l.qty }))
+      lines: lines.map((l) => ({ gtin: l.gtin, requested: l.qty })),
+      ...spec ? this.promiseOf(spec) : {}
     };
     this.orders.set(id, order);
     this.emitOrder(order);
@@ -2766,7 +3824,8 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
   onTaskComplete(t) {
-    const item = this.items.get(t.itemEpc);
+    const item = this.itemByRef(t.itemEpc);
+    if (!item) throw new Error(`task ${t.id}: item "${t.itemEpc}" vanished between the core check and the domain hook`);
     const from = this.locations.get(t.fromNode);
     const to = this.locations.get(t.toNode);
     from.occupancy--;
@@ -2819,6 +3878,7 @@ var WmsKernel = class extends FlowEngine {
 var TRAVEL_MS2 = 2e4;
 var DWELL_MS = 3e4;
 var WINDOW_DELAY_MS = 4e4;
+var WINDOW_LENGTH_MS = 20 * 6e4;
 var CARGO_PER_TRAILER = 2;
 var CP = "0614141";
 var YmsKernel = class extends FlowEngine {
@@ -2836,14 +3896,14 @@ var YmsKernel = class extends FlowEngine {
   }
   /** 인바운드(하차) 자극 — 화물 적재된 트레일러 도착. */
   onArrival(_spec) {
-    this.spawnAppointment("appointment");
+    this.spawnAppointment("appointment", _spec);
   }
   /** 아웃바운드(상차) 자극 — 빈 트레일러 도착(도크에서 staging 화물 적재 예정). */
   onOrder(_spec) {
-    this.spawnAppointment("appointment-out");
+    this.spawnAppointment("appointment-out", _spec);
   }
   /** 게이트-인 — 트레일러 도착 → 어포인트먼트(도크도어 배정 + 창). drop 은 야드 주차 태스크, live 는 게이트 대기. */
-  spawnAppointment(kind) {
+  spawnAppointment(kind, spec) {
     const gate = this.locationByType("gate");
     const doors = [...this.locations.values()].filter((n) => n.type === "dock-door").sort((a, b) => a.id.localeCompare(b.id));
     if (!gate || doors.length === 0) return;
@@ -2860,7 +3920,24 @@ var YmsKernel = class extends FlowEngine {
     const door = doors[this.doorRR++ % doors.length];
     const id = `order-${++this.orderSeq}`;
     const appt = gdtiUri(CP, "404", ++this.soSeq);
-    const order = { id, kind, status: "created", requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [epc], picked: [], dockDoor: door.id, windowStartMs: this.clockMs + WINDOW_DELAY_MS };
+    const order = {
+      id,
+      kind,
+      status: "created",
+      requested: 1,
+      fulfilled: 0,
+      bizTransaction: appt,
+      allocated: [epc],
+      picked: [],
+      dockDoor: door.id,
+      /* 내부 스케줄 게이트(시뮬 ms) — 표준 `EarliestStartTime` 과 같은 개념의 우리 단위. */
+      windowStartMs: this.clockMs + WINDOW_DELAY_MS,
+      /* 표준 필드로도 함께 낸다 — 소비처(화면·집계·미러)는 표준 축으로 읽는다.
+         `startTime` = 창이 열리는 때 · `endTime` = 창이 닫히는 때(= 납기). */
+      startTime: new Date(Date.parse(this.now()) + WINDOW_DELAY_MS).toISOString(),
+      endTime: new Date(Date.parse(this.now()) + WINDOW_DELAY_MS + WINDOW_LENGTH_MS).toISOString(),
+      ...spec?.priority !== void 0 ? { priority: spec.priority } : {}
+    };
     this.orders.set(id, order);
     this.apptMode.set(id, this.mode);
     this.emitOrder(order);
@@ -2907,7 +3984,8 @@ var YmsKernel = class extends FlowEngine {
   }
   /** 태스크 완료 — 목적지 타입으로 분기: yard-slot=주차, dock-door=상/하차+depart, gate=출차. */
   onTaskComplete(t) {
-    const trailer = this.items.get(t.itemEpc);
+    const trailer = this.itemByRef(t.itemEpc);
+    if (!trailer) throw new Error(`task ${t.id}: item "${t.itemEpc}" vanished between the core check and the domain hook`);
     const from = this.locations.get(t.fromNode);
     const to = this.locations.get(t.toNode);
     from.occupancy--;
@@ -2993,7 +4071,29 @@ 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);
+    if (mesSpec?.definition?.operations) {
+      this.loadOperations(mesSpec.definition.operations);
+      this.assertNoDoubleProduction(mesSpec.definition.operations);
+    }
+  }
+  /**
+   * **산출을 두 곳에서 만들지 않는다** — 기동 때 막는다.
+   *
+   * MES 는 레시피로 산출을 만든다: WIP 사슬(스텝마다 앞의 WIP 을 먹고 다음 WIP 을 낸다) · **직렬번호**
+   * (회사 프리픽스 + 일련번호) · **수율**(양품/불량이 처분을 가른다) · 생산오더 연결. 코어의 일반
+   * 자재 명세(`use: 'produced'`)는 **비직렬 클래스+수량**이라 그 넷을 표현하지 못한다.
+   *
+   * 그래서 MES 를 일반 선언으로 옮기지 않는다 — 옮기면 정체성·수율·오더 연결을 **잃는다**(§4-20).
+   * 대신 둘이 겹치면 **같은 산출을 두 번 만들게** 되므로, 그 조합을 기동 시점에 거부한다.
+   * 런타임에 조용히 두 배가 되는 것보다 기동이 실패하는 편이 낫다(재고가 거짓이 되면 그 위의
+   * 모든 계산이 거짓이 된다).
+   */
+  assertNoDoubleProduction(ops) {
+    const bad = ops.filter((o) => (o.materialSpecification ?? []).some((m) => m.use === "produced")).map((o) => o.key);
+    if (!bad.length) return;
+    throw new Error(
+      `MES recipe already produces outputs \u2014 operations [${bad.join(", ")}] must not also declare materialSpecification use:'produced' (that would create the same output twice). Consumption specs are fine; declare production in the recipe.`
+    );
   }
   productOf(gtin) {
     return PRODUCTS.find((p) => p.gtin === gtin);
@@ -3038,7 +4138,7 @@ var MesKernel = class extends FlowEngine {
     const product = PRODUCTS[this.orderSeq % PRODUCTS.length];
     const id = `order-${++this.orderSeq}`;
     const wo = gdtiUri(CP2, "403", ++this.soSeq);
-    const order = { id, kind: "workorder", status: "created", gtin: product.gtin, requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [] };
+    const order = { id, kind: "workorder", status: "created", gtin: product.gtin, requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [], ...this.promiseOf(_spec) };
     this.orders.set(id, order);
     this.emitOrder(order);
   }
@@ -3071,10 +4171,23 @@ var MesKernel = class extends FlowEngine {
     this.emitTask(task);
   }
   /** op 완료 = 변환. 라우트 인덱스로 분기: 첫=BOM 소비→WIP, 중간=WIP→WIP, 마지막(조립)=WIP→완성차(수율→OEE 품질). */
+  /**
+   * MES 는 완료 시점에 **오더와 제품 정의**를 딛고 선다 — 둘 중 하나만 없어도 끝맺을 수 없다.
+   *
+   * 씨앗이 이미 이행된 오더를 심지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
+   * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 던졌고 **그 예외
+   * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
+   */
+  canComplete(t) {
+    if (this.mesSpec) return !!(t.orderId && this.orders.get(t.orderId));
+    const order = t.orderId ? this.orders.get(t.orderId) : void 0;
+    return !!order && !!this.productOf(order.gtin);
+  }
   onTaskComplete(t) {
     if (this.mesSpec) return this.onTaskCompleteDef(t);
     const order = this.orders.get(t.orderId);
-    const product = this.productOf(order.gtin);
+    const product = order && this.productOf(order.gtin);
+    if (!order || !product) throw new Error(`task ${t.id}: order/product vanished between the core check and the domain hook`);
     const i = ROUTE.findIndex((s) => s.kind === t.kind);
     const loc = this.locations.get(t.toNode);
     const isLast = i === ROUTE.length - 1;
@@ -3114,6 +4227,17 @@ var MesKernel = class extends FlowEngine {
   serialOf(materialKey, serial) {
     return sgtinUri(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey], serial);
   }
+  /**
+   * 라우트를 용량 계산에 알려 준다 — 수율을 거슬러 올릴 때 순서가 곧 계산이다.
+   *
+   * 순서를 모르면 선언 순서대로 세는데, 그러면 하류에서 잃는 몫이 엉뚱한 공정에 얹힌다(조용히
+   * 틀린다). 생산 정의를 가진 커널만 이 답을 안다.
+   */
+  routeKeys() {
+    if (!this.mesSpec) return void 0;
+    const d = this.mesSpec.definition;
+    return d.routes?.find((r) => r.key === this.recipeDef().route)?.steps;
+  }
   /** recipe.route → 오퍼레이션 시퀀스 해소. */
   routeOps() {
     const d = this.mesSpec.definition;
@@ -3125,6 +4249,7 @@ var MesKernel = class extends FlowEngine {
     const rawStore = this.locationByType("raw-store");
     if (!rawStore) return;
     const gtin = this.pickGtin(spec.content.skuMix);
+    if (!gtin) return;
     const inputKey = this.recipeDef().inputs.map((i) => i.material).find((k) => this.classOf(k) === gtin);
     if (!inputKey) return;
     const epc = this.serialOf(inputKey, ++this.epcSeq);
@@ -3137,7 +4262,7 @@ var MesKernel = class extends FlowEngine {
     const rc = this.recipeDef();
     const id = `order-${++this.orderSeq}`;
     const wo = gdtiUri(this.mesSpec.companyPrefix, "403", ++this.soSeq);
-    const order = { id, kind: "workorder", status: "created", gtin: this.classOf(rc.outputs[0].material), requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [] };
+    const order = { id, kind: "workorder", status: "created", gtin: this.classOf(rc.outputs[0].material), requested: 1, fulfilled: 0, bizTransaction: wo, allocated: [], picked: [], ...this.promiseOf(_spec) };
     this.orders.set(id, order);
     this.emitOrder(order);
   }
@@ -3170,6 +4295,7 @@ var MesKernel = class extends FlowEngine {
   /** 정의 모드 완료 — 라우트 인덱스: 중간=WIP 변환+다음 스텝, 마지막=완제품(수율). */
   onTaskCompleteDef(t) {
     const order = this.orders.get(t.orderId);
+    if (!order) throw new Error(`task ${t.id}: order vanished between the core check and the domain hook`);
     const rc = this.recipeDef();
     const ops = this.routeOps();
     const i = ops.findIndex((s) => s.key === t.kind);
@@ -3213,6 +4339,12 @@ var VOCABULARY_EXCEPTIONS = [
   { token: "moverId", why: "journal wire field \u2014 renaming would mix two keys for one fact across history" },
   { token: "fromNode", why: "journal wire field (task.status payload)" },
   { token: "toNode", why: "journal wire field (task.status payload)" },
+  /* ── 보드의 옛 세대 키 — 저장된 데이터라 읽어는 줘야 한다 ────────────────
+   * 설비 배열의 이름은 세 세대를 거쳤다(movers → equipmentList → equipment). 저장된 보드에는
+   * 셋이 섞여 있고(실측 23개 중 13개가 `movers`), 하나라도 안 읽으면 그 보드는 **설비가 0인 공장**
+   * 으로 조용히 읽힌다 — 화면의 설비 수가 0이 되고 용량 판정에서 자원이 사라진다. 쓰는 곳은
+   * `readBoardEquipment` 한 곳뿐이고, 거기서 새 이름으로 정규화해 내보낸다. */
+  { token: "movers", why: "legacy board key (movers \u2192 equipmentList \u2192 equipment); read-only normalization in readBoardEquipment, 13 stored boards still use it" },
   /* ── 씬 컴포넌트 타입 — 보드에 저장된 값이고, 뜻이 어긋나지도 않는다 ──────
    * 보드 7개가 이 타입으로 컴포넌트를 담고 있어 개명하면 그 컴포넌트가 조용히 안 그려진다.
    * 그리고 씬에서 이 이름은 자원이 아니라 **움직임 표현**을 가리킨다(표준과 충돌 아님). */
@@ -3248,6 +4380,7 @@ function retiredVocabularyIn(line) {
   BTT_PRODORDER,
   CAPABILITIES,
   CAPABILITY_KEYS,
+  CBV_BIZSTEP,
   CMD,
   DISP,
   DOMAIN_CATALOG,
@@ -3259,6 +4392,7 @@ function retiredVocabularyIn(line) {
   GUARD_PRAGMA,
   ILMD_ATTR,
   LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY,
   MES_BIZSTEP,
   MES_LOCATION_TYPES,
   MES_PART_GTINS,
@@ -3269,6 +4403,7 @@ function retiredVocabularyIn(line) {
   OP_EVENT,
   OP_PARAM,
   ObservedReducer,
+  PRIORITY_UNSET,
   RETIRED_VOCABULARY,
   StateProjector,
   TwinHistory,
@@ -3283,41 +4418,61 @@ function retiredVocabularyIn(line) {
   YMS_LOCATION_TYPES,
   YMS_TYPES,
   YmsKernel,
+  activeShiftAt,
+  activeShiftOf,
   aggregationEvent,
+  analyzeCapacity,
   capabilitiesForType,
   classClosure,
   compareStates,
   computeOee,
   constantDuration,
+  conversionFactorOf,
   counterfactualAt,
   deriveAttentions,
+  dueStatusOf,
+  effectivityAt,
   fefoPolicy,
   firstFitPolicy,
+  foldJobResponses,
   foldTaskRecords,
   gdtiUri,
   graiUri,
   hierarchyOf,
+  inWorkCalendar,
+  inWorkCalendarAt,
   ingest,
   isEquipmentLevel,
+  isoDurationHours,
+  itemKeyOf,
   lgtinClass,
   locationStatusOf,
   mapRecord,
+  minuteOfDayAt,
   monteCarloForecast,
   objectEvent,
+  offCalendarAt,
+  offCalendarReasonAt,
   parseEpc,
   parseIsoDuration,
   partialFitPolicy,
+  priorityRank,
+  quantityIn,
   readBoardAssets,
   readBoardEquipment,
   readBoardLocations,
   replay,
+  replaySegments,
   retiredVocabularyIn,
   sgtinClass,
   sgtinUri,
   ssccUri,
   stateFieldsOf,
+  subLotIdOf,
   transactionEvent,
   transformationEvent,
   validateDomainDefinition,
-  validateEpcisEvent
+  validateEpcisEvent,
+  weekdayAt,
+  workingTimeOfWeek
 });