@operato/twin-kernel 0.2.3 → 0.4.0

package/dist-cjs/index.cjs

@@ -25,77 +25,362 @@ __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,
   DOMAIN_SYSTEMS: () => DOMAIN_SYSTEMS,
   EPCIS_CONTEXT: () => EPCIS_CONTEXT,
+  EQUIPMENT_LEVEL: () => EQUIPMENT_LEVEL,
   EventJournal: () => EventJournal,
   FlowEngine: () => FlowEngine,
+  GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
+  LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
   MES_BIZSTEP: () => MES_BIZSTEP,
-  MES_NODE_TYPES: () => MES_NODE_TYPES,
+  MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
   MES_PART_GTINS: () => MES_PART_GTINS,
   MES_PRODUCTS: () => MES_PRODUCTS,
   MES_PRODUCT_GTINS: () => MES_PRODUCT_GTINS,
   MES_TYPES: () => MES_TYPES,
   MesKernel: () => MesKernel,
-  NODE_SATURATION_NEAR: () => NODE_SATURATION_NEAR,
   OP_EVENT: () => OP_EVENT,
   OP_PARAM: () => OP_PARAM,
   ObservedReducer: () => ObservedReducer,
+  PRIORITY_UNSET: () => PRIORITY_UNSET,
+  RETIRED_VOCABULARY: () => RETIRED_VOCABULARY,
   StateProjector: () => ObservedReducer,
   TwinHistory: () => TwinHistory,
   TwinObserver: () => TwinObserver,
   TwinRuntime: () => TwinRuntime,
   UTC_OFFSET: () => UTC_OFFSET,
-  WMS_NODE_TYPES: () => WMS_NODE_TYPES,
+  VOCABULARY_EXCEPTIONS: () => VOCABULARY_EXCEPTIONS,
+  WMS_LOCATION_TYPES: () => WMS_LOCATION_TYPES,
   WMS_TYPES: () => WMS_TYPES,
   WmsKernel: () => WmsKernel,
   YARD_BIZSTEP: () => YARD_BIZSTEP,
-  YMS_NODE_TYPES: () => YMS_NODE_TYPES,
+  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,
-  nodeStatusOf: () => nodeStatusOf,
   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);
 
 // src/contract.ts
-var NODE_SATURATION_NEAR = 0.9;
-function nodeStatusOf(n) {
+var LOCATION_SATURATION_NEAR = 0.9;
+function locationStatusOf(n) {
   const cap = n.capacity;
   if (!(typeof cap === "number" && cap > 0)) return void 0;
   const r = (n.occupancy ?? 0) / cap;
-  return r >= 1 ? "full" : r >= NODE_SATURATION_NEAR ? "near-full" : "available";
+  return r >= 1 ? "full" : r >= LOCATION_SATURATION_NEAR ? "near-full" : "available";
+}
+var EQUIPMENT_LEVEL = [
+  "Enterprise",
+  "Site",
+  "Area",
+  "ProcessCell",
+  "Unit",
+  "ProductionLine",
+  "WorkCell",
+  "ProductionUnit",
+  "StorageZone",
+  "StorageUnit",
+  "WorkCenter",
+  "WorkUnit",
+  "EquipmentModule",
+  "ControlModule",
+  "Other"
+];
+function isEquipmentLevel(v) {
+  return typeof v === "string" && EQUIPMENT_LEVEL.includes(v);
+}
+function hierarchyOf(s) {
+  const push = (m, k, v) => {
+    const cur = m.get(k);
+    if (cur) cur.push(v);
+    else m.set(k, [v]);
+  };
+  const parent = /* @__PURE__ */ new Map();
+  const kids = /* @__PURE__ */ new Map();
+  const known = new Set(s.locations.map((n) => n.id));
+  for (const n of s.locations) {
+    if (!n.parentId || n.parentId === n.id) continue;
+    parent.set(n.id, n.parentId);
+    if (known.has(n.parentId)) push(kids, n.parentId, n.id);
+  }
+  for (const start of known) {
+    const seen = [start];
+    for (let at = parent.get(start); at !== void 0; at = parent.get(at)) {
+      if (seen.includes(at)) throw new Error(`location hierarchy has a cycle: ${[...seen, at].join(" \u2192 ")}`);
+      seen.push(at);
+      if (!known.has(at)) break;
+    }
+  }
+  const homes = /* @__PURE__ */ new Map();
+  for (const m of s.equipment ?? []) if (m.homeLocation) push(homes, m.homeLocation, m.id);
+  const ancestorsOf = (id) => {
+    const out = [];
+    for (let at = parent.get(id); at !== void 0; at = parent.get(at)) {
+      out.push(at);
+      if (!known.has(at)) break;
+    }
+    return out;
+  };
+  const descendantsOf = (id) => {
+    const out = [];
+    const stack = [...kids.get(id) ?? []];
+    while (stack.length) {
+      const cur = stack.pop();
+      out.push(cur);
+      stack.push(...kids.get(cur) ?? []);
+    }
+    return out;
+  };
+  const typeOf = new Map(s.locations.map((n) => [n.id, n.type]));
+  const levelOf = new Map(s.locations.map((n) => [n.id, n.level]));
+  return {
+    childrenOf: (id) => [...kids.get(id) ?? []],
+    ancestorsOf,
+    descendantsOf,
+    rollupOf: (id) => ancestorsOf(id).find((a) => !known.has(a)),
+    ancestorOfLevel: (id, level) => ancestorsOf(id).find((a) => known.has(a) && levelOf.get(a) === level),
+    ancestorOfType: (id, type) => ancestorsOf(id).find((a) => known.has(a) && typeOf.get(a) === type),
+    equipmentOf: (id, opts) => {
+      const scope = opts?.deep ? [id, ...descendantsOf(id)] : [id];
+      return scope.flatMap((n) => homes.get(n) ?? []);
+    }
+  };
+}
+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 inWindow = (d) => !d || effectivityAt(d, at) === void 0;
+  const out = /* @__PURE__ */ new Set();
+  const stack = [...directIds ?? []];
+  while (stack.length) {
+    const id = stack.pop();
+    if (out.has(id)) continue;
+    const def = byId.get(id);
+    if (!inWindow(def)) continue;
+    out.add(id);
+    for (const b of def?.baseIds ?? []) if (!out.has(b)) stack.push(b);
+  }
+  return out;
+}
+var PRIORITY_UNSET = Number.POSITIVE_INFINITY;
+function priorityRank(p) {
+  return typeof p === "number" && Number.isFinite(p) ? p : PRIORITY_UNSET;
+}
+function dueStatusOf(x, nowIso) {
+  if (!x.endTime || !nowIso) return void 0;
+  const due = 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",
@@ -114,7 +399,7 @@ var CMD = {
   orderRelease: "order.release",
   attentionAck: "attention.ack",
   // 주목 신호 확인(OPC UA A&C acknowledge) — args:{id}
-  // Operable 코어 — 모든 operable 자원(설비·이동무버) 공통. args:{resourceId}. capability-keyed(무방언, equipment.* 아님).
+  // Operable 코어 — 모든 operable 자원(설비·이동설비) 공통. args:{resourceId}. capability-keyed(무방언, equipment.* 아님).
   resourceHold: "resource.hold",
   // 계획 정지(정비/오프라인) — 배정 스킵
   resourceResume: "resource.resume",
@@ -126,8 +411,27 @@ var CMD = {
   resourceResetMetrics: "resource.reset-metrics",
   // OEE 계측 창 리셋
   resourceAdd: "resource.add"
-  // 라이브 자원(무버) 추가 — args:{kind, homeNode, count?}. 런타임 구조 변이(what-if 아닌 실제 act)
+  // 라이브 자원(설비) 추가 — args:{kind, homeLocation, count?}. 런타임 구조 변이(what-if 아닌 실제 act)
 };
+function readBoardLocations(def) {
+  const d = def;
+  return d.locations ?? d.nodes ?? [];
+}
+function readBoardEquipment(def) {
+  const d = def;
+  const list = d.equipment ?? d.equipmentList ?? [];
+  return list.map((e) => normalizeHomeLocation(e));
+}
+function normalizeHomeLocation(entry) {
+  const legacy = entry.homeNode;
+  if (legacy === void 0 || entry.homeLocation !== void 0) return entry;
+  const { homeNode: _drop, ...rest } = entry;
+  return { ...rest, homeLocation: legacy };
+}
+function readBoardAssets(def) {
+  const list = def.assets ?? [];
+  return list.map((a) => normalizeHomeLocation(a));
+}
 
 // src/domain-definition.ts
 var OP_PARAM = {
@@ -152,19 +456,19 @@ function validateDomainDefinition(def) {
   if (!def || typeof def !== "object") return ["domain definition \uC5C6\uC74C/\uAC1D\uCCB4 \uC544\uB2D8"];
   if (typeof def.id !== "string" || !def.id) v.push("id \uB204\uB77D");
   if (typeof def.label !== "string" || !def.label) v.push("label \uB204\uB77D");
-  if (!Array.isArray(def.nodeTypes) || def.nodeTypes.length === 0) v.push("nodeTypes \uBE44\uC5B4\uC788\uC74C");
+  if (!Array.isArray(def.locationTypes) || def.locationTypes.length === 0) v.push("locationTypes \uBE44\uC5B4\uC788\uC74C");
   if (!Array.isArray(def.resourceTypes)) v.push("resourceTypes \uBC30\uC5F4 \uC544\uB2D8");
-  const nodeKeys2 = new Set((def.nodeTypes || []).map((n) => n.key));
+  const locationKeys2 = new Set((def.locationTypes || []).map((n) => n.key));
   const resKeys = new Set((def.resourceTypes || []).map((r) => r.key));
   const matKeys = new Set((def.materials || []).map((m) => m.key));
   const opKeys = new Set((def.operations || []).map((o) => o.key));
   const routeKeys = new Set((def.routes || []).map((r) => r.key));
-  for (const [name, arr] of [["nodeTypes", def.nodeTypes], ["resourceTypes", def.resourceTypes], ["materials", def.materials], ["operations", def.operations], ["routes", def.routes], ["recipes", def.recipes]]) {
+  for (const [name, arr] of [["locationTypes", def.locationTypes], ["resourceTypes", def.resourceTypes], ["materials", def.materials], ["operations", def.operations], ["routes", def.routes], ["recipes", def.recipes]]) {
     for (const d of dupes((arr || []).map((x) => x.key))) v.push(`${name} \uD0A4 \uC911\uBCF5: ${d}`);
   }
   for (const o of def.operations || []) {
     if (!INTENTS.includes(o.intent)) v.push(`operation '${o.key}' intent \uBD80\uC815: ${o.intent}`);
-    if (o.nodeType && !nodeKeys2.has(o.nodeType)) v.push(`operation '${o.key}' nodeType '${o.nodeType}' \uBBF8\uC815\uC758`);
+    if (o.locationType && !locationKeys2.has(o.locationType)) v.push(`operation '${o.key}' locationType '${o.locationType}' \uBBF8\uC815\uC758`);
     if (o.resourceType && !resKeys.has(o.resourceType)) v.push(`operation '${o.key}' resourceType '${o.resourceType}' \uBBF8\uC815\uC758`);
     if (o.intent === "dwell" && o.resourceType) v.push(`operation '${o.key}' dwell \uC778\uB370 resourceType \uC9C0\uC815\uB428(\uBB34\uC790\uC6D0\uC774\uC5B4\uC57C)`);
   }
@@ -196,12 +500,12 @@ 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 nodeOccupancy = diffBy(predicted.nodes, actual.nodes, (n) => n.id, (n) => n.occupancy);
+  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 || nodeOccupancy.length > 0 || orderStatus.length > 0;
-  return { hasDrift, itemLocation, itemDisposition, nodeOccupancy, orderStatus };
+  const hasDrift = itemLocation.length > 0 || itemDisposition.length > 0 || locationOccupancy.length > 0 || orderStatus.length > 0;
+  return { hasDrift, itemLocation, itemDisposition, locationOccupancy, orderStatus };
 }
 
 // src/counterfactual.ts
@@ -324,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")}`;
 }
@@ -529,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();
@@ -538,34 +854,109 @@ var ObservedReducer = class {
   pendingParent = /* @__PURE__ */ new Map();
   // 자식 EPC → 부모(물류단위)
   tasks = /* @__PURE__ */ new Map();
-  movers = /* @__PURE__ */ new Map();
+  equipment = /* @__PURE__ */ new Map();
   persons = /* @__PURE__ */ new Map();
   assets = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
   revision = 0;
   /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
   corrections = [];
+  /**
+   * 자원별 **교대 선언** — 미러가 "지금 근무 중인가" 를 스스로 판정하기 위한 재료.
+   *
+   * 상태(`EquipmentState`)에 넣지 않는다: 시뮬 스냅샷도 이것을 내보내지 않으므로 넣으면 두 구동이
+   * 갈라진다(적합성 하네스가 `mirrorOnly` 로 잡는다). 이것은 **판정의 입력**이고, 나가는 것은 판정뿐이다.
+   */
+  shifts = /* @__PURE__ */ new Map();
+  /** 시각 해석 기준(보드 선언) — 없으면 UTC. 캘린더의 `HH:MM` 이 어느 기준인지 정한다. */
+  utcOffsetMinutes;
   constructor(board) {
-    for (const n of board.nodes) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, parentId: n.parentId, origin: "master" });
-    for (const m of board.movers) this.movers.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeNode, origin: "master" });
-    for (const p of board.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: "idle" });
-    for (const a of board.assets ?? []) this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: "idle" });
+    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 } : {}, ...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) {
     if (u.op === "remove") {
-      this.master.delete(u.node.id);
+      this.master.delete(u.location.id);
       return;
     }
-    const cur = this.master.get(u.node.id);
-    const capacity = u.node.capacity ?? cur?.capacity;
-    const parallelism = u.node.parallelism ?? cur?.parallelism;
-    this.master.set(u.node.id, {
-      id: u.node.id,
-      type: u.node.type ?? cur?.type ?? UNKNOWN_TYPE,
+    const cur = this.master.get(u.location.id);
+    const capacity = u.location.capacity ?? cur?.capacity;
+    const parallelism = u.location.parallelism ?? cur?.parallelism;
+    this.master.set(u.location.id, {
+      id: u.location.id,
+      type: u.location.type ?? cur?.type ?? UNKNOWN_TYPE,
       ...capacity === void 0 ? {} : { capacity },
       ...parallelism === void 0 ? {} : { parallelism },
-      ...u.node.parentId ?? cur?.parentId ? { parentId: u.node.parentId ?? cur?.parentId } : {},
+      ...u.location.parentId ?? cur?.parentId ? { parentId: u.location.parentId ?? cur?.parentId } : {},
       /* 마스터가 말한 것은 마스터 출처다 — 관측으로 알게 된 것(origin='observed')을 덮어 승격한다. */
       origin: "master"
     });
@@ -573,7 +964,7 @@ var ObservedReducer = class {
   /**
    * 관측된 로케이션을 구조로 승격 — **이벤트가 가르쳐 준 것을 구조에서 지우지 않는다.**
    *
-   * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `nodes` 에는
+   * 마스터에 없는 로케이션에서 물품이 관측되면, 예전에는 물품의 `location` 에만 남고 `locations` 에는
    * 나타나지 않았다. 그 결과 그 자리는 스키매틱에 없고, 점유가 집계되지 않고, 병목 주목이 뜰 수
    * 없었다 — **사실은 들어왔는데 구조가 모르는 상태.** 이제 최소 형태로 승격한다:
    * 종류는 모르므로 `unknown`, **용량은 비워 둔다**(발명하지 않는다), 출처는 `observed`.
@@ -597,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);
@@ -611,6 +1003,14 @@ var ObservedReducer = class {
   }
   /** 대상별 마지막 반영 시각 — 순서 판정용(대상=EPC·작업·설비·오더 id). */
   lastAt = /* @__PURE__ */ new Map();
+  /**
+   * **미러의 "지금"** — 지금까지 들은 것 중 가장 늦은 발생 시각.
+   *
+   * 미러는 스스로 시간을 굴리지 않지만, 시각으로만 일어나는 사실(유효 기간 만료)을 판정하려면 기준이
+   * 필요하다. 미러의 정직한 기준은 **"내가 마지막으로 들은 시점"** 이다. 아무것도 못 들었으면
+   * 판정하지 않는다(모르면 단정하지 않는다).
+   */
+  observedAtMs;
   /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
   apply(e) {
     this.revision++;
@@ -640,27 +1040,42 @@ 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;
       }
       case OP_EVENT.equipment: {
         const d = e.data;
-        if (this.stale(`mover:${d.moverId}`, e)) return;
+        if (this.stale(`eq:${d.moverId}`, e)) return;
         this.touchLocation(d.location);
-        const known = this.movers.get(d.moverId);
-        this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, taskId: d.taskId, motion: d.motion, origin: known?.origin ?? "observed" });
+        const known = this.equipment.get(d.moverId);
+        const homeLocation = d.homeLocation ?? known?.homeLocation;
+        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: {
         const d = e.data;
         if (this.stale(`person:${d.personId}`, e)) return;
+        const known = this.persons.get(d.personId);
         this.persons.set(d.personId, {
           id: d.personId,
-          personnelClass: d.personnelClass ?? this.persons.get(d.personId)?.personnelClass,
+          personnelClassIds: d.personnelClassIds ?? known?.personnelClassIds,
           status: d.status,
           taskId: d.taskId,
-          ...d.offShift ? { offShift: true } : {}
+          ...d.location ?? known?.location ? { location: d.location ?? known?.location } : {},
+          ...known?.properties ? { properties: known.properties } : {},
+          ...known?.testSpecificationIds ? { testSpecificationIds: known.testSpecificationIds } : {},
+          /* 델타의 `offShift` 는 **선언이 없을 때만** 받는다 — 선언이 있으면 `snapshot()` 이 시각으로
+             판정하고, 저장값을 함께 두면 교대 안으로 돌아왔을 때 옛 `true` 가 남는다(두 출처 = 갈라짐).
+             남겨 두는 이유는 캘린더 없는 옛 저널 재생이다. */
+          ...d.offShift && !this.shifts.has(`person:${d.personId}`) ? { offShift: true } : {},
+          ...d.effectiveStart || d.effectiveEnd ? effectiveOf(d) : effectiveOf(known)
         });
         break;
       }
@@ -670,11 +1085,12 @@ var ObservedReducer = class {
         const cur = this.assets.get(d.assetId);
         this.assets.set(d.assetId, {
           id: d.assetId,
-          assetClass: d.assetClass ?? cur?.assetClass,
+          assetClassIds: d.assetClassIds ?? cur?.assetClassIds,
           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;
@@ -690,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;
@@ -742,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));
       }
     }
   }
@@ -773,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 ?? "",
@@ -787,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,
@@ -803,16 +1240,57 @@ var ObservedReducer = class {
       for (const c of children) this.remove(c);
     }
   }
-  /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+  /** 현재 투영 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);
     return {
       revision: this.revision,
       ...this.corrections.length ? { corrections: this.corrections.map((c) => ({ ...c })) } : {},
-      nodes: [...this.master.values()].map((n) => {
+      locations: [...this.master.values()].map((n) => {
         const occupancy = occ.get(n.id) ?? 0;
-        const status = nodeStatusOf({ occupancy, capacity: n.capacity });
+        const status = locationStatusOf({ occupancy, capacity: n.capacity });
         return {
           id: n.id,
           type: n.type,
@@ -827,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 })),
-      movers: [...this.movers.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 }))
     };
   }
@@ -858,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) {
@@ -867,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 = {
@@ -882,10 +1372,10 @@ var BTT = {
   po: "urn:epcglobal:cbv:btt:po",
   so: "urn:epcglobal:cbv:btt:so"
 };
-var WMS_NODE_TYPES = ["dock", "storage", "staging", "dock-ship"];
+var WMS_LOCATION_TYPES = ["dock", "storage", "staging", "dock-ship"];
 var WMS_TYPES = [
-  ...WMS_NODE_TYPES.map((k) => ({ key: k, role: "node", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
-  { key: "forklift", role: "mover", label: "twin.type.forklift", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
+  ...WMS_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  { key: "forklift", role: "equipment", label: "twin.type.forklift", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
 ];
 
 // src/capability.ts
@@ -908,7 +1398,7 @@ var CAPABILITIES = {
   mobile: {
     key: "mobile",
     label: "\uC774\uB3D9",
-    semantics: "\uC790\uC6D0 \uC790\uC2E0\uC774 \uB178\uB4DC \uAC04 \uC774\uB3D9. Transferable(\uC544\uC774\uD15C \uC774\uB3D9)\uACFC \uB2E4\uB984. (\uC52C \uAE30\uC81C: CarrierLine)",
+    semantics: "\uC790\uC6D0 \uC790\uC2E0\uC774 \uC790\uB9AC \uAC04 \uC774\uB3D9. Transferable(\uC544\uC774\uD15C \uC774\uB3D9)\uACFC \uB2E4\uB984. (\uC52C \uAE30\uC81C: CarrierLine)",
     stateFields: ["location", "motion"],
     models: ["Motion"],
     results: ["moved", "motionTick"]
@@ -952,10 +1442,10 @@ var BTT_DELIVERY = "urn:epcglobal:cbv:btt:deliv";
 function graiUri(companyPrefix, assetType, serial) {
   return `urn:epc:id:grai:${companyPrefix}.${assetType}.${String(serial).padStart(6, "0")}`;
 }
-var YMS_NODE_TYPES = ["gate", "yard-slot", "dock-door", "staging"];
+var YMS_LOCATION_TYPES = ["gate", "yard-slot", "dock-door", "staging"];
 var YMS_TYPES = [
-  ...YMS_NODE_TYPES.map((k) => ({ key: k, role: "node", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
-  { key: "hostler", role: "mover", label: "twin.type.hostler", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
+  ...YMS_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  { key: "hostler", role: "equipment", label: "twin.type.hostler", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] }
 ];
 
 // src/mes-profile.ts
@@ -971,8 +1461,8 @@ var BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
 function sgtinUri(companyPrefix, itemRef, serial) {
   return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
 }
-var MES_NODE_TYPES = ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
-var MES_NODE_CLS = {
+var MES_LOCATION_TYPES = ["raw-store", "cut-station", "weld-station", "paint-booth", "assembly-line", "fg-store"];
+var MES_LOCATION_CLS = {
   "raw-store": { epcis: "bizLocation" },
   "cut-station": { isa95: "WorkCenter", epcis: "bizLocation" },
   "weld-station": { isa95: "WorkCenter", epcis: "bizLocation" },
@@ -981,20 +1471,20 @@ var MES_NODE_CLS = {
   "fg-store": { epcis: "bizLocation" }
 };
 var MES_TYPES = [
-  ...MES_NODE_TYPES.map((k) => ({ key: k, role: "node", label: `twin.type.${k}`, standardClass: MES_NODE_CLS[k] ?? {}, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
-  { key: "cutter", role: "mover", label: "twin.type.cutter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
-  { key: "welder", role: "mover", label: "twin.type.welder", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
-  { key: "painter", role: "mover", label: "twin.type.painter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
-  { key: "assembler", role: "mover", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
+  ...MES_LOCATION_TYPES.map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: MES_LOCATION_CLS[k] ?? {}, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  { key: "cutter", role: "equipment", label: "twin.type.cutter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
+  { key: "welder", role: "equipment", label: "twin.type.welder", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
+  { key: "painter", role: "equipment", label: "twin.type.painter", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] },
+  { key: "assembler", role: "equipment", label: "twin.type.assembler", standardClass: { isa95: "Equipment", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
 // src/domain-catalog.ts
-var nodeKeys = (types) => types.filter((t) => t.role === "node").map((t) => t.key);
+var locationKeys = (types) => types.filter((t) => t.role === "location").map((t) => t.key);
 var DOMAIN_CATALOG = {
   // label 은 언어 중립 i18n 키(twin.system.<code>) — 사람 언어는 표현계층이 렌더(L2).
-  wms: { system: "wms", label: "twin.system.wms", types: WMS_TYPES, nodeTypes: nodeKeys(WMS_TYPES) },
-  yms: { system: "yms", label: "twin.system.yms", types: YMS_TYPES, nodeTypes: nodeKeys(YMS_TYPES) },
-  mes: { system: "mes", label: "twin.system.mes", types: MES_TYPES, nodeTypes: nodeKeys(MES_TYPES) }
+  wms: { system: "wms", label: "twin.system.wms", types: WMS_TYPES, locationTypes: locationKeys(WMS_TYPES) },
+  yms: { system: "yms", label: "twin.system.yms", types: YMS_TYPES, locationTypes: locationKeys(YMS_TYPES) },
+  mes: { system: "mes", label: "twin.system.mes", types: MES_TYPES, locationTypes: locationKeys(MES_TYPES) }
 };
 var DOMAIN_SYSTEMS = ["wms", "yms", "mes"];
 function capabilitiesForType(system, typeKey) {
@@ -1083,8 +1573,8 @@ function foldTaskRecords(rows) {
     if (f.resource === void 0 && d.resourceRef) f.resource = d.resourceRef;
     if (f.kind === void 0 && d.kind) f.kind = d.kind;
     if (f.order === void 0 && d.orderId) f.order = d.orderId;
-    const node = d.toNode ?? d.fromNode;
-    if (node) f.node = node;
+    const loc = d.toNode ?? d.fromNode;
+    if (loc) f.location = loc;
     if (d.status === "created") rec.createdMs = at;
     else if (d.status === "in-progress") rec.startedMs = rec.startedMs != null ? Math.min(rec.startedMs, at) : at;
     else if (d.status === "completed") rec.completedMs = rec.completedMs != null ? Math.max(rec.completedMs, at) : at;
@@ -1092,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);
@@ -1192,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 = () => {
@@ -1207,16 +1837,16 @@ function mulberry32(seed) {
   } });
   return fn;
 }
-function deriveAttentions(view, acked) {
+function deriveAttentions(view, acked, nowIso) {
   const out = [];
-  for (const m of view.movers) {
+  for (const m of view.equipment) {
     if (m.status === "down") {
       out.push({
         id: `breakdown:${m.id}`,
         kind: "breakdown",
         severity: "critical",
-        anchor: { moverId: m.id, nodeId: m.location },
-        params: { moverId: m.id, ...m.location ? { nodeId: m.location } : {} },
+        anchor: { moverId: m.id, locationId: m.location },
+        params: { moverId: m.id, ...m.location ? { locationId: m.location } : {} },
         recommendedActions: [
           { code: "act.repair", command: CMD.resourceRepair, args: { resourceId: m.id } },
           { code: "act.hold-until-repair", command: CMD.resourceHold, args: { resourceId: m.id } }
@@ -1225,7 +1855,7 @@ function deriveAttentions(view, acked) {
       });
     }
   }
-  for (const n of view.nodes) {
+  for (const n of view.locations) {
     if ((n.capacity ?? 0) > 0) {
       const r = (n.occupancy ?? 0) / n.capacity;
       if (r >= 0.9) {
@@ -1234,15 +1864,39 @@ function deriveAttentions(view, acked) {
           id: `bottleneck:${n.id}`,
           kind: "bottleneck",
           severity: saturated ? "high" : "medium",
-          anchor: { nodeId: n.id },
-          params: { nodeId: n.id, occupancy: n.occupancy ?? 0, capacity: n.capacity ?? 0, ratioPct: Math.round(r * 100), saturated: saturated ? 1 : 0 },
+          anchor: { locationId: n.id },
+          params: { locationId: n.id, occupancy: n.occupancy ?? 0, capacity: n.capacity ?? 0, ratioPct: Math.round(r * 100), saturated: saturated ? 1 : 0 },
           recommendedActions: [{ code: "advice.add-resource" }, { code: "advice.downstream-priority" }]
           // 권고만(command 없음) — 표현계층이 advice.* 코드로 렌더
         });
       }
     }
   }
-  for (const m of view.movers) {
+  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) {
       const rate = (m.scrapCount ?? 0) / total;
@@ -1250,7 +1904,7 @@ function deriveAttentions(view, acked) {
         id: `scrap:${m.id}`,
         kind: "scrap-high",
         severity: rate >= 0.3 ? "high" : "medium",
-        anchor: { moverId: m.id, nodeId: m.location },
+        anchor: { moverId: m.id, locationId: m.location },
         params: { moverId: m.id, goodCount: m.goodCount ?? 0, scrapCount: m.scrapCount ?? 0, ratePct: Math.round(rate * 100) },
         recommendedActions: [
           { code: "act.hold-for-inspection", command: CMD.resourceHold, args: { resourceId: m.id } },
@@ -1271,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";
   }
@@ -1298,9 +1967,16 @@ function computeOee(c, nowMs) {
 }
 var FlowEngine = class {
   tenantId;
-  nodes = /* @__PURE__ */ new Map();
+  locations = /* @__PURE__ */ new Map();
   items = /* @__PURE__ */ new Map();
-  movers = /* @__PURE__ */ new Map();
+  equipment = /* @__PURE__ */ new Map();
+  /** 등급 정의(표준 `<X>Class`) — 상속·유효기간 판정의 재료. 선언 안 하면 비어 있고, 소속 그대로 판정한다. */
+  classDefs = {};
+  /**
+   * 품목 정의 색인(표준 `MaterialDefinition`) — 단위 환산의 **유일한 근거**.
+   * 비어 있으면 환산하지 않는다(계수를 모르는데 값을 만들지 않는다).
+   */
+  materialDefs = /* @__PURE__ */ new Map();
   /** 사람 — 선언하지 않으면 빈 맵(인원 제약 없는 트윈, 기존 거동). */
   persons = /* @__PURE__ */ new Map();
   /** 물리 자산 — 선언하지 않으면 빈 맵(자산 제약 없는 트윈, 기존 거동). */
@@ -1347,88 +2023,191 @@ var FlowEngine = class {
   // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
   loadBoard(def) {
     this.boardDef = def;
-    for (const n of def.nodes) this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, parallelism: n.parallelism, occupancy: 0, status: "idle", parentId: n.parentId });
-    for (const p of def.persons ?? []) this.persons.set(p.id, { id: p.id, personnelClass: p.personnelClass, status: "idle", taskId: null, window: p.window });
-    for (const a of def.assets ?? []) this.assets.set(a.id, { id: a.id, assetClass: a.assetClass, location: a.homeNode, status: "idle", taskId: null });
-    for (const m of def.movers) {
-      const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0, window: m.window };
+    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, 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, ...m.workCalendar ? { workCalendar: m.workCalendar } : {}, ...effectiveOnly(m) };
       if (m.mtbfMs !== void 0) {
-        mover.mtbfMs = m.mtbfMs;
-        mover.mttrMs = m.mttrMs;
-        mover.nextFailureMs = this.sampleExp(m.mtbfMs);
+        eq.mtbfMs = m.mtbfMs;
+        eq.mttrMs = m.mttrMs;
+        eq.nextFailureMs = this.sampleExp(m.mtbfMs);
       }
-      this.movers.set(m.id, mover);
+      this.equipment.set(m.id, eq);
     }
   }
   /**
-   * what-if 구성 변주 — fork(또는 실행 중) 엔진에 무버 추가. loadBoard 무버 삽입과 동일 규약.
+   * what-if 구성 변주 — fork(또는 실행 중) 엔진에 설비 추가. loadBoard 설비 삽입과 동일 규약.
    * 기본은 mtbf 미지정(고장 없는 신뢰 자원) → sampleExp(rng) 무소비라 baseline fork 와 깨끗이 비교 가능.
    */
-  addMover(m) {
-    if (this.movers.has(m.id)) return;
-    const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+  addEquipment(m) {
+    if (this.equipment.has(m.id)) return;
+    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 };
     if (m.mtbfMs !== void 0) {
-      mover.mtbfMs = m.mtbfMs;
-      mover.mttrMs = m.mttrMs;
-      mover.nextFailureMs = this.sampleExp(m.mtbfMs);
+      eq.mtbfMs = m.mtbfMs;
+      eq.mttrMs = m.mttrMs;
+      eq.nextFailureMs = this.sampleExp(m.mtbfMs);
     }
-    this.movers.set(m.id, mover);
+    this.equipment.set(m.id, eq);
   }
   /**
-   * 관측 상태 주입(라이브 예측용, kernel-unification P1) — 외부 관측 스냅샷(재고·무버·노드)과
+   * 관측 상태 주입(라이브 예측용, kernel-unification P1) — 외부 관측 스냅샷(재고·설비·자리)과
    * 저널 오더(원값+라인)로 이 커널의 맵을 채운다. tick 으로 만든 게 아니라 "현재 관측된 현실"을 심어
    * 이후 fork/tick 으로 예측한다. 라이브 런타임은 여전히 projector 미러 — 이 커널은 예측용 임시본.
    * 오더는 남은 데맨드(라인별 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.nodes) {
-      this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity ?? 0, parallelism: n.parallelism, occupancy: n.occupancy ?? 0, status: n.status ?? "idle", parentId: n.parentId });
+    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,
         ilmd: it.ilmd
       });
     }
-    for (const m of snap.movers) {
+    for (const m of snap.equipment) {
       const oee = m.oee;
-      this.movers.set(m.id, {
+      const prev = this.equipment.get(m.id);
+      this.equipment.set(m.id, {
+        ...prev ?? {},
         id: m.id,
         kind: m.kind,
         location: m.location ?? "",
+        ...m.homeLocation ? { homeLocation: m.homeLocation } : {},
         status: m.status ?? "idle",
         taskId: null,
         runMs: oee?.runMs ?? 0,
         setupMs: oee?.setupMs ?? 0,
         downMs: oee?.downMs ?? 0,
         goodCount: oee?.goodCount ?? 0,
-        scrapCount: oee?.scrapCount ?? 0
+        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, personnelClass: p.personnelClass, 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, assetClass: a.assetClass, 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 ?? "",
@@ -1440,7 +2219,7 @@ var FlowEngine = class {
         intent: t.intent
       });
       if (known && t.status === "in-progress" && t.resourceRef) {
-        const mv = this.movers.get(t.resourceRef);
+        const mv = this.equipment.get(t.resourceRef);
         if (mv) {
           mv.status = "busy";
           mv.taskId = t.id;
@@ -1458,17 +2237,15 @@ 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. */
-  setNodeCapacity(nodeId, capacity) {
-    const n = this.nodes.get(nodeId);
+  /** what-if 구성 변주 — 자리 용량 변경(fork 대상). 존재하면 true. */
+  setLocationCapacity(locationId, capacity) {
+    const n = this.locations.get(locationId);
     if (!n) return false;
     n.capacity = Math.max(0, capacity);
     return true;
@@ -1494,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 });
@@ -1513,39 +2299,39 @@ var FlowEngine = class {
         if (id) this._acked.add(id);
         return ok();
       }
-      // Operable 코어 — 자원(설비·무버) 제어. capability-keyed(resourceId), 모든 operable 자원 공통.
+      // Operable 코어 — 자원(설비·설비) 제어. capability-keyed(resourceId), 모든 operable 자원 공통.
       case CMD.resourceHold:
       case CMD.resourceResume: {
-        const m = this.movers.get(cmd.args?.resourceId ?? "");
+        const m = this.equipment.get(cmd.args?.resourceId ?? "");
         if (!m) return fail("resource-not-found");
         m.held = cmd.type === CMD.resourceHold;
-        this.emitMover(m);
+        this.emitEquipment(m);
         return ok();
       }
       case CMD.resourceDown: {
         const a = cmd.args;
-        const m = this.movers.get(a?.resourceId ?? "");
+        const m = this.equipment.get(a?.resourceId ?? "");
         if (!m) return fail("resource-not-found");
         if (m.status !== "down") {
           m.status = "down";
           m.repairUntilMs = this.clockMs + (Number(a?.durationMs) || m.mttrMs || 6e4);
-          this.emitMover(m);
+          this.emitEquipment(m);
         }
         return ok();
       }
       case CMD.resourceRepair: {
-        const m = this.movers.get(cmd.args?.resourceId ?? "");
+        const m = this.equipment.get(cmd.args?.resourceId ?? "");
         if (!m) return fail("resource-not-found");
         if (m.status === "down") {
           m.status = m.taskId ? "busy" : "idle";
           m.repairUntilMs = void 0;
           if (m.mtbfMs !== void 0) m.nextFailureMs = this.clockMs + this.sampleExp(m.mtbfMs);
-          this.emitMover(m);
+          this.emitEquipment(m);
         }
         return ok();
       }
       case CMD.resourceResetMetrics: {
-        const m = this.movers.get(cmd.args?.resourceId ?? "");
+        const m = this.equipment.get(cmd.args?.resourceId ?? "");
         if (!m) return fail("resource-not-found");
         m.runMs = 0;
         m.setupMs = 0;
@@ -1554,21 +2340,21 @@ var FlowEngine = class {
         m.scrapCount = 0;
         m.holdMs = 0;
         m.metricsSinceMs = this.clockMs;
-        this.emitMover(m);
+        this.emitEquipment(m);
         return ok();
       }
       case CMD.resourceAdd: {
         const a = cmd.args;
         if (!a?.kind) return fail("kind-required");
-        if (!a?.homeNode || !this.nodes.has(a.homeNode)) return fail("home-node-not-found", { homeNode: a?.homeNode ?? "" });
+        if (!a?.homeLocation || !this.locations.has(a.homeLocation)) return fail("home-location-not-found", { homeLocation: a?.homeLocation ?? "" });
         const count = Math.max(1, Math.min(50, Number(a.count) || 1));
-        let seq = this.movers.size;
+        let seq = this.equipment.size;
         for (let i = 0; i < count; i++) {
           let id = `${a.kind}-${++seq}`;
-          while (this.movers.has(id)) id = `${a.kind}-${++seq}`;
-          this.addMover({ id, kind: a.kind, homeNode: a.homeNode });
-          const m = this.movers.get(id);
-          if (m) this.emitMover(m);
+          while (this.equipment.has(id)) id = `${a.kind}-${++seq}`;
+          this.addEquipment({ id, kind: a.kind, homeLocation: a.homeLocation });
+          const m = this.equipment.get(id);
+          if (m) this.emitEquipment(m);
         }
         return ok();
       }
@@ -1615,28 +2401,42 @@ var FlowEngine = class {
     return {
       revision: this.revision,
       simClockMs: this.clockMs,
+      nowTime: this.now(),
+      // 트윈의 "지금" — 관측 모드면 마지막으로 들은 시각(§nowMs)
       /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
        * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
-      nodes: [...this.nodes.values()].map((n) => {
+      locations: [...this.locations.values()].map((n) => {
         const { status, ...rest } = n;
-        const derived = nodeStatusOf(n);
+        const derived = locationStatusOf(n);
         return { ...rest, ...derived ? { status: derived } : {}, origin: "master" };
       }),
       items: [...this.items.values()].map((i) => this.itemState(i)),
-      movers: [...this.movers.values()].map((m) => {
-        const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m), held: m.held, origin: "master", ...this.offShift(m) ? { offShift: true } : {} };
+      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, ...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;
       }),
       assets: [...this.assets.values()].map((a) => {
-        const st = { id: a.id, assetClass: a.assetClass, location: a.location, status: a.status, taskId: a.taskId ?? void 0 };
+        const st = { id: a.id, assetClassIds: a.assetClassIds, location: a.location, status: a.status, taskId: a.taskId ?? void 0 };
         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) => {
-        const st = { id: p.id, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? void 0 };
-        if (this.personOffShift(p)) st.offShift = true;
+        const st = { id: p.id, personnelClassIds: p.personnelClassIds, status: p.status, taskId: p.taskId ?? void 0 };
+        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;
+          Object.assign(st, this.offReason(p));
+        }
+        const sh = this.shiftOf(p);
+        if (sh) st.shift = sh;
+        Object.assign(st, this.effectivePart(p));
         return st;
       }),
       /* 스냅샷이 **델타보다 가난하면 안 된다** — 예전에는 소요·남은 시간을 빼고 내보내서, 이 스냅샷으로
@@ -1656,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,
@@ -1666,23 +2470,40 @@ 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()
     };
   }
   /*
-   * 주목 신호 판단 — 상태(노드·무버·오더)에서 도메인 조건을 평가해 Attention 방출.
+   * 주목 신호 판단 — 상태(자리·설비·오더)에서 도메인 조건을 평가해 Attention 방출.
    * severity=ISA-18.2 우선순위 계열, kind=도메인 라벨. UI 는 판단 안 함(임계값 여기 소유).
    * 도메인별 추가 판단은 서브클래스가 override 로 확장(super.computeAttentions() 합성).
    */
   computeAttentions() {
+    const now = this.now();
     const out = deriveAttentions(
-      { movers: [...this.movers.values()], nodes: [...this.nodes.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;
   }
   /**
@@ -1709,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));
@@ -1733,7 +2588,7 @@ var FlowEngine = class {
    */
   apply(envelope) {
     if (!this.observer) {
-      this.observer = new ObservedReducer(this.boardDef ?? { nodes: [], movers: [] });
+      this.observer = new ObservedReducer(this.boardDef ?? { locations: [], equipment: [] });
       this.observeMode = true;
     }
     this.observer.apply(envelope);
@@ -1762,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 + 변동) → ③ 도메인 상수.**
    *
@@ -1871,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) {
@@ -1881,28 +2781,28 @@ var FlowEngine = class {
     }
     return mix[mix.length - 1].gtin;
   }
-  nodeByType(type) {
-    for (const n of this.nodes.values()) if (n.type === type) return n;
+  locationByType(type) {
+    for (const n of this.locations.values()) if (n.type === type) return n;
     return void 0;
   }
   /**
    * process 변화 대수(EPCIS TransformationEvent · ISA-95 Material Consumed/Produced · 씬 Processable.transform).
    * inputs 소비 → outputs 생산. 입출력 arity 가 곧 대수:
    *   merge N→1(조립) · split 1→N(분해) · transform 1→1(타입변경) · loss N→0(소실) · gain 0→N(부산물·생성).
-   * 아이템 상태(소비/생산)와 노드 점유를 갱신하고 계보(TransformationEvent)를 방출한다.
+   * 아이템 상태(소비/생산)와 자리 점유를 갱신하고 계보(TransformationEvent)를 방출한다.
    * 도메인은 이 원시만 호출 — onTaskComplete 의 소비/생산/EPCIS 손코딩을 대체.
    */
   transform(inputs, outputs, opts) {
     for (const epc of inputs) {
       const it = this.items.get(epc);
       if (!it) continue;
-      const n = this.nodes.get(it.location);
+      const n = this.locations.get(it.location);
       if (n) n.occupancy--;
       this.items.delete(epc);
     }
     for (const o of outputs) {
       this.items.set(o.epc, { epc: o.epc, gtin: o.gtin, qty: o.qty, location: o.location, disposition: o.disposition });
-      const n = this.nodes.get(o.location);
+      const n = this.locations.get(o.location);
       if (n) n.occupancy++;
     }
     this.emit(transformationEvent({
@@ -1976,7 +2876,7 @@ var FlowEngine = class {
       for (const c of children) {
         const it = this.items.get(c);
         if (it) {
-          const n = this.nodes.get(it.location);
+          const n = this.locations.get(it.location);
           if (n) n.occupancy--;
           this.items.delete(c);
         }
@@ -1990,7 +2890,7 @@ var FlowEngine = class {
   }
   /**
    * containment 분해(EPCIS AggregationEvent DELETE) — 부모(용기)에서 자식들을 풀어냄.
-   * materialize 지정 시 자식이 독립 아이템으로 등장(materialize: 노드 배치 + occupancy + ObjectEvent ADD).
+   * materialize 지정 시 자식이 독립 아이템으로 등장(materialize: 자리 배치 + occupancy + ObjectEvent ADD).
    * 미지정 시 이벤트만.
    */
   disaggregate(parent, children, opts) {
@@ -2003,7 +2903,7 @@ var FlowEngine = class {
       const m = opts.materialize;
       for (const c of children) {
         this.items.set(c, { epc: c, location: m.location, disposition: m.disposition });
-        const n = this.nodes.get(m.location);
+        const n = this.locations.get(m.location);
         if (n) n.occupancy++;
         this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: opts.bizStep, disposition: m.disposition, epcList: [c], readPoint: m.location, bizLocation: m.location }));
       }
@@ -2011,22 +2911,22 @@ var FlowEngine = class {
   }
   /** 품질 보고(OEE Quality) — 도메인이 완료 시 자원별 양품/불량 1건 계상(예: 용접 수율). */
   recordOutput(moverId, good) {
-    const m = moverId ? this.movers.get(moverId) : void 0;
+    const m = moverId ? this.equipment.get(moverId) : void 0;
     if (!m) return;
     if (good) m.goodCount++;
     else m.scrapCount++;
     this.emitOp(OP_EVENT.quality, { moverId: m.id, good, goodCount: m.goodCount, scrapCount: m.scrapCount });
   }
-  /** 무버 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
+  /** 설비 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
   oeeOf(m) {
     return computeOee(m, this.clockMs);
   }
-  /** 정책에 넘길 특정 타입 노드의 관측 뷰 — 예약(그 노드로 향하는 in-flight task) 포함. */
-  slotViews(nodeType) {
+  /** 정책에 넘길 특정 타입 자리의 관측 뷰 — 예약(그 자리로 향하는 in-flight task) 포함. */
+  slotViews(locationType) {
     const reserved = /* @__PURE__ */ new Map();
     for (const t of this.tasks.values()) if (t.status !== "completed") reserved.set(t.toNode, (reserved.get(t.toNode) ?? 0) + 1);
     const views = [];
-    for (const n of this.nodes.values()) if (n.type === nodeType) views.push({ id: n.id, capacity: n.capacity, occupancy: n.occupancy, reserved: reserved.get(n.id) ?? 0 });
+    for (const n of this.locations.values()) if (n.type === locationType) views.push({ id: n.id, capacity: n.capacity, occupancy: n.occupancy, reserved: reserved.get(n.id) ?? 0 });
     return views;
   }
   emit(event) {
@@ -2062,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, assetClass: a.assetClass, 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, personnelClass: p.personnelClass, status: p.status, taskId: p.taskId ?? void 0, ...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` 를 함께 싣는다(사람·자산 델타와 같은 규칙). 없으면 미러가 "이 설비가
    *  무슨 일을 하는 중인가" 를 알 수 없어 작업↔자원 연결이 한쪽에서만 성립한다. */
-  emitMover(m, motion) {
-    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, taskId: m.taskId ?? void 0, motion });
+  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, ...m.held ? { held: true } : {}, ...effectiveOnly(m) });
   }
   /** 오더 델타 — **라인까지 싣는다.** 라인이 빠지면 미러가 남은 데맨드를 라인별로 재계획할 수 없다. */
   emitOrder(o) {
@@ -2087,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 })) } : {}
     });
   }
@@ -2156,7 +3064,9 @@ var FlowEngine = class {
       const want = Math.max(0, Math.floor(req.quantity ?? 0));
       if (!want) continue;
       const avail = [...this.assets.values()].filter(
-        (a) => a.status === "idle" && !picked.includes(a.id) && (req.assetClass === void 0 || a.assetClass === req.assetClass)
+        /* 인원과 같은 규칙 — 상속을 타고 닫아 판정하고 유효기간 밖은 제외한다. 요구는 등급 하나+수량. */
+        (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);
@@ -2174,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);
@@ -2205,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 [];
@@ -2213,7 +3311,11 @@ 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) && (req.personnelClass === void 0 || p.personnelClass === req.personnelClass)
+        (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))
       );
       if (avail.length < want) return null;
       for (let i = 0; i < want; i++) picked.push(avail[i].id);
@@ -2226,8 +3328,12 @@ var FlowEngine = class {
    * 여기서는 고르기만 한다 — 확정은 호출부가 다른 자원까지 확보한 뒤에 한다.
    */
   claimEquipment(t) {
-    const free = (kind, picked2 = []) => [...this.movers.values()].filter(
-      (m) => m.status === "idle" && !m.held && !this.offShift(m) && !picked2.includes(m.id) && (kind === void 0 || m.kind === kind)
+    const free = (kind, picked2 = []) => [...this.equipment.values()].filter(
+      (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))
     );
     const need = this.operationSpecs.get(t.kind)?.equipmentSpecification;
     if (!need?.length) {
@@ -2268,33 +3374,87 @@ 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` 을 선언한 자리만 판정한다(미선언=제약 없음).
    * 세는 대상은 **그 자리에서 진행 중인 작업**(`toNode` 기준, in-progress). 대기 중인 작업은 세지 않는다.
    */
-  stationFull(nodeId) {
-    if (!nodeId) return false;
-    const limit = this.nodes.get(nodeId)?.parallelism;
+  stationFull(locationId) {
+    if (!locationId) return false;
+    const limit = this.locations.get(locationId)?.parallelism;
     if (!(typeof limit === "number" && limit > 0)) return false;
     let running = 0;
-    for (const t of this.tasks.values()) if (t.status === "in-progress" && t.toNode === nodeId) running++;
+    for (const t of this.tasks.values()) if (t.status === "in-progress" && t.toNode === locationId) running++;
     return running >= limit;
   }
   /** 교대 밖인가 — 자원이 지금 일하지 않는 이유 중 고장·계획정지와 구별되는 세 번째. */
   offShift(m) {
-    const w = m.window;
-    if (!w) return false;
-    const h = this.hourOfDay();
-    return !(w.startHour <= w.endHour ? h >= w.startHour && h < w.endHour : h >= w.startHour || h < w.endHour);
+    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}`. **선언만 되고 소비처가 없던 필드**를 판정한다.
@@ -2312,19 +3472,19 @@ var FlowEngine = class {
     return -Math.log(1 - this.rng()) * meanMs;
   }
   /**
-   * 확률적 설비 고장(MTBF/MTTR) — mtbf 지정 무버만 참여(미지정=고장 없음, rng 무소비 → byte-identical).
+   * 확률적 설비 고장(MTBF/MTTR) — mtbf 지정 설비만 참여(미지정=고장 없음, rng 무소비 → byte-identical).
    * up: nextFailure 도래 시 down(수리까지 repairUntil). down: downMs 누적, repair 도래 시 up(다음 고장 예약).
-   * down 중 무버는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
+   * down 중 설비는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
    */
   processFailures(dt) {
-    for (const m of this.movers.values()) {
+    for (const m of this.equipment.values()) {
       if (m.status === "down") {
         m.downMs += dt;
         if (m.repairUntilMs != null && this.clockMs >= m.repairUntilMs) {
           m.status = m.taskId ? "busy" : "idle";
           m.repairUntilMs = void 0;
           if (m.mtbfMs !== void 0) m.nextFailureMs = this.clockMs + this.sampleExp(m.mtbfMs);
-          this.emitMover(m);
+          this.emitEquipment(m);
         }
         continue;
       }
@@ -2336,7 +3496,7 @@ var FlowEngine = class {
         m.status = "down";
         m.repairUntilMs = this.clockMs + this.sampleExp(m.mttrMs ?? m.mtbfMs);
         m.nextFailureMs = void 0;
-        this.emitMover(m);
+        this.emitEquipment(m);
       }
     }
   }
@@ -2354,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 } : {},
@@ -2363,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 } : {}
     };
@@ -2390,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);
   }
   /**
    * 작업 진행 — **진행을 먼저, 배정을 나중에.**
@@ -2404,54 +3569,87 @@ 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;
       }
       if (this.stationFull(t.toNode)) continue;
       const rigs = this.claimEquipment(t);
       if (!rigs) continue;
-      const mover = this.movers.get(rigs[0]);
-      if (t.setupMs && t.changeoverKey !== void 0 && mover.lastChangeoverKey !== void 0 && mover.lastChangeoverKey !== t.changeoverKey) {
+      const eq = this.equipment.get(rigs[0]);
+      if (t.setupMs && t.changeoverKey !== void 0 && eq.lastChangeoverKey !== void 0 && eq.lastChangeoverKey !== t.changeoverKey) {
         t.appliedSetupMs = t.setupMs;
         t.durationMs += t.setupMs;
       }
-      if (t.changeoverKey !== void 0) mover.lastChangeoverKey = t.changeoverKey;
+      if (t.changeoverKey !== void 0) eq.lastChangeoverKey = t.changeoverKey;
       for (const id of rigs) {
-        const m = this.movers.get(id);
+        const m = this.equipment.get(id);
         m.status = "busy";
         m.taskId = t.id;
       }
       t.status = "in-progress";
-      t.resource = mover.id;
+      t.resource = eq.id;
       t.remainingMs = t.durationMs;
       t.startedAtSimMs = this.clockMs;
       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.emitMover(mover);
-      else this.emitMover(mover, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
+      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 });
     }
   }
   /** in-progress 진행/완료 — 상태 효과는 전부 도메인(onTaskComplete). base 는 자원 해제·델타만. */
   advanceTasks(dt) {
     for (const t of this.tasks.values()) {
       if (t.status !== "in-progress") continue;
-      if (t.resource && this.movers.get(t.resource)?.status === "down") continue;
+      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);
@@ -2460,26 +3658,26 @@ var FlowEngine = class {
         this.emitTask(t);
         continue;
       }
-      const mover = this.movers.get(t.resource);
+      const eq = this.equipment.get(t.resource);
       const setup = t.appliedSetupMs ?? 0;
-      mover.setupMs += setup;
-      mover.runMs += t.durationMs - setup;
-      mover.status = "idle";
-      mover.taskId = null;
-      if (t.intent !== "process") mover.location = t.toNode;
+      eq.setupMs += setup;
+      eq.runMs += t.durationMs - setup;
+      eq.status = "idle";
+      eq.taskId = null;
+      if (t.intent !== "process") eq.location = t.toNode;
       for (const id of t.resources ?? []) {
-        if (id === mover.id) continue;
-        const m = this.movers.get(id);
+        if (id === eq.id) continue;
+        const m = this.equipment.get(id);
         if (!m) continue;
         m.setupMs += setup;
         m.runMs += t.durationMs - setup;
         m.status = "idle";
         m.taskId = null;
         if (t.intent !== "process") m.location = t.toNode;
-        this.emitMover(m);
+        this.emitEquipment(m);
       }
       this.emitTask(t);
-      this.emitMover(mover);
+      this.emitEquipment(eq);
     }
   }
 };
@@ -2496,10 +3694,11 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
   onArrival(spec) {
-    const dock = this.nodeByType("dock");
+    const dock = this.locationByType("dock");
     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();
@@ -2537,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);
@@ -2545,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) {
@@ -2561,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);
@@ -2575,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);
@@ -2586,14 +3795,14 @@ var WmsKernel = class extends FlowEngine {
    * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
    */
   allocate(o) {
-    const staging = this.nodeByType("staging");
+    const staging = this.locationByType("staging");
     if (!staging || !o.lines) return;
     const chosenAll = [];
     for (const line of o.lines) {
       const already = o.allocated.filter((e) => this.items.get(e)?.gtin === line.gtin).length;
       const need = line.requested - already;
       if (need <= 0) continue;
-      const available = [...this.items.values()].filter((i) => i.gtin === line.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "storage").map((i) => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
+      const available = [...this.items.values()].filter((i) => i.gtin === line.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === "storage").map((i) => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
       const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
       for (const epc of chosen) {
         o.allocated.push(epc);
@@ -2615,9 +3824,10 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
   onTaskComplete(t) {
-    const item = this.items.get(t.itemEpc);
-    const from = this.nodes.get(t.fromNode);
-    const to = this.nodes.get(t.toNode);
+    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--;
     to.occupancy++;
     item.location = to.id;
@@ -2635,7 +3845,7 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
   finalizeOrder(order, staging) {
-    const shipDock = this.nodeByType("dock-ship") ?? staging;
+    const shipDock = this.locationByType("dock-ship") ?? staging;
     const eventTime = this.now();
     const shipment = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
     order.shipmentEpc = shipment;
@@ -2668,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 {
@@ -2685,16 +3896,16 @@ 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) {
-    const gate = this.nodeByType("gate");
-    const doors = [...this.nodes.values()].filter((n) => n.type === "dock-door").sort((a, b) => a.id.localeCompare(b.id));
+  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;
     const inbound = kind === "appointment";
     const epc = graiUri(CP, "10", ++this.epcSeq);
@@ -2709,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);
@@ -2731,15 +3959,15 @@ var YmsKernel = class extends FlowEngine {
     const trailer = this.items.get(o.allocated[0]);
     if (!trailer) return;
     if (this.clockMs < (o.windowStartMs ?? 0)) return;
-    const door = this.nodes.get(o.dockDoor);
+    const door = this.locations.get(o.dockDoor);
     const inflight = [...this.tasks.values()].some((t) => t.status !== "completed" && t.toNode === door.id);
     if (door.occupancy > 0 || inflight) return;
     const mode = this.apptMode.get(o.id) ?? "drop";
-    if (mode === "drop" && this.nodes.get(trailer.location)?.type !== "yard-slot") return;
+    if (mode === "drop" && this.locations.get(trailer.location)?.type !== "yard-slot") return;
     const outbound = o.kind === "appointment-out";
     const bizStep = outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading;
     if (outbound) {
-      const staging = this.nodeByType("staging");
+      const staging = this.locationByType("staging");
       const reserved = new Set([...this.trailerCargo.values()].flat());
       const avail = [...this.items.values()].filter((i) => i.location === staging?.id && i.disposition === DISP.sellable && !reserved.has(i.epc)).sort((a, b) => a.epc.localeCompare(b.epc));
       if (!staging || avail.length < CARGO_PER_TRAILER) return;
@@ -2756,14 +3984,15 @@ var YmsKernel = class extends FlowEngine {
   }
   /** 태스크 완료 — 목적지 타입으로 분기: yard-slot=주차, dock-door=상/하차+depart, gate=출차. */
   onTaskComplete(t) {
-    const trailer = this.items.get(t.itemEpc);
-    const from = this.nodes.get(t.fromNode);
-    const to = this.nodes.get(t.toNode);
+    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--;
     to.occupancy++;
     trailer.location = to.id;
     if (t.kind === "dwell") {
-      const gate = this.nodeByType("gate");
+      const gate = this.locationByType("gate");
       const dep = { id: `task-${++this.taskSeq}`, kind: "depart", status: "created", itemEpc: trailer.epc, fromNode: t.toNode, toNode: gate.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "depart", fromNode: t.toNode, toNode: gate.id }, TRAVEL_MS2), orderId: t.orderId };
       this.tasks.set(dep.id, dep);
       this.emitTask(dep);
@@ -2777,7 +4006,7 @@ var YmsKernel = class extends FlowEngine {
     if (to.type === "dock-door") {
       const order2 = t.orderId ? this.orders.get(t.orderId) : void 0;
       const outbound = order2?.kind === "appointment-out";
-      const staging = this.nodeByType("staging");
+      const staging = this.locationByType("staging");
       const cargo = this.trailerCargo.get(trailer.epc) ?? [];
       this.observeDisposition([trailer.epc], DISP.in_progress, outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading, to.id);
       if (outbound) {
@@ -2829,10 +4058,10 @@ var MES_PART_GTINS = { partA: PART_A.gtin, partB: PART_B.gtin };
 var MES_PRODUCT_GTINS = { p1: PRODUCTS[0].gtin, p2: PRODUCTS[1].gtin };
 var MES_PRODUCTS = PRODUCTS.map((p) => ({ gtin: p.gtin, label: p.key }));
 var ROUTE = [
-  { kind: "cut", node: "cut-station", resource: "cutter" },
-  { kind: "weld", node: "weld-station", resource: "welder" },
-  { kind: "paint", node: "paint-booth", resource: "painter" },
-  { kind: "assembly", node: "assembly-line", resource: "assembler" }
+  { kind: "cut", locationType: "cut-station", resource: "cutter" },
+  { kind: "weld", locationType: "weld-station", resource: "welder" },
+  { kind: "paint", locationType: "paint-booth", resource: "painter" },
+  { kind: "assembly", locationType: "assembly-line", resource: "assembler" }
 ];
 var MesKernel = class extends FlowEngine {
   wipSeq = 0;
@@ -2842,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);
@@ -2857,12 +4108,12 @@ var MesKernel = class extends FlowEngine {
     if (cmd.type === MES_CMD.changeover) {
       const a = cmd.args;
       if (!a?.resourceId || !a?.gtin) return { commandId: cmd.commandId, accepted: false, errorCode: "changeover-needs-args", error: "mes.changeover: resourceId and gtin required" };
-      const m = this.movers.get(a.resourceId);
+      const m = this.equipment.get(a.resourceId);
       if (!m) return { commandId: cmd.commandId, accepted: false, errorCode: "resource-not-found", errorParams: { resourceId: a.resourceId }, error: `resource-not-found: ${a.resourceId}` };
       if (m.lastChangeoverKey !== a.gtin) {
         m.setupMs += DEFAULT_SETUP_MS;
         m.lastChangeoverKey = a.gtin;
-        this.emitMover(m);
+        this.emitEquipment(m);
       }
       return { commandId: cmd.commandId, accepted: true };
     }
@@ -2871,7 +4122,7 @@ var MesKernel = class extends FlowEngine {
   /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
   onArrival(spec) {
     if (this.mesSpec) return this.onArrivalDef(spec);
-    const rawStore = this.nodeByType("raw-store");
+    const rawStore = this.locationByType("raw-store");
     if (!rawStore) return;
     const gtin = this.pickGtin(spec.content.skuMix);
     const part = [PART_A, PART_B].find((p) => p.gtin === gtin);
@@ -2887,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);
   }
@@ -2895,12 +4146,12 @@ var MesKernel = class extends FlowEngine {
   allocate(o) {
     if (this.mesSpec) return this.allocateDef(o);
     const s0 = ROUTE[0];
-    const first = this.nodeByType(s0.node);
+    const first = this.locationByType(s0.locationType);
     const product = this.productOf(o.gtin);
     if (!first || !product) return;
     const picks = [];
     for (const line of product.bom) {
-      const available = [...this.items.values()].filter((i) => i.gtin === line.part.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
+      const available = [...this.items.values()].filter((i) => i.gtin === line.part.gtin && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
       const chosen = this.policy.selectStock({ gtin: line.part.gtin, qty: line.qty, available });
       if (chosen.length < line.qty) return;
       picks.push(...chosen);
@@ -2914,23 +4165,36 @@ var MesKernel = class extends FlowEngine {
   }
   /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(process), 이종 자원, 제품 전환 셋업. */
   emitStation(o, stage, itemEpc, changeoverKey) {
-    const node = this.nodeByType(stage.node);
-    const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: node.id, toNode: node.id, resourceKind: stage.resource }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: this.paramDuration(stage.kind, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: "process" };
+    const loc = this.locationByType(stage.locationType);
+    const task = { id: `task-${++this.taskSeq}`, kind: stage.kind, status: "created", itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: stage.kind, fromNode: loc.id, toNode: loc.id, resourceKind: stage.resource }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: stage.resource, changeoverKey, setupMs: this.paramDuration(stage.kind, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: "process" };
     this.tasks.set(task.id, task);
     this.emitTask(task);
   }
   /** 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 node = this.nodes.get(t.toNode);
+    const loc = this.locations.get(t.toNode);
     const isLast = i === ROUTE.length - 1;
     if (!isLast) {
       const inputs = order.allocated.slice();
       const wip2 = sgtinUri(CP2, WIP_ITEMREF, ++this.wipSeq);
-      this.transform(inputs, [{ epc: wip2, gtin: WIP_GTIN, qty: 1, location: node.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+      this.transform(inputs, [{ epc: wip2, gtin: WIP_GTIN, qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
       order.allocated = [wip2];
       const next = ROUTE[i + 1];
       this.emitStation(order, next, wip2, product.gtin);
@@ -2938,13 +4202,13 @@ var MesKernel = class extends FlowEngine {
       this.emitOrder(order);
       return;
     }
-    const fgStore = this.nodeByType("fg-store");
+    const fgStore = this.locationByType("fg-store");
     const wip = order.allocated[0];
     const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outputEpc = sgtinUri(CP2, product.ref, ++this.prodSeq);
-    this.transform([wip], [{ epc: outputEpc, gtin: product.gtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep: MES_BIZSTEP.producing, disposition: disp, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+    this.transform([wip], [{ epc: outputEpc, gtin: product.gtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep: MES_BIZSTEP.producing, disposition: disp, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
     this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: MES_BIZSTEP.storing, disposition: disp, epcList: [outputEpc], quantityList: [{ epcClass: product.gtin, quantity: 1 }], readPoint: fgStore.id, bizLocation: fgStore.id }));
     order.allocated = [];
     order.fulfilled = 1;
@@ -2963,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;
@@ -2971,9 +4246,10 @@ var MesKernel = class extends FlowEngine {
   }
   /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 raw-store 에 생성. */
   onArrivalDef(spec) {
-    const rawStore = this.nodeByType("raw-store");
+    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);
@@ -2986,19 +4262,19 @@ 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);
   }
   /** 정의 모드 할당 — 레시피 입력 BOM 전량 확보 후 첫 라우트 스텝 태스크. */
   allocateDef(o) {
     const ops = this.routeOps();
-    if (!ops.length || !ops[0].nodeType || !this.nodeByType(ops[0].nodeType)) return;
+    if (!ops.length || !ops[0].locationType || !this.locationByType(ops[0].locationType)) return;
     const rc = this.recipeDef();
     const picks = [];
     for (const line of rc.inputs) {
       const g = this.classOf(line.material);
-      const available = [...this.items.values()].filter((i) => i.gtin === g && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
+      const available = [...this.items.values()].filter((i) => i.gtin === g && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
       const chosen = this.policy.selectStock({ gtin: g, qty: line.qty, available });
       if (chosen.length < line.qty) return;
       picks.push(...chosen);
@@ -3011,25 +4287,26 @@ var MesKernel = class extends FlowEngine {
     this.emitOrder(o);
   }
   emitStationDef(o, op, itemEpc) {
-    const node = this.nodeByType(op.nodeType);
-    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc, fromNode: node.id, toNode: node.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: node.id, toNode: node.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
+    const loc = this.locationByType(op.locationType);
+    const task = { id: `task-${++this.taskSeq}`, kind: op.key, status: "created", itemEpc, fromNode: loc.id, toNode: loc.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: op.key, fromNode: loc.id, toNode: loc.id, resourceKind: op.resourceType }, DEFAULT_CYCLE_MS), orderId: o.id, resourceType: op.resourceType, changeoverKey: o.gtin, setupMs: this.paramDuration(op.key, OP_PARAM.setupDuration) ?? DEFAULT_SETUP_MS, intent: op.intent };
     this.tasks.set(task.id, task);
     this.emitTask(task);
   }
   /** 정의 모드 완료 — 라우트 인덱스: 중간=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);
-    const node = this.nodes.get(t.toNode);
+    const loc = this.locations.get(t.toNode);
     const bizStep = ops[i]?.bizStep ?? MES_BIZSTEP.producing;
     const isLast = i === ops.length - 1;
     if (!isLast) {
       const inputs = order.allocated.slice();
       const wip2 = sgtinUri(this.mesSpec.companyPrefix, "WIP", ++this.wipSeq);
       const wipGtin = sgtinClass(this.mesSpec.companyPrefix, "WIP");
-      this.transform(inputs, [{ epc: wip2, gtin: wipGtin, qty: 1, location: node.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+      this.transform(inputs, [{ epc: wip2, gtin: wipGtin, qty: 1, location: loc.id, disposition: DISP.in_progress }], { bizStep, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
       order.allocated = [wip2];
       const next = ops[i + 1];
       this.emitStationDef(order, next, wip2);
@@ -3037,14 +4314,14 @@ var MesKernel = class extends FlowEngine {
       this.emitOrder(order);
       return;
     }
-    const fgStore = this.nodeByType("fg-store");
+    const fgStore = this.locationByType("fg-store");
     const wip = order.allocated[0];
     const good = this.rng() < (this.paramNumber(t.kind, OP_PARAM.yield) ?? DEFAULT_YIELD);
     this.recordOutput(t.resource, good);
     const disp = good ? DISP.sellable : DISP.non_sellable;
     const outEpc = this.serialOf(rc.outputs[0].material, ++this.prodSeq);
     const outGtin = this.classOf(rc.outputs[0].material);
-    this.transform([wip], [{ epc: outEpc, gtin: outGtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep, disposition: disp, transformationId: order.bizTransaction, readPoint: node.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+    this.transform([wip], [{ epc: outEpc, gtin: outGtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep, disposition: disp, transformationId: order.bizTransaction, readPoint: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
     this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: MES_BIZSTEP.storing, disposition: disp, epcList: [outEpc], quantityList: [{ epcClass: outGtin, quantity: 1 }], readPoint: fgStore.id, bizLocation: fgStore.id }));
     order.allocated = [];
     order.fulfilled = 1;
@@ -3052,6 +4329,43 @@ var MesKernel = class extends FlowEngine {
     this.emitOrder(order);
   }
 };
+
+// src/vocabulary.ts
+var RETIRED_VOCABULARY = ["mover", "Mover", "MOVER", "node", "Node", "NODE"];
+var VOCABULARY_EXCEPTIONS = [
+  /* ── 저널 와이어 필드 — append-only 역사이므로 이름을 바꾸지 않는다 ───────
+   * 같은 사실이 시점에 따라 다른 키로 들어가면 낡은 이름보다 나쁘다. 개명은 이벤트 스키마
+   * 버저닝과 함께 다룬다. (개명 시점 실측: moverId 8,965행 · fromNode/toNode 9,679행) */
+  { token: "moverId", why: "journal wire field \u2014 renaming would mix two keys for one fact across history" },
+  { token: "fromNode", why: "journal wire field (task.status payload)" },
+  { token: "toNode", why: "journal wire field (task.status payload)" },
+  /* ── 씬 컴포넌트 타입 — 보드에 저장된 값이고, 뜻이 어긋나지도 않는다 ──────
+   * 보드 7개가 이 타입으로 컴포넌트를 담고 있어 개명하면 그 컴포넌트가 조용히 안 그려진다.
+   * 그리고 씬에서 이 이름은 자원이 아니라 **움직임 표현**을 가리킨다(표준과 충돌 아님). */
+  { token: "twin-mover", why: "scene component type persisted in boards; names a motion representation, not a resource" },
+  { token: "TwinMover", why: "class backing the persisted scene component type above" },
+  /* ── 플랫폼·언어 어휘 — 우리 도메인 낱말이 아니다 ─────────────────────── */
+  { token: "node_modules", why: "npm path" },
+  { token: "node:", why: "Node.js builtin module specifier" },
+  { token: "nodemon", why: "tool name" },
+  { token: "Node.js", why: "platform name" },
+  { token: "NodeJS", why: "TypeScript global namespace" },
+  { token: "nodeName", why: "DOM API" },
+  { token: "childNodes", why: "DOM API" },
+  { token: "appendChild", why: "DOM API (no match, kept for clarity)" }
+];
+var GUARD_PRAGMA = "vocabulary-guard: allow";
+function retiredVocabularyIn(line) {
+  if (line.includes(GUARD_PRAGMA)) return [];
+  let rest = line;
+  for (const { token } of VOCABULARY_EXCEPTIONS) rest = rest.split(token).join(" ");
+  const hits = [];
+  for (const word of RETIRED_VOCABULARY) {
+    const re = new RegExp(`[A-Za-z_]*${word}[A-Za-z_]*`, "g");
+    for (const m of rest.matchAll(re)) hits.push(m[0]);
+  }
+  return hits;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BIZSTEP,
@@ -3060,65 +4374,99 @@ var MesKernel = class extends FlowEngine {
   BTT_PRODORDER,
   CAPABILITIES,
   CAPABILITY_KEYS,
+  CBV_BIZSTEP,
   CMD,
   DISP,
   DOMAIN_CATALOG,
   DOMAIN_SYSTEMS,
   EPCIS_CONTEXT,
+  EQUIPMENT_LEVEL,
   EventJournal,
   FlowEngine,
+  GUARD_PRAGMA,
   ILMD_ATTR,
+  LOCATION_SATURATION_NEAR,
+  MATERIAL_PROPERTY,
   MES_BIZSTEP,
-  MES_NODE_TYPES,
+  MES_LOCATION_TYPES,
   MES_PART_GTINS,
   MES_PRODUCTS,
   MES_PRODUCT_GTINS,
   MES_TYPES,
   MesKernel,
-  NODE_SATURATION_NEAR,
   OP_EVENT,
   OP_PARAM,
   ObservedReducer,
+  PRIORITY_UNSET,
+  RETIRED_VOCABULARY,
   StateProjector,
   TwinHistory,
   TwinObserver,
   TwinRuntime,
   UTC_OFFSET,
-  WMS_NODE_TYPES,
+  VOCABULARY_EXCEPTIONS,
+  WMS_LOCATION_TYPES,
   WMS_TYPES,
   WmsKernel,
   YARD_BIZSTEP,
-  YMS_NODE_TYPES,
+  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,
-  nodeStatusOf,
   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
 });