@operato/twin-kernel 0.7.39 → 0.7.40

package/dist-cjs/index.cjs

@@ -46,13 +46,11 @@ __export(index_exports, {
   FlowEngine: () => FlowEngine,
   GUARD_PRAGMA: () => GUARD_PRAGMA,
   ILMD_ATTR: () => ILMD_ATTR,
+  ItemStore: () => ItemStore,
   LOCATION_SATURATION_NEAR: () => LOCATION_SATURATION_NEAR,
   MATERIAL_PROPERTY: () => MATERIAL_PROPERTY,
   MES_BIZSTEP: () => MES_BIZSTEP,
   MES_LOCATION_TYPES: () => MES_LOCATION_TYPES,
-  MES_PART_GTINS: () => MES_PART_GTINS,
-  MES_PRODUCTS: () => MES_PRODUCTS,
-  MES_PRODUCT_GTINS: () => MES_PRODUCT_GTINS,
   MES_TYPES: () => MES_TYPES,
   MesKernel: () => MesKernel,
   OPERATION_PROPERTY: () => OPERATION_PROPERTY,
@@ -86,9 +84,11 @@ __export(index_exports, {
   axisAppliesTo: () => axisAppliesTo,
   axisInfo: () => axisInfo,
   axisSource: () => axisSource,
+  bizTransactionUri: () => bizTransactionUri,
   capabilitiesForType: () => capabilitiesForType,
   capabilityOf: () => capabilityOf,
   classClosure: () => classClosure,
+  classIdentifierViolation: () => classIdentifierViolation,
   commandsOf: () => commandsOf,
   compareStates: () => compareStates,
   computeOee: () => computeOee,
@@ -112,6 +112,7 @@ __export(index_exports, {
   generationFractionAt: () => generationFractionAt,
   graiUri: () => graiUri,
   hierarchyOf: () => hierarchyOf,
+  identityGroundingOf: () => identityGroundingOf,
   inWorkCalendar: () => inWorkCalendar,
   inWorkCalendarAt: () => inWorkCalendarAt,
   ingest: () => ingest,
@@ -604,6 +605,24 @@ function readBoardAssets(def) {
   const list = def.assets ?? [];
   return list.map((a) => normalizeHomeLocation(a));
 }
+function identityGroundingOf(spec, kernelConstantPrefix) {
+  const declared = spec?.identity?.namespaces?.filter((n) => typeof n === "string" && n.length > 0) ?? [];
+  if (spec?.identity?.issuedClaim && declared.length) {
+    return { grounding: "issued", basis: "claimed-issued", namespaces: [...declared] };
+  }
+  if (declared.length) return { grounding: "declared", basis: "declared-namespace", namespaces: [...declared] };
+  if (spec?.companyPrefix && spec.binding) {
+    return { grounding: "declared", basis: "gs1-shaped", namespaces: gs1Namespaces(spec.companyPrefix) };
+  }
+  return {
+    grounding: "fabricated",
+    basis: "kernel-constant",
+    namespaces: kernelConstantPrefix ? gs1Namespaces(kernelConstantPrefix) : []
+  };
+}
+function gs1Namespaces(prefix) {
+  return [`urn:epc:idpat:sgtin:${prefix}.`, `urn:epc:class:lgtin:${prefix}.`, `urn:epc:id:sgtin:${prefix}.`];
+}
 
 // src/scenario-validate.ts
 var DISTRIBUTIONS = /* @__PURE__ */ new Set(["poisson", "uniform", "constant", "profile"]);
@@ -677,6 +696,7 @@ function validateDomainDefinition(def) {
   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 matByKey = new Map((def.materials || []).map((m) => [m.key, m]));
   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 [["locationTypes", def.locationTypes], ["resourceTypes", def.resourceTypes], ["materials", def.materials], ["operations", def.operations], ["routes", def.routes], ["recipes", def.recipes]]) {
@@ -698,6 +718,9 @@ function validateDomainDefinition(def) {
     for (const p of [...rc.inputs || [], ...rc.outputs || []]) {
       if (!matKeys.has(p.material)) v.push(`recipe '${rc.key}' material '${p.material}' \uBBF8\uC815\uC758`);
       if (typeof p.qty !== "number" || p.qty <= 0) v.push(`recipe '${rc.key}' material '${p.material}' qty \uBD80\uC815`);
+      const mat = matByKey.get(p.material);
+      if (mat && !mat.locationType) v.push(`recipe '${rc.key}' material '${p.material}' locationType \uBBF8\uC120\uC5B8`);
+      if (mat?.locationType && !locationKeys2.has(mat.locationType)) v.push(`recipe '${rc.key}' material '${p.material}' locationType '${mat.locationType}' \uBBF8\uC815\uC758`);
     }
   }
   return v;
@@ -923,6 +946,16 @@ function parseEpc(uri) {
 function gdtiUri(companyPrefix, docType, serial) {
   return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
 }
+function bizTransactionUri(namespace, transId) {
+  const ns = namespace?.trim();
+  if (!ns) return void 0;
+  const id = String(transId);
+  if (!id || id.includes("/") || id.includes(":")) return void 0;
+  if (/^https?:\/\/[^/\s]+/.test(ns)) return `${ns.replace(/\/+$/, "")}/bt/${id}`;
+  if (/^urn:epc(global)?:/.test(ns)) return void 0;
+  if (/^urn:[^:\s]+/.test(ns)) return `${ns.replace(/:+$/, "")}:bt:${id}`;
+  return void 0;
+}
 function header(type, eventTime, bizStep, opts) {
   const h = {
     "@context": EPCIS_CONTEXT,
@@ -992,6 +1025,17 @@ function transformationEvent(p) {
 var ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
 var TZ_RE = /^[+-]\d{2}:\d{2}$/;
 var ACTIONS = ["ADD", "OBSERVE", "DELETE"];
+var EPC_CLASS_PREFIXES = ["urn:epc:idpat:", "urn:epc:class:"];
+var DL_CANONICAL = "https://id.gs1.org/";
+var CBV_URL_CLASS = /^https?:\/\/[^/\s]+\/(?:[^/\s]+\/)*class\/[^/\s]+$/;
+var CBV_URN_CLASS = /^urn:[^:\s]+:(?:[^:\s]+:)*class:[^:\s]+$/;
+function classIdentifierViolation(epcClass) {
+  if (!epcClass) return `quantity epcClass \uBD80\uC815: ${epcClass}`;
+  if (EPC_CLASS_PREFIXES.some((p) => epcClass.startsWith(p))) return void 0;
+  if (epcClass.startsWith(DL_CANONICAL)) return void 0;
+  if (CBV_URL_CLASS.test(epcClass) || CBV_URN_CLASS.test(epcClass)) return void 0;
+  return `quantity epcClass \uBD80\uC815: ${epcClass} \u2014 \uD074\uB798\uC2A4 \uC2DD\uBCC4\uC790\uB294 \uC18C\uC720 \uAD8C\uD55C\uC744 \uB9D0\uD560 \uC218 \uC788\uB294 \uBAA8\uC591\uC774\uC5B4\uC57C \uD55C\uB2E4 (EPC \uD074\uB798\uC2A4 urn:epc:idpat:/urn:epc:class: \xB7 CBV \xA78.3.4 http(s)://<\uB3C4\uBA54\uC778>/**/class/<id> \xB7 CBV \xA78.3.3 urn:<\uC774\uB984\uACF5\uAC04>:**:class:<id>)`;
+}
 function validateEpcisEvent(e) {
   const v = [];
   if (e["@context"] !== EPCIS_CONTEXT) v.push("@context \uB204\uB77D/\uBD88\uC77C\uCE58");
@@ -1059,7 +1103,8 @@ function validateEpcisEvent(e) {
     "outputQuantityList" in e ? e.outputQuantityList : void 0
   ];
   for (const list of qtyLists) for (const q of list ?? []) {
-    if (!q.epcClass?.startsWith("urn:epc:idpat:") && !q.epcClass?.startsWith("urn:epc:class:")) v.push(`quantity epcClass \uBD80\uC815: ${q.epcClass}`);
+    const bad2 = classIdentifierViolation(q.epcClass);
+    if (bad2) v.push(bad2);
     const hasQty = q.quantity !== void 0 && q.quantity !== null;
     if (!hasQty) {
       if (q.uom !== void 0) v.push("quantity \uC5C6\uC73C\uBA74 uom \uB3C4 \uC5C6\uC5B4\uC57C \uD55C\uB2E4(\uC218\uB7C9 \uBBF8\uC9C0\uC815)");
@@ -1376,6 +1421,8 @@ var ObservedReducer = class {
           /* 진행 중 확보분과 거래번호 — **미러도 같은 필드를 채운다.** 시뮬만 아는 사실을 두면
              그 위에서 세운 예측이 두 구동에서 달라진다(패리티 검사가 지키는 것이 이것이다). */
           ...d.gtin ? { gtin: d.gtin } : {},
+          /* 어느 레시피로 만드는가 — 품목만으로는 「무엇으로」가 남지 않는다(같은 품목에 대체 레시피). */
+          ...d.recipeKey ? { recipeKey: d.recipeKey } : {},
           ...d.allocated?.length ? { allocated: d.allocated.slice() } : {},
           ...d.bizTransaction ? { bizTransaction: d.bizTransaction } : {},
           /* 약속해 둔 자리·시각창도 채운다 — 시뮬만 알면 미러 위 예측이 「어디로 들일지」를 모른다.
@@ -1449,7 +1496,7 @@ var ObservedReducer = class {
           const cur = this.items.get(ev.parentID);
           if (!cur) this.pendingQuantities.set(ev.parentID, [...ev.childQuantityList]);
           else {
-            this.items.set(cur.subLotId ?? cur.epc, this.withContainedQuantity(cur, q2, ev.childQuantityList));
+            this.items.set(itemKeyOf(cur), this.withContainedQuantity(cur, q2, ev.childQuantityList));
             this.qtyAggregation.set(ev.parentID, [...ev.childQuantityList]);
           }
         }
@@ -1475,7 +1522,7 @@ var ObservedReducer = class {
           const cur = this.items.get(ev.parentID);
           if (cur) {
             const { gtin, gtinKey, qty, uom, quantities, lot, ...rest } = cur;
-            this.items.set(cur.subLotId ?? cur.epc, { ...rest, qty: 1 });
+            this.items.set(itemKeyOf(cur), { ...rest, qty: 1 });
           }
         }
         this.pendingQuantities.delete(ev.parentID);
@@ -1533,7 +1580,7 @@ var ObservedReducer = class {
     return void 0;
   }
   mergeItem(epc, patch, q, all, subLotId) {
-    const cur = this.items.get(subLotId ?? epc);
+    const cur = this.items.get(itemKeyOf({ epc, subLotId }));
     const parsedClass = q?.epcClass ? parseEpc(q.epcClass) : void 0;
     const parsedSelf = parseEpc(epc);
     const pendingQty = this.pendingQuantities.get(epc);
@@ -2822,8 +2869,21 @@ function mapRecordChecked(record, mapping, eventTime) {
     };
   }
   const epc = resolve(mapping.epc, record, "epc", errors);
+  const quantityList = resolveQuantityList(mapping.quantityList, record, "quantityList", errors);
+  if (!epc && !quantityList.length) {
+    errors.push("epc \uC640 quantityList \uAC00 \uB458 \uB2E4 \uBE44\uC5C8\uB2E4 \u2014 \uAC1C\uCCB4 \uC2DD\uBCC4\uC790\uB098 \uD074\uB798\uC2A4+\uC218\uB7C9 \uC911 \uD558\uB098\uB294 \uC788\uC5B4\uC57C \uD55C\uB2E4");
+  }
   return {
-    event: objectEvent({ eventTime, action, bizStep, disposition, epcList: epc ? [epc] : [], readPoint, bizLocation }),
+    event: objectEvent({
+      eventTime,
+      action,
+      bizStep,
+      disposition,
+      epcList: epc ? [epc] : [],
+      ...quantityList.length ? { quantityList } : {},
+      readPoint,
+      bizLocation
+    }),
     errors
   };
 }
@@ -3262,10 +3322,124 @@ function energyFieldsOf(m) {
   }
   return out;
 }
+var ItemStore = class _ItemStore {
+  map = /* @__PURE__ */ new Map();
+  byLocation = /* @__PURE__ */ new Map();
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  values() {
+    return this.map.values();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  [Symbol.iterator]() {
+    return this.map[Symbol.iterator]();
+  }
+  forEach(fn) {
+    this.map.forEach((v, k) => fn(v, k));
+  }
+  set(key, item) {
+    const prev = this.map.get(key);
+    if (prev) this.unindex(key, prev.location);
+    this.map.set(key, item);
+    this.index(key, item.location);
+    return this;
+  }
+  delete(key) {
+    const prev = this.map.get(key);
+    if (prev) this.unindex(key, prev.location);
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+    this.byLocation.clear();
+  }
+  /**
+   * 물품을 다른 자리로 옮긴다 — **색인이 함께 움직이는 유일한 통로.**
+   *
+   * 없는 물품을 옮기라는 요청은 조용히 넘기지 않는다: 그 요청을 낸 쪽의 계산이 이미 어긋난 것이고,
+   * 지나가면 그 뒤의 이동·처분이 엉뚱한 자리에 적힌다.
+   */
+  relocate(key, to) {
+    const it = this.map.get(key);
+    if (!it) throw new Error(`relocate: \uBB3C\uD488 '${key}' \uC774 \uC0C1\uD0DC\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uC5C6\uB294 \uAC83\uC744 \uC62E\uAE38 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
+    if (it.location !== to) {
+      this.unindex(key, it.location);
+      it.location = to;
+      this.index(key, to);
+    }
+    return it;
+  }
+  /**
+   * 사본 — **자기 복제 방법을 스스로 안다.**
+   *
+   * `fork()` 는 `Map` 만 알고 나머지는 `structuredClone` 으로 복제한다. 그 함수는 클래스의 메서드를
+   * 복제하지 못하므로(평범한 객체가 된다), 저장소가 복제를 맡지 않으면 사본의 물품 조회가 통째로
+   * 깨진다 — 실제로 그렇게 42건이 붉어졌다. 복제 방법을 아는 객체가 스스로 복제한다.
+   */
+  clone() {
+    const out = new _ItemStore();
+    for (const [k, it] of this.map) out.set(k, structuredClone(it));
+    return out;
+  }
+  /** 그 자리에 있는 물품들 — 색인이 답한다(전체 순회가 아니다). */
+  at(location) {
+    const keys = this.byLocation.get(location);
+    if (!keys) return [];
+    const out = [];
+    for (const k of keys) {
+      const it = this.map.get(k);
+      if (it) out.push(it);
+    }
+    return out;
+  }
+  /**
+   * 색인이 맵과 어긋난 자리 — **시험이 쓰는 확인 통로**(전체를 다시 세므로 비싸다).
+   *
+   * 어긋남은 조용한 결함이다(자재가 있는데 없다고 판정된다). 그래서 「어긋나지 않을 것이다」를 믿지 않고
+   * 시나리오를 돌린 뒤 이 값으로 확인한다.
+   */
+  indexDrift() {
+    const drift = [];
+    for (const [key, it] of this.map) {
+      if (!this.byLocation.get(it.location)?.has(key)) drift.push(`${key} \uC774 '${it.location}' \uC0C9\uC778\uC5D0 \uC5C6\uB2E4`);
+    }
+    for (const [loc, keys] of this.byLocation) {
+      for (const k of keys) {
+        const it = this.map.get(k);
+        if (!it) drift.push(`${k} \uC774 \uC9C0\uC6CC\uC84C\uB294\uB370 '${loc}' \uC0C9\uC778\uC5D0 \uB0A8\uC544 \uC788\uB2E4`);
+        else if (it.location !== loc) drift.push(`${k} \uC740 '${it.location}' \uC5D0 \uC788\uB294\uB370 '${loc}' \uC0C9\uC778\uC5D0 \uC788\uB2E4`);
+      }
+    }
+    return drift;
+  }
+  index(key, location) {
+    const set = this.byLocation.get(location) ?? /* @__PURE__ */ new Set();
+    set.add(key);
+    this.byLocation.set(location, set);
+  }
+  unindex(key, location) {
+    const set = this.byLocation.get(location);
+    if (!set) return;
+    set.delete(key);
+    if (!set.size) this.byLocation.delete(location);
+  }
+};
 var FlowEngine = class {
   tenantId;
   locations = /* @__PURE__ */ new Map();
-  items = /* @__PURE__ */ new Map();
+  items = new ItemStore();
   equipment = /* @__PURE__ */ new Map();
   /** 등급 정의(표준 `<X>Class`) — 상속·유효기간 판정의 재료. 선언 안 하면 비어 있고, 소속 그대로 판정한다. */
   classDefs = {};
@@ -3329,6 +3503,21 @@ var FlowEngine = class {
   /** 관측 구동(P0) — 이벤트를 접는 투영기와 그 사실. tick 과 섞이지 않게 명시적으로 들고 있다. */
   observer;
   /** 관측분이 아직 커널 상태로 옮겨지지 않았다 — 스냅샷·fork 직전에 한 번만 옮긴다. */
+  /**
+   * **관측 모드에서 원본과 어긋난 횟수** — 받아들였지만 사실이 맞지 않았다.
+   *
+   * 미러는 원본을 비추는 쪽이라 어긋남을 만나도 멈추지 않는다(멈추면 원본의 한 건이 트윈 전체를
+   * 세운다). 그래서 **세어 둔다** — 세지 않으면 그 결함이 아무 데도 드러나지 않고, 화면은 어긋난 적이
+   * 없는 트윈과 구별되지 않는다.
+   */
+  /**
+   * **씨앗이 심지 못한 참조의 수** — 원본이 말했지만 그 물품이 스냅샷에 없었다.
+   *
+   * 0 이 아니면 이 트윈의 상태는 원본의 일부를 담지 못했다는 뜻이다. 예측·집계가 그 사실을 모르면
+   * 부족한 씨앗 위에서 낸 답을 완전한 답으로 읽는다.
+   */
+  seedDanglingRefs = 0;
+  transformInputsAbsent = 0;
   observedDirty = false;
   observeMode = false;
   /** 관측 구동이 투영기를 세울 때 필요한 원본 보드(구조는 이벤트가 아니라 마스터에서 온다). */
@@ -3533,6 +3722,24 @@ var FlowEngine = class {
     for (const id of snap?.acked ?? []) this._acked.add(id);
     for (const e of snap?.attentionSince ?? []) if (e?.id && e.since) this._attentionSince.set(e.id, e.since);
   }
+  /**
+   * 씨앗의 확보분 중 **이 트윈에 실제로 있는 것만** 남긴다 — 없는 것은 세고 버린다.
+   *
+   * 원본이 확보분을 말했는데 그 물품이 스냅샷에 없으면, 그 참조는 심는 순간 이미 사실이 아니다.
+   * 심어 두면 나중에 틱에서 드러나고(시뮬은 없는 것을 소비하지 않으므로 멈춘다) 그 판정이 예측
+   * 경로에서 터지면 원본의 빈틈 하나가 답 전체를 서버 오류로 죽인다.
+   *
+   * 그래서 심을 때 맞춘다. **없는 물품을 만들어 채우지 않는다** — 채우면 계보와 재고가 거짓 위에 선다.
+   * 대신 몇 건이 맞지 않았는지 남겨 씨앗이 불완전했다는 사실을 답에 실을 수 있게 한다.
+   */
+  resolvedAllocated(allocated) {
+    const all = allocated ?? [];
+    if (!all.length) return { kept: [], dropped: 0 };
+    const kept = all.filter((epc) => this.items.has(epc));
+    const dropped = all.length - kept.length;
+    this.seedDanglingRefs += dropped;
+    return { kept, dropped };
+  }
   hydrateObserved(snap, orders = []) {
     for (const id of snap.acked ?? []) this._acked.add(id);
     for (const e of snap.attentionSince ?? []) if (e?.id && e.since) this._attentionSince.set(e.id, e.since);
@@ -3645,6 +3852,7 @@ var FlowEngine = class {
          사라진다(같은 사실이 델타·스냅샷·이 변환 **세 길**을 지난다). */
       ...o.allocated?.length ? { allocated: o.allocated } : {},
       ...o.gtin ? { gtin: o.gtin } : {},
+      ...o.recipeKey ? { recipeKey: o.recipeKey } : {},
       ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {},
       ...o.dockDoor ? { dockDoor: o.dockDoor } : {},
       ...o.windowStartMs !== void 0 ? { windowStartMs: o.windowStartMs } : {}
@@ -3653,6 +3861,7 @@ var FlowEngine = class {
       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;
+      const resolved = this.resolvedAllocated(o.allocated);
       this.orders.set(o.orderId, {
         id: o.orderId,
         kind: o.kind,
@@ -3664,11 +3873,15 @@ var FlowEngine = class {
            않으면(옛 저널) 그때는 비는 것이 사실이다 — 없는 것을 지어내지 않는다. */
         /* 품목도 함께 — 씨앗이 흘리면 되살아난 오더가 무엇을 만드는지 모른다. */
         ...o.gtin ? { gtin: o.gtin } : {},
+        /* 레시피도 함께 — 품목만 이어받으면 되살아난 오더가 「무엇으로」를 모르고, 그 오더의
+           남은 공정·소요가 다른 레시피 기준으로 계산된다(같은 품목에 대체 레시피가 있다). */
+        ...o.recipeKey ? { recipeKey: o.recipeKey } : {},
         bizTransaction: o.bizTransaction ?? "",
-        allocated: (o.allocated ?? []).slice(),
+        allocated: resolved.kept,
         picked: [],
         shipmentEpc: null,
         lines,
+        ...resolved.dropped ? { seedIncomplete: true } : {},
         /* **보류를 이어받는다** — 잃으면 씨앗이 사람이 일부러 멈춘 오더를 다시 계획해 내보낸다.
            씨앗 왕복 대조가 이것을 잡았다(그 전에는 사람이 코드를 읽어야만 알 수 있었다). */
         ...o.held ? { held: true } : {},
@@ -3942,6 +4155,12 @@ var FlowEngine = class {
       simClockMs: this.clockMs,
       nowTime: this.now(),
       // 트윈의 "지금" — 관측 모드면 마지막으로 들은 시각(§nowMs)
+      identityGrounding: this.identityGroundingView(),
+      /* 원본과 어긋난 사실 — 0 이면 싣지 않는다(어긋난 적 없는 트윈에 빈 칸을 만들지 않는다). */
+      ...this.transformInputsAbsent || this.seedDanglingRefs ? { conformance: {
+        ...this.transformInputsAbsent ? { transformInputsAbsent: this.transformInputsAbsent } : {},
+        ...this.seedDanglingRefs ? { seedDanglingRefs: this.seedDanglingRefs } : {}
+      } } : {},
       /* 출처 표시 — 보드(마스터)에서 온 자리다. 미러는 관측으로 알게 된 자리를 'observed' 로 구별하는데,
        * 시뮬이 아무 표시도 안 하면 소비처가 두 스냅샷을 같은 규칙으로 읽지 못한다. */
       locations: [...this.locations.values()].map((n) => {
@@ -4027,6 +4246,10 @@ var FlowEngine = class {
          * 라인이 있는 오더는 `lines[].gtin` 이 품목을 말하고, 단일 품목 작업지시는 이 자리가 말한다.
          */
         ...o.gtin ? { gtin: o.gtin } : {},
+        /* **어느 레시피로 만드나** — 품목만으로는 「무엇으로」가 안 남는다(같은 품목의 대체 레시피가 있다). */
+        ...o.recipeKey ? { recipeKey: o.recipeKey } : {},
+        /* 씨앗이 다 심지 못했다는 사실 — 조용히 자르지 않는다(그 오더의 답은 부족한 씨앗 위에 있다). */
+        ...o.seedIncomplete ? { seedIncomplete: true } : {},
         ...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 } : {},
@@ -4138,7 +4361,8 @@ var FlowEngine = class {
       if (skip.has(key)) continue;
       const v = this[key];
       if (typeof v === "function") continue;
-      clone[key] = v instanceof Map ? new Map([...v.entries()].map(([k, o]) => [k, structuredClone(o)])) : structuredClone(v);
+      const cloneable = v;
+      clone[key] = v instanceof Map ? new Map([...v.entries()].map(([k, o]) => [k, structuredClone(o)])) : typeof cloneable?.clone === "function" ? cloneable.clone() : structuredClone(v);
     }
     clone.rng.state = this.rng.state;
     clone.durationEstimator = this.durationEstimator;
@@ -4360,7 +4584,7 @@ var FlowEngine = class {
    * 이긴다(원천 사본의 값이 낡았을 때 고칠 자리가 여기다). 무엇을 썼는지는 `specCoverage()` 가 밝힌다.
    *
    * ── 조용히 버리지 않는다 ────────────────────────────────────────────────────
-   * 읽을 수 없는 값은 던진다. 받아 두고 무시하면 화면은 「넣었습니다」라고 말하고 시뮬은 상수로 도는데,
+   * 읽을 수 없는 값은 오류를 낸다. 받아 두고 무시하면 화면은 「넣었습니다」라고 말하고 시뮬은 상수로 도는데,
    * 그 어긋남을 아무도 볼 수 없다(이 시스템에서 가장 비싼 종류의 침묵이다).
    */
   declareDurations(durations) {
@@ -4388,7 +4612,7 @@ var FlowEngine = class {
    *  · **현장 선언이 원천 명세를 이긴다**(ADR-0034) — 원천 사본이 낡았을 때 고칠 자리가 그것뿐이다.
    *  · 명세 행이 없는 종류에도 얹힌다 — 행을 지어 만들면 지어낸 `intent` 가 능력 계산을 오염시킨다.
    *  · 무엇을 썼는지는 `specCoverage()` 의 `parameters` 가 그대로 밝힌다.
-   *  · 빈 이름·빈 값은 **던진다**: 받아 두고 무시하면 화면은 「넣었습니다」라고 말하고 시뮬은 상수로 돈다.
+   *  · 빈 이름·빈 값은 **오류를 낸다**: 받아 두고 무시하면 화면은 「넣었습니다」라고 말하고 시뮬은 상수로 돈다.
    */
   declareParameters(params) {
     for (const [kind, entries] of Object.entries(params ?? {})) {
@@ -4412,6 +4636,17 @@ var FlowEngine = class {
   routeKeys() {
     return void 0;
   }
+  /**
+   * **이 트윈이 굴리는 서로 다른 라우트들** — 용량이 답할 수 있는지를 가른다.
+   *
+   * 하나면 `routeKeys()` 가 그 순서를 답한다. 둘 이상이면 「하루 몇 대」의 답이 **제품 구성에 따라
+   * 달라지므로**, 하나를 골라 답하지 않고 서로 다르다는 사실을 `capacity()` 가 함께 낸다. 조용히 고르면
+   * 능력 숫자가 거짓이 되고, 그 위에 선 모든 계획이 거짓 위에 선다.
+   */
+  distinctRouteKeys() {
+    const one = this.routeKeys();
+    return one ? ["(single)"] : [];
+  }
   /**
    * **이 공장이 하루 몇 대를 낼 수 있는가** — 실행해 보지 않고 답한다.
    *
@@ -4438,7 +4673,7 @@ var FlowEngine = class {
       sampleWeekStartMs: opts.sampleWeekStartMs,
       unitsPerDay: opts.unitsPerDay
     });
-    return { ...analysis, mixedCalendars: calendars.size > 1 };
+    return { ...analysis, mixedCalendars: calendars.size > 1, mixedRoutes: this.distinctRouteKeys().length > 1 };
   }
   /**
    * **생산 능력 보고서** — ISA-95 Part 4 `OperationsCapability`(§operations-capability).
@@ -4664,7 +4899,7 @@ var FlowEngine = class {
    * `skuMix` 에서 weight 로 gtin 선택(rng) — 도착·오더 자극의 품목 결정.
    *
    * **빈 목록이면 고르지 않는다**(`undefined`). 예전에는 `mix[mix.length - 1].gtin` 으로 떨어져
-   * `mix[-1]` 이 undefined 가 되고 거기서 던졌다 — 그 예외가 서버까지 올라가 **정확도 추세 전체를
+   * `mix[-1]` 이 undefined 가 되고 거기서 오류가 났다 — 그 예외가 서버까지 올라가 **정확도 추세 전체를
    * 죽였다**(품목 구성을 선언하지 않은 자극 하나가 예측 전체를 껐다).
    *
    * 없는 품목을 지어내지 않는다: 무엇을 만들지 모르면 **만들지 않는 것**이 맞고, 부르는 쪽이
@@ -4692,9 +4927,16 @@ var FlowEngine = class {
    * 도메인은 이 원시만 호출 — onTaskComplete 의 소비/생산/EPCIS 손코딩을 대체.
    */
   transform(inputs, outputs, opts) {
-    for (const epc of inputs) {
+    const absent = inputs.filter((epc) => !this.items.get(epc));
+    if (absent.length && !this.observeMode) {
+      throw new Error(
+        `transform: \uC785\uB825 ${absent.length}\uAC74\uC774 \uC0C1\uD0DC\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4 (${absent.slice(0, 3).join(", ")}${absent.length > 3 ? " \u2026" : ""}) \u2014 \uC5C6\uB294 \uAC83\uC744 \uC18C\uBE44\uD588\uB2E4\uACE0 \uAE30\uB85D\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uC774 \uD2B8\uC708\uC758 \uACC4\uC0B0\uC774 \uC5C6\uB294 \uBB3C\uAC74\uC744 \uC694\uAD6C\uD588\uC2B5\uB2C8\uB2E4.`
+      );
+    }
+    if (absent.length) this.transformInputsAbsent += absent.length;
+    const consumed = absent.length ? inputs.filter((epc) => this.items.has(epc)) : inputs;
+    for (const epc of consumed) {
       const it = this.items.get(epc);
-      if (!it) continue;
       const n = this.locations.get(it.location);
       if (n) n.occupancy--;
       this.items.delete(epc);
@@ -4708,7 +4950,7 @@ var FlowEngine = class {
       eventTime: this.now(),
       bizStep: opts.bizStep,
       disposition: opts.disposition,
-      inputEPCList: inputs.length ? inputs.slice() : void 0,
+      inputEPCList: consumed.length ? consumed.slice() : void 0,
       outputEPCList: outputs.length ? outputs.map((o) => o.epc) : void 0,
       transformationID: opts.transformationId,
       readPoint: opts.readPoint,
@@ -4911,6 +5153,9 @@ var FlowEngine = class {
       /* 진행 중 할당과 거래번호를 함께 싣는다 — 이것이 없으면 웜스타트가 잃고, 되살아난 오더의
          계보가 입력 없이 나간다(무엇이 무엇으로 바뀌었나의 절반이 사라진다). */
       ...o.gtin ? { gtin: o.gtin } : {},
+      /* 어느 레시피로 만드는가 — 품목만 보내면 미러는 「무엇으로」를 알 수 없다(같은 품목에 대체
+         레시피가 있다). 시뮬만 아는 사실이 남으면 두 스냅샷을 같은 규칙으로 읽을 수 없다. */
+      ...o.recipeKey ? { recipeKey: o.recipeKey } : {},
       ...o.allocated?.length ? { allocated: o.allocated.slice() } : {},
       ...o.bizTransaction ? { bizTransaction: o.bizTransaction } : {},
       /* 약속해 둔 자리·시각창 — 이것이 빠져서 야드 트윈이 재기동마다 첫 틱에 죽었다(§dockDoor). */
@@ -5056,9 +5301,8 @@ var FlowEngine = class {
     for (const req of need) {
       let remaining = Math.max(0, req.quantity ?? 0);
       if (!remaining) continue;
-      for (const it of this.items.values()) {
+      for (const it of this.items.at(at)) {
         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);
@@ -5095,7 +5339,36 @@ var FlowEngine = class {
    * 같은 품목이 그 자리에 이미 있으면 **수량을 더한다** — 새 줄을 만들면 같은 자리의 같은 로트가
    * 둘로 갈려 재고가 부푼다(§MaterialSubLot 에서 겪은 것과 반대 방향의 같은 오류).
    */
+  /**
+   * **이 공정의 산출을 도메인이 직접 만드는가** — 기본은 아니다(코어가 만든다).
+   *
+   * ── 왜 이 이음새가 있나 (2026-08-20) ──────────────────────────────────────
+   * 코어의 산출은 **비직렬 클래스+수량**이다(일련번호를 지어내지 않으므로). 그런데 어떤 도메인은
+   * 산출물에 **개체 정체성**이 필요하다: MES 의 레시피 생산은 개체마다 직렬번호를 갖고, 수율이
+   * 개체별로 양품/불량을 가르고, 계보(`TransformationEvent`)가 오더의 단계들을 잇는다.
+   *
+   * 그 도메인이 산출을 만들 때 코어도 같은 선언을 보고 만들면 **같은 산출이 두 벌** 된다 — 재고가
+   * 조용히 두 배가 되고, 그 위의 모든 계산이 거짓 위에 선다. 그래서 소유를 **한쪽으로 정한다.**
+   *
+   * 코어는 여기서 **도메인 명사를 하나도 알지 않는다**: 「누가 만드는가」만 묻는다. 무엇을 만드는지는
+   * 여전히 선언이 정하고, 코어는 그 선언을 읽을 뿐이다.
+   */
+  producesOwnOutputs(_opKey) {
+    return false;
+  }
+  /**
+   * **이 트윈의 정체성 근거** — 스냅샷에 실린다(§`StateSnapshot.identityGrounding`).
+   *
+   * 코어는 선언을 갖고 있지 않다(생산 선언은 도메인의 것이다). 그래서 기본은 **선언 없음**이고,
+   * 선언을 든 커널이 override 해서 자기 것을 답한다 — `routeKeys()` 와 같은 모양이다.
+   *
+   * 코어는 여기서 **정체성의 값을 정하지 않는다**: 「어디서 왔나」만 묻는다.
+   */
+  identityGroundingView() {
+    return identityGroundingOf(void 0);
+  }
   produceMaterials(t) {
+    if (this.producesOwnOutputs(t.kind)) return;
     const made = (this.operationSpecs.get(t.kind)?.materialSpecification ?? []).filter((m) => m.use === "produced");
     if (!made.length) return;
     for (const spec of made) {
@@ -5132,7 +5405,7 @@ var FlowEngine = class {
    * 작업은 혼자 서지 못한다: 옮길 **물품**과, (있다면) 그것을 시킨 **오더** 위에 선다. 진행 중에
    * 둘 중 하나가 사라질 수 있다 — 물품은 포장·출하·소비로, 오더는 이미 이행돼 씨앗이 주입하지 않아서.
    *
-   * 그때 도메인 훅은 없는 것을 딛으려다 던진다(`order.gtin` · `item.location`). 그 예외 하나가
+   * 그때 도메인 훅은 없는 것을 딛으려다 오류를 낸다(`order.gtin` · `item.location`). 그 예외 하나가
    * **예측 전체를 죽였다** — 사용자에게는 기능이 통째로 사라진 것으로 보였다. 그래서 완료 **전에**
    * 여기서 묻고, 없으면 그 작업만 접는다.
    */
@@ -5146,7 +5419,7 @@ var FlowEngine = class {
    * 이 도메인이 이 작업을 **끝맺을 수 있나** — 코어가 모르는 조건은 도메인이 답한다.
    *
    * 코어는 물품과 오더까지만 안다. 그런데 도메인은 더 필요할 수 있다 — MES 는 완료 시점에 **오더와
-   * 제품 정의**를 딛고 서고, 그 중 하나만 없어도 던진다. 코어가 그 조건을 추측하면 도메인마다 다른
+   * 제품 정의**를 딛고 서고, 그 중 하나만 없어도 오류를 낸다. 코어가 그 조건을 추측하면 도메인마다 다른
    * 가정을 코어에 박게 되므로(방언), **묻는다.**
    *
    * 기본은 `true` — 대부분의 작업은 코어가 확인한 것으로 충분하다.
@@ -5159,7 +5432,7 @@ var FlowEngine = class {
    *
    * 물품 맵의 키는 `itemKeyOf`(직렬 물품은 `epc`, 로트의 부분은 `subLotId`)인데, 작업은 로트 식별자
    * (`itemEpc`)로 가리킨다. 비직렬 로트에서는 둘이 **다르다** — 그래서 그냥 `get` 하면 못 찾는다.
-   * 실제로 그 회귀를 냈다: 예측(씨앗) 경로에서 `item.location = …` 이 `undefined` 위에서 던져
+   * 실제로 그 회귀를 냈다: 예측(씨앗) 경로에서 `item.location = …` 이 `undefined` 위에서 오류를 내어
    * **정확도 추세 전체가 서버 오류로 죽었다.**
    *
    * **부분이 여럿이면 풀지 않는다** — 어느 부분을 가리키는지 알 수 없고, 아무거나 고르면 그 뒤
@@ -5168,6 +5441,7 @@ var FlowEngine = class {
   itemByRef(ref) {
     const exact = this.items.get(ref);
     if (exact) return exact;
+    this.refScans++;
     let hit;
     for (const it of this.items.values()) {
       if (it.epc !== ref) continue;
@@ -5176,6 +5450,16 @@ var FlowEngine = class {
     }
     return hit;
   }
+  /**
+   * 참조가 키가 아니어서 전수 조회로 찾은 횟수 — **성능 판단의 근거**다.
+   *
+   * 규약대로면 0 이다. 0 이 아닌 것은 결함이 아니라 사실이다(원본이 준 참조는 우리 키를 모른다).
+   * 다만 그 수가 규모와 함께 자라면 인덱스가 필요하다는 뜻이고, 그때 넣을 근거가 이 값이다.
+   */
+  refScans = 0;
+  refScanCount() {
+    return this.refScans;
+  }
   /**
    * 실제 자재 이동을 작업에 적어 둔다 — ISA-95 `JobResponse.MaterialActual`.
    * 같은 품목·같은 쓰임은 **한 줄로 합친다**(줄을 늘리면 실적을 세는 쪽이 중복을 걷어내야 한다).
@@ -5692,7 +5976,7 @@ function matches(s, req) {
 
 // src/kernel.ts
 var TRAVEL_MS = 3e4;
-var COMPANY_PREFIX = "0614141";
+var LEGACY_COMPANY_PREFIX = "0614141";
 var SHELF_MS = 30 * 24 * 36e5;
 var SHELF_JITTER_MS = 5 * 24 * 36e5;
 var WmsKernel = class extends FlowEngine {
@@ -5700,15 +5984,37 @@ var WmsKernel = class extends FlowEngine {
   constructor(tenantId, policy = firstFitPolicy) {
     super(tenantId, policy);
   }
+  /**
+   * 내장 시나리오가 요구하는 자리 — **없으면 말한다.**
+   *
+   * ── 왜 (2026-08-20) ────────────────────────────────────────────────────────
+   * 이 커널은 입고·중간·보관 자리를 **자기 낱말로** 찾았고(`dock`·`staging`·`storage`), 없으면 조용히
+   * `return` 했다. 그래서 그 낱말을 쓰지 않는 현장의 트윈은 **아무 일도 일어나지 않는 공장**이 됐다 —
+   * 오류도 로그도 없이. 실제로 확인된 자리다: 첫 실 시스템(F&B)에는 `dock`·`gate`·`staging` 이 **한 건도
+   * 없다**(자리 타입이 자유 문자열이고, 입출고가 도크 단계 없이 자리에 직접 일어난다).
+   *
+   * 여기서 이름을 여는 것이 답이 아니다 — 이 경로는 부품·라우트가 내장 상수인 레거시 시나리오라,
+   * 이름만 열면 **지원하는 척**이 된다(MES 가 같은 이유로 같은 결론을 냈다). 답은 요구를 분명히 말하는
+   * 것이고, 던지면 호스트가 그 트윈만 멈추고 이유를 등록부에 적는다(`tick-failed`) — 다른 트윈은 계속 돈다.
+   * 조용한 정지는 그 사실조차 남기지 않는다.
+   */
+  builtInLocation(type, what) {
+    const loc = this.locationByType(type);
+    if (!loc) {
+      throw new Error(
+        `built-in WMS scenario needs a location of type '${type}' (${what}) and this twin has none \u2014 rename it, or drive this twin from declarations instead of the built-in scenario`
+      );
+    }
+    return loc;
+  }
   /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
   onArrival(spec) {
-    const dock = this.locationByType("dock");
-    if (!dock) return;
-    const epc = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
+    const dock = this.builtInLocation("dock", "inbound pallets land here");
+    const epc = ssccUri(LEGACY_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 po = gdtiUri(LEGACY_COMPANY_PREFIX, "401", ++this.poSeq);
     const eventTime = this.now();
     const qtyList = [{ epcClass: gtin, quantity: qty }];
     const poTxn = [{ type: BTT.po, bizTransaction: po }];
@@ -5779,7 +6085,7 @@ var WmsKernel = class extends FlowEngine {
   /** 오더 생성 — 약속(납기·우선순위)은 base `promiseOf` 가 계산한다(도메인마다 다르게 재지 않는다). */
   createSalesOrder(lines, spec) {
     const id = `order-${++this.orderSeq}`;
-    const so = gdtiUri(COMPANY_PREFIX, "402", ++this.soSeq);
+    const so = gdtiUri(LEGACY_COMPANY_PREFIX, "402", ++this.soSeq);
     const requested = lines.reduce((s, l) => s + l.qty, 0);
     const order = {
       id,
@@ -5803,8 +6109,8 @@ var WmsKernel = class extends FlowEngine {
    * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
    */
   allocate(o) {
-    const staging = this.locationByType("staging");
-    if (!staging || !o.lines) return;
+    if (!o.lines) return;
+    const staging = this.builtInLocation("staging", "picked pallets wait here before shipping");
     const chosenAll = [];
     for (const line of o.lines) {
       const already = o.allocated.filter((e) => this.items.get(e)?.gtin === line.gtin).length;
@@ -5839,7 +6145,7 @@ var WmsKernel = class extends FlowEngine {
     const to = this.locations.get(t.toNode);
     from.occupancy--;
     to.occupancy++;
-    item.location = to.id;
+    this.items.relocate(itemKeyOf(item), to.id);
     if (t.kind === "feed") {
       this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: BIZSTEP.storing, disposition: item.disposition, epcList: [item.epc], quantityList: [{ epcClass: item.gtin, quantity: item.qty }], readPoint: to.id, bizLocation: to.id }));
       return;
@@ -5952,21 +6258,21 @@ var WmsKernel = class extends FlowEngine {
       const qty = row.qty ?? 0;
       if (qty <= 0) continue;
       this.items.delete(key);
-      const pallet = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
+      const pallet = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
       const qtyList = [{ epcClass: m.definitionId, quantity: qty }];
       this.items.set(pallet, { epc: pallet, gtin: m.definitionId, qty, location: at, disposition: DISP.in_progress });
       const eventTime = this.now();
       this.emit(aggregationEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.packing, parentID: pallet, childQuantityList: qtyList, readPoint: at }));
       this.emit(objectEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.packing, disposition: DISP.in_progress, epcList: [pallet], quantityList: qtyList, readPoint: at, bizLocation: at }));
-      const storage = this.locationByType("storage");
-      if (storage) this.pushTask(order, "putaway", pallet, at, storage.id);
+      const storage = this.builtInLocation("storage", "received pallets are put away here");
+      this.pushTask(order, "putaway", pallet, at, storage.id);
     }
   }
   /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
   finalizeOrder(order, staging) {
     const shipDock = this.locationByType("dock-ship") ?? staging;
     const eventTime = this.now();
-    const shipment = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
+    const shipment = ssccUri(LEGACY_COMPANY_PREFIX, ++this.epcSeq);
     order.shipmentEpc = shipment;
     const soTxn = [{ type: BTT.so, bizTransaction: order.bizTransaction }];
     this.aggregate(shipment, order.picked.slice(), { bizStep: BIZSTEP.packing, readPoint: staging.id, bizLocation: staging.id });
@@ -5999,7 +6305,7 @@ var DWELL_MS = 3e4;
 var WINDOW_DELAY_MS = 4e4;
 var WINDOW_LENGTH_MS = 20 * 6e4;
 var CARGO_PER_TRAILER = 2;
-var CP = "0614141";
+var LEGACY_CP = "0614141";
 var YmsKernel = class extends FlowEngine {
   doorRR = 0;
   cargoSeq = 0;
@@ -6029,18 +6335,18 @@ var YmsKernel = class extends FlowEngine {
     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);
+    const epc = graiUri(LEGACY_CP, "10", ++this.epcSeq);
     this.items.set(epc, { epc, location: gate.id, disposition: DISP.in_progress });
     gate.occupancy++;
     this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: YARD_BIZSTEP.arriving, disposition: DISP.in_progress, epcList: [epc], readPoint: gate.id, bizLocation: gate.id }));
     if (inbound) {
-      const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => ssccUri(CP, ++this.cargoSeq));
+      const cargo = Array.from({ length: CARGO_PER_TRAILER }, () => ssccUri(LEGACY_CP, ++this.cargoSeq));
       this.trailerCargo.set(epc, cargo);
       this.aggregate(epc, cargo, { bizStep: YARD_BIZSTEP.arriving, readPoint: gate.id });
     }
     const door = doors[this.doorRR++ % doors.length];
     const id = `order-${++this.orderSeq}`;
-    const appt = gdtiUri(CP, "404", ++this.soSeq);
+    const appt = gdtiUri(LEGACY_CP, "404", ++this.soSeq);
     const order = {
       id,
       kind,
@@ -6120,7 +6426,7 @@ var YmsKernel = class extends FlowEngine {
     const to = this.locations.get(t.toNode);
     from.occupancy--;
     to.occupancy++;
-    trailer.location = to.id;
+    this.items.relocate(itemKeyOf(trailer), to.id);
     if (t.kind === "dwell") {
       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 };
@@ -6174,25 +6480,7 @@ var YmsKernel = class extends FlowEngine {
 var DEFAULT_CYCLE_MS = 4e4;
 var DEFAULT_SETUP_MS = 15e3;
 var MES_CMD = { changeover: "mes.changeover" };
-var CP2 = "0614141";
-var WIP_ITEMREF = "066666";
-var WIP_GTIN = sgtinClass(CP2, WIP_ITEMREF);
 var DEFAULT_YIELD = 0.8;
-var PART_A = { itemRef: "055551", gtin: sgtinClass(CP2, "055551") };
-var PART_B = { itemRef: "055552", gtin: sgtinClass(CP2, "055552") };
-var PRODUCTS = [
-  { key: "P1", ref: "077777", gtin: sgtinClass(CP2, "077777"), bom: [{ part: PART_A, qty: 2 }, { part: PART_B, qty: 1 }] },
-  { key: "P2", ref: "077778", gtin: sgtinClass(CP2, "077778"), bom: [{ part: PART_A, qty: 1 }, { part: PART_B, qty: 2 }] }
-];
-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", 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;
   prodSeq = 0;
@@ -6203,13 +6491,15 @@ var MesKernel = class extends FlowEngine {
     this.productionSpec = productionSpec;
     if (productionSpec?.definition?.operations) {
       this.loadOperations(productionSpec.definition.operations);
-      this.assertNoDoubleProduction(productionSpec.definition.operations);
     }
     if (productionSpec?.definition?.recipes?.length && (!productionSpec.binding || !productionSpec.companyPrefix)) {
       throw new Error(
         "recipe-driven production needs `binding` and `companyPrefix` \u2014 the definition does not know GTINs, so material keys cannot be resolved to GS1 identifiers"
       );
     }
+    if (productionSpec?.definition?.operations) {
+      this.assertNoDoubleProduction(productionSpec.definition.operations);
+    }
   }
   /**
    * **산출을 두 곳에서 만들지 않는다** — 기동 때 막는다.
@@ -6224,14 +6514,69 @@ var MesKernel = class extends FlowEngine {
    * 모든 계산이 거짓이 된다).
    */
   assertNoDoubleProduction(ops) {
-    const bad2 = ops.filter((o) => (o.materialSpecification ?? []).some((m) => m.use === "produced")).map((o) => o.key);
+    const finals = new Set((this.productionSpec?.definition?.recipes ?? []).flatMap((r) => (r.outputs ?? []).map((o) => this.classOf(o.material))));
+    const bad2 = ops.filter((o) => (o.materialSpecification ?? []).some((m) => m.use === "produced" && m.materialDefinition && finals.has(m.materialDefinition))).map((o) => o.key);
     if (!bad2.length) return;
     throw new Error(
-      `MES recipe already produces outputs \u2014 operations [${bad2.join(", ")}] must not also declare materialSpecification use:'produced' (that would create the same output twice). Consumption specs are fine; declare production in the recipe.`
+      `MES recipe already produces its output \u2014 operations [${bad2.join(", ")}] must not also declare that same material as materialSpecification use:'produced' (that would create the same output twice). Declare intermediate outputs freely; the final output belongs to the recipe.`
     );
   }
-  productOf(gtin) {
-    return PRODUCTS.find((p) => p.gtin === gtin);
+  /**
+   * **레시피 모드에서는 MES 가 산출을 소유한다** — 코어는 비켜선다(§`producesOwnOutputs`).
+   *
+   * MES 의 산출은 개체 정체성(직렬번호) + 수율 + 오더 계보를 갖는다. 코어의 일반 산출은 비직렬
+   * 클래스+수량이라 그 셋을 표현하지 못한다. 둘이 같은 선언을 보고 각자 만들면 재고가 두 배가 된다.
+   *
+   * 레시피가 없으면(유통가공 등) 소유를 주장하지 않는다 — 그때는 코어의 산출이 맞다.
+   */
+  producesOwnOutputs(_opKey) {
+    return !!this.productionSpec?.definition?.recipes?.length;
+  }
+  /**
+   * 이 트윈의 정체성 근거 — 선언에서 파생한다(§`identityGroundingOf`).
+   *
+   * 선언이 근거를 정한다: 이름공간을 선언했으면 `declared`, 발급을 주장했으면 `issued`(주장이지 사실이
+   * 아니다). 선언이 없는 MES 트윈은 이제 만들 수 없으므로(`loadTwinModel` 이 거절한다) `fabricated` 로
+   * 판정될 일이 없다.
+   */
+  identityGroundingView() {
+    return identityGroundingOf(this.productionSpec);
+  }
+  /**
+   * 선언이 말하는 자리 타입이 **이 트윈에 있나** — 로드 시점에 한 번, 모아서 말한다 (2026-08-20).
+   *
+   * ── 왜 로드 시점인가 ───────────────────────────────────────────────────────
+   * 이것은 **선언의 흠**이다: 그 트윈의 생산 선언과 그 트윈의 모델이 서로 어긋났다. 틱에서 발견하면
+   * 그 트윈은 「도는데 아무 일도 안 일어나는」 모습이 된다 — 실제로 `allocateDef` 가 첫 공정의 자리를
+   * 못 찾으면 조용히 `return` 했고, 오더는 영원히 배정되지 않은 채 화면에는 「running」이라 적혔다.
+   *
+   * ── 좁히지 않는다 ─────────────────────────────────────────────────────────
+   * 「이 트윈이 실제로 지나는 라우트만 본다」는 예외를 한 번 검토했다가 버렸다. 근거로 삼은 「여러
+   * 트윈이 한 선언을 공유한다」가 **이 코드에 없는 이야기**였다: 호스트는 트윈마다 자기 모델에서
+   * 선언을 만든다(`productionSpecOf(model)`). 없는 사정을 상상해 검사에 구멍을 내지 않는다.
+   *
+   * 모아서 한 번에 말한다 — 하나씩 실패하면 사람이 같은 기동을 열 번 반복한다.
+   */
+  loadTwinModel(def) {
+    super.loadTwinModel(def);
+    if (!this.productionSpec) {
+      throw new Error(
+        "MES twin requires a production declaration (ProductionSpec): materials, routes and recipes. The kernel no longer carries a built-in demo product \u2014 what is made is decided by the model."
+      );
+    }
+    const have = new Set([...this.locations.values()].map((l) => l.type));
+    const missing = [];
+    for (const m of this.productionSpec.definition.materials ?? []) {
+      if (m.locationType && !have.has(m.locationType)) missing.push(`material '${m.key}' \u2192 '${m.locationType}'`);
+    }
+    for (const op of this.productionSpec.definition.operations ?? []) {
+      if (op.locationType && !have.has(op.locationType)) missing.push(`operation '${op.key}' \u2192 '${op.locationType}'`);
+    }
+    if (missing.length) {
+      throw new Error(
+        `production declaration names location types this twin does not have: ${missing.join(" \xB7 ")}. This twin has [${[...have].sort().join(", ")}]. Declare those locations in the model, or fix the declared locationType \u2014 the kernel does not invent a place for material to sit.`
+      );
+    }
   }
   /**
    * MES 도메인 커맨드(Tier 2) — mes.changeover: 설비를 제품 gtin 으로 강제 전환.
@@ -6254,107 +6599,55 @@ var MesKernel = class extends FlowEngine {
     }
     return super.handleCommand(cmd);
   }
-  /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
+  /** 부품 수령 — 도착한 품목이 선언된 입력 자재면 그 자재가 선언한 자리에 생성. */
   onArrival(spec) {
-    if (this.productionSpec) return this.onArrivalDef(spec);
-    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);
-    if (!part) return;
-    const epc = sgtinUri(CP2, part.itemRef, ++this.epcSeq);
-    this.items.set(epc, { epc, gtin: part.gtin, qty: 1, location: rawStore.id, disposition: DISP.sellable });
-    rawStore.occupancy++;
-    this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.receiving, disposition: DISP.sellable, epcList: [epc], quantityList: [{ epcClass: part.gtin, quantity: 1 }], readPoint: rawStore.id, bizLocation: rawStore.id }));
-  }
-  /** 작업지시 — 제품 2종 교대(체인지오버 유발). 제품 gtin 을 오더에 기록. */
+    return this.onArrivalDef(spec);
+  }
+  /** 작업지시 — 오더가 자기 레시피를 든다(선언된 레시피 중에서). */
   onOrder(_spec) {
-    if (this.productionSpec) return this.onOrderDef(_spec);
-    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: [], ...this.promiseOf(_spec) };
-    this.orders.set(id, order);
-    this.emitOrder(order);
+    return this.onOrderDef(_spec);
   }
-  /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + 라우트 첫 스테이션(절단) 태스크. */
+  /** 할당 — 레시피 입력 전량 확보 후 첫 라우트 단계 태스크(부족하면 대기). */
   allocate(o) {
-    if (this.productionSpec) return this.allocateDef(o);
-    const s0 = ROUTE[0];
-    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.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);
-    }
-    for (const epc of picks) o.allocated.push(epc);
-    this.reserve(picks, MES_BIZSTEP.producing);
-    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
-    this.emitStation(o, s0, o.allocated[0], product.gtin);
-    o.status = "op-" + s0.kind;
-    this.emitOrder(o);
-  }
-  /** 라우트 스테이션 태스크 발행(공통) — 제자리 가공(process), 이종 자원, 제품 전환 셋업. */
-  emitStation(o, stage, itemEpc, changeoverKey) {
-    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);
+    return this.allocateDef(o);
   }
-  /** op 완료 = 변환. 라우트 인덱스로 분기: 첫=BOM 소비→WIP, 중간=WIP→WIP, 마지막(조립)=WIP→완성차(수율→OEE 품질). */
   /**
    * MES 는 완료 시점에 **오더와 제품 정의**를 딛고 선다 — 둘 중 하나만 없어도 끝맺을 수 없다.
    *
    * 씨앗이 이미 이행된 오더를 주입하지 않으므로(남은 수량 0) 그 오더에 딸린 작업만 남을 수 있고,
-   * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 던졌고 **그 예외
+   * 관측이 오더 연결을 담지 못한 작업도 있다. 그때 예전에는 `order.gtin` 에서 오류가 났고 **그 예외
    * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
    */
   canComplete(t) {
-    if (this.productionSpec) 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);
+    return !!(t.orderId && this.orders.get(t.orderId));
   }
   onTaskComplete(t) {
-    if (this.productionSpec) return this.onTaskCompleteDef(t);
-    const order = this.orders.get(t.orderId);
-    const product = order && this.productOf(order.gtin);
-    if (!order || !product) throw new Error(`task ${t.id}: order/product vanished between the core check and the domain hook`);
-    const i = ROUTE.findIndex((s) => s.kind === t.kind);
-    const loc = this.locations.get(t.toNode);
-    const isLast = i === ROUTE.length - 1;
-    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: 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);
-      order.status = "op-" + next.kind;
-      this.emitOrder(order);
-      return;
-    }
-    const fgStore = this.locationByType("fg-store");
-    const wip = order.allocated[0];
-    const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
-    t.outcome = good ? "good" : "scrap";
-    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: 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;
-    order.status = good ? "produced" : "scrapped";
-    this.emitOrder(order);
+    return this.onTaskCompleteDef(t);
   }
   // ── 정의-구동 모드 (도메인 정의 데이터로 실행 — 레거시와 분리, 하드코딩 대체) ──
-  recipeDef() {
+  /** 선언된 레시피 전부 — 오더가 자기 것을 고르고, 수령이 전부의 소요를 본다. */
+  recipesDef() {
+    return this.productionSpec.definition.recipes ?? [];
+  }
+  /**
+   * 이 오더의 레시피 — **오더가 들면 그것, 없으면 선언 수준의 기본**(§`FlowOrder.recipeKey`).
+   *
+   * 오더가 든 키가 선언에 없으면 **말한다**: 조용히 첫 레시피로 떨어지면 그 오더는 다른 물건을 만들고,
+   * 그 뒤 계보·재고·수율이 전부 엉뚱한 품목에 붙는다.
+   */
+  recipeDef(order) {
     const d = this.productionSpec.definition;
-    return this.productionSpec.recipeKey ? d.recipes?.find((r) => r.key === this.productionSpec.recipeKey) : d.recipes?.[0];
+    const key = order?.recipeKey ?? this.productionSpec.recipeKey;
+    if (key) {
+      const found = d.recipes?.find((r) => r.key === key);
+      if (!found) {
+        throw new Error(
+          `recipe '${key}' is not declared. Declared: [${(d.recipes ?? []).map((r) => r.key).join(", ") || "(none)"}]. The kernel does not substitute another recipe \u2014 that would make this order produce a different item.`
+        );
+      }
+      return found;
+    }
+    return d.recipes[0];
   }
   /** 자재 키 → 구체 gtin 클래스(idpat). 구체 식별은 바인딩+prefix 로 인스턴스가 주입. */
   classOf(materialKey) {
@@ -6363,54 +6656,180 @@ var MesKernel = class extends FlowEngine {
   serialOf(materialKey, serial) {
     return sgtinUri(this.productionSpec.companyPrefix, this.productionSpec.binding[materialKey], serial);
   }
+  /**
+   * 이 공정이 **만든다고 선언한 품목** — 표준 `OpMaterialSpecification` `MaterialUse='produced'`.
+   *
+   * ── 왜 이 함수가 생겼나 (2026-08-20) ──────────────────────────────────────
+   * 예전에는 라우트의 중간 단계마다 커널이 `sgtinUri(prefix, 'WIP', ++seq)` 로 **품목을 지어냈다.**
+   * 그러면 배합물·가열완료물·소분물이 전부 같은 상품코드가 된다 — 저널에 남는 것은 「무엇인지 아무도
+   * 답할 수 없는 물건」이고, 그것이 영구 기록이 된다. 게다가 그 조립은 `binding` 을 **건너뛴다**:
+   * 다른 모든 품목은 `classOf`/`serialOf` 로 인스턴스가 주입한 품번을 지나는데, `'WIP'` 만 커널이
+   * itemRef 자리에 리터럴을 넣었다.
+   *
+   * ── 규율 ──────────────────────────────────────────────────────────────────
+   * 만드는 것은 **선언이 정한다**. 선언이 없으면 만들지 않는다(§`produceMaterials` 와 같은 규율 —
+   * 「무엇을 만드는지 말하지 않으면 만들지 않는다」). 있으면 그 품목으로 만든다. 어느 쪽도 지어내지 않는다.
+   *
+   * 둘 이상을 선언하면 **거부한다**: 어느 것이 이 단계의 산출인지는 모델이 말할 일이고, 커널이 첫 줄을
+   * 고르면 나머지는 조용히 사라진다.
+   */
+  producedMaterialKeyOf(opKey) {
+    const made = (this.operationSpecs.get(opKey)?.materialSpecification ?? []).filter((m) => m.use === "produced");
+    if (!made.length) return void 0;
+    if (made.length > 1) {
+      throw new Error(
+        `operation '${opKey}' declares ${made.length} produced materials \u2014 the kernel does not choose one. Declare exactly one 'produced' material for this step, or split the step.`
+      );
+    }
+    const declared = made[0].materialDefinition;
+    if (!declared) {
+      return void 0;
+    }
+    return this.materialKeyOfClass(declared, opKey);
+  }
+  /**
+   * 표준 GTIN 클래스 → **모델의 자재 키.**
+   *
+   * 공정 명세는 표준 식별자(`MaterialDefinitionID` = GTIN idpat)로 품목을 가리키고, MES 프로파일의
+   * 나머지는 자재 키(`MaterialDef.key` + `binding`)로 가리킨다. **둘은 다른 층이고 `binding` 이 통로다.**
+   * 그래서 선언된 식별자가 이 트윈의 `binding` 을 지나 나오는 것인지 되짚어 확인한다.
+   *
+   * 없으면 **모델 위반이므로 멈춘다** — 커널이 바인딩 없는 품목의 정체성을 만들어 낼 자리가 없다.
+   */
+  materialKeyOfClass(gtinClass, opKey) {
+    const binding = this.productionSpec.binding;
+    const key = Object.keys(binding).find((k) => this.classOf(k) === gtinClass);
+    if (!key) {
+      throw new Error(
+        `operation '${opKey}' declares produced material '${gtinClass}', which no declared material binds to. Known: ${Object.keys(binding).map((k) => `${k}=${this.classOf(k)}`).join(", ") || "(none)"}. Declare that material in the model with a binding \u2014 the kernel does not invent an identity for it.`
+      );
+    }
+    return key;
+  }
+  /**
+   * 이 자재가 놓이는 **자리 타입** — 선언이 권위다(`MaterialDef.locationType`).
+   *
+   * 예전에는 이 자리에 `'raw-store'`·`'fg-store'` 가 박혀 있었다. 그래서 현장은 자기 창고를 그 이름으로
+   * **개명해야** 트윈이 굴러갔다 — 커널이 현장의 낱말을 정하는 셈이었다. 선언이 없으면 **지어내지 않고
+   * 말한다**: 예전 거동(조용한 return)에서는 아무도 왜 자재가 들어오지 않는지 알 수 없었다.
+   *
+   * 레거시(선언 없는 내장 프로파일) 경로는 이 함수를 쓰지 않는다 — 그쪽에는 대조할 선언이 없으므로
+   * 커널 어휘 자체가 계약이다.
+   */
+  locationTypeOfMaterial(materialKey) {
+    const type = this.productionSpec.definition.materials?.find((m) => m.key === materialKey)?.locationType;
+    if (!type) throw new Error(`material '${materialKey}': MaterialDef.locationType \uBBF8\uC120\uC5B8 \u2014 \uC790\uC7AC\uAC00 \uB193\uC774\uB294 \uC790\uB9AC\uB97C \uCEE4\uB110\uC774 \uC9C0\uC5B4\uB0BC \uC218 \uC5C6\uB2E4`);
+    return type;
+  }
+  /** 그 자리 타입의 자리 — 이 트윈에 없으면 말한다(선언과 모델이 어긋난 사실이다). */
+  locationOfMaterial(materialKey) {
+    const type = this.locationTypeOfMaterial(materialKey);
+    const loc = this.locationByType(type);
+    if (!loc) throw new Error(`material '${materialKey}': locationType '${type}' \uC778 \uC790\uB9AC\uAC00 \uC774 \uD2B8\uC708\uC5D0 \uC5C6\uB2E4`);
+    return loc;
+  }
   /**
    * 라우트를 용량 계산에 알려 준다 — 수율을 거슬러 올릴 때 순서가 곧 계산이다.
    *
    * 순서를 모르면 선언 순서대로 세는데, 그러면 하류에서 잃는 몫이 엉뚱한 공정에 얹힌다(조용히
    * 틀린다). 생산 정의를 가진 커널만 이 답을 안다.
    */
+  /*
+   * ── 레시피가 여럿이면 「그 라우트」가 하나가 아니다 (2026-08-20) ────────────
+   * 용량은 트윈 수준의 질문이다(「이 공장이 하루 몇 대」). 레시피마다 라우트가 다르면 그 답이 제품
+   * 구성에 따라 달라지는데, **하나를 골라 답하면 능력 숫자가 조용히 거짓이 된다.** 그래서 갈릴 때는
+   * 답하지 않고(`undefined`) 서로 다르다는 사실을 `capacity()` 가 함께 낸다 — `mixedCalendars` 와 같은 규율.
+   */
   routeKeys() {
     if (!this.productionSpec) return void 0;
-    const d = this.productionSpec.definition;
-    return d.routes?.find((r) => r.key === this.recipeDef().route)?.steps;
+    const routes = this.distinctRouteKeys();
+    if (routes.length !== 1) return void 0;
+    return this.productionSpec.definition.routes?.find((r) => r.key === routes[0])?.steps;
   }
-  /** recipe.route → 오퍼레이션 시퀀스 해소. */
-  routeOps() {
+  /** 선언된 레시피들이 쓰는 **서로 다른** 라우트 키들. 하나면 용량을 답할 수 있다. */
+  distinctRouteKeys() {
+    if (!this.productionSpec) return [];
+    return [...new Set(this.recipesDef().map((r) => r.route).filter((k) => !!k))];
+  }
+  /** recipe.route → 오퍼레이션 시퀀스 해소. 오더가 자기 레시피를 들면 그 라우트다. */
+  routeOps(order) {
     const d = this.productionSpec.definition;
-    const route = d.routes?.find((r) => r.key === this.recipeDef().route);
+    const route = d.routes?.find((r) => r.key === this.recipeDef(order).route);
     return (route?.steps ?? []).map((sk) => d.operations?.find((o) => o.key === sk)).filter((o) => !!o);
   }
-  /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 raw-store 에 생성. */
+  /** 정의 모드 수령 — skuMix gtin 이 레시피 입력 자재면 **그 자재가 선언한 자리**에 생성. */
   onArrivalDef(spec) {
-    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);
+    const inputKey = this.recipesDef().flatMap((r) => r.inputs.map((i) => i.material)).find((k) => this.classOf(k) === gtin);
     if (!inputKey) return;
+    const store = this.locationOfMaterial(inputKey);
     const epc = this.serialOf(inputKey, ++this.epcSeq);
-    this.items.set(epc, { epc, gtin, qty: 1, location: rawStore.id, disposition: DISP.sellable });
-    rawStore.occupancy++;
-    this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.receiving, disposition: DISP.sellable, epcList: [epc], quantityList: [{ epcClass: gtin, quantity: 1 }], readPoint: rawStore.id, bizLocation: rawStore.id }));
+    this.items.set(epc, { epc, gtin, qty: 1, location: store.id, disposition: DISP.sellable });
+    store.occupancy++;
+    this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.receiving, disposition: DISP.sellable, epcList: [epc], quantityList: [{ epcClass: gtin, quantity: 1 }], readPoint: store.id, bizLocation: store.id }));
+  }
+  /**
+   * 정의 모드 작업지시 — 레시피 산출물 1개. **오더가 자기 레시피를 든다**(§`FlowOrder.recipeKey`).
+   *
+   * 선언 수준의 `recipeKey` 가 있으면 그 하나만 만든다(현장이 한 품목만 돌린다고 말한 것이다). 없으면
+   * 선언된 레시피를 **차례로** 돈다 — 그것이 제품 전환이고, 체인지오버 셋업은 `changeoverKey`(산출물
+   * 클래스)가 달라지는 것으로 자동으로 따라온다. 커널 상수 제품 목록이 필요했던 이유가 이것이었다.
+   *
+   * 차례는 `orderSeq` 로 정한다 — 난수를 쓰면 fork 예측이 결정적이지 않게 된다.
+   */
+  /**
+   * **작업지시의 거래 문서 식별자** — 선언이 정하고, 커널은 문서 타입을 정하지 않는다.
+   *
+   * ── 무엇이 틀렸나 (2026-08-21) ────────────────────────────────────────────
+   * 여기는 `gdtiUri(prefix, '403', seq)` 였다. GDTI 는 `회사 프리픽스 + 문서 타입 + 일련번호`이고
+   * **문서 타입은 GS1 이 공표하는 목록이 아니다** — 프리픽스를 배정받은 회사가 자기 번호 용량에서
+   * 정한다. 그런데 커널이 `'403'` 을 스스로 정해 저널에 영구히 기록했다. 회사의 배정 권한을 커널이
+   * 대신 행사한 것이고, 프리픽스 날조와 같은 종류다.
+   *
+   * ── 순서 ──────────────────────────────────────────────────────────────────
+   * ① 선언된 이름공간이 있으면 그 아래 `bt` 형태로 만든다(CBV §8.5.4·§8.5.5). **문서 타입이 필요
+   *    없는 길**이고, 회사가 도메인만 있으면 되므로 진입장벽이 가장 낮다.
+   * ② 없고 문서 타입을 선언했으면 GDTI 로 만든다(그 현장이 GDTI 를 쓰는 것이다).
+   * ③ 둘 다 없으면 **말한다.** 지어내면 그 값이 영구 기록이 되고, 어느 화면도 그것이 발명된
+   *    번호라고 말해 주지 않는다.
+   */
+  workOrderId(serial) {
+    const identity = this.productionSpec.identity;
+    for (const ns of identity?.namespaces ?? []) {
+      const uri = bizTransactionUri(ns, serial);
+      if (uri) return uri;
+    }
+    const docType = identity?.documentTypes?.workorder;
+    if (docType) return gdtiUri(this.productionSpec.companyPrefix, docType, serial);
+    throw new Error(
+      "work order needs an identifier the model declares: either `identity.namespaces` (CBV \xA78.5.4/\xA78.5.5 `.../bt/<id>`) or `identity.documentTypes.workorder` (the GDTI document type this site assigns). The kernel does not choose a document type \u2014 GS1 assigns the company prefix, the company assigns the type."
+    );
   }
-  /** 정의 모드 작업지시 — 레시피 산출물 1개. */
   onOrderDef(_spec) {
-    const rc = this.recipeDef();
     const id = `order-${++this.orderSeq}`;
-    const wo = gdtiUri(this.productionSpec.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: [], ...this.promiseOf(_spec) };
+    const recipes = this.recipesDef();
+    const chosen = this.productionSpec.recipeKey ? void 0 : recipes[(this.orderSeq - 1) % recipes.length];
+    const rc = this.recipeDef(chosen ? { recipeKey: chosen.key } : void 0);
+    const wo = this.workOrderId(++this.soSeq);
+    const order = { id, kind: "workorder", status: "created", ...chosen ? { recipeKey: chosen.key } : {}, 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].locationType || !this.locationByType(ops[0].locationType)) return;
-    const rc = this.recipeDef();
+    const ops = this.routeOps(o);
+    if (!ops.length) return;
+    const firstType = ops[0].locationType;
+    if (!firstType) {
+      throw new Error(`route step '${ops[0].key}' declares no locationType \u2014 the kernel cannot choose where work happens`);
+    }
+    const rc = this.recipeDef(o);
     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.locations.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
+      const fromType = this.locationTypeOfMaterial(line.material);
+      const available = [...this.items.values()].filter((i) => i.gtin === g && i.disposition === DISP.sellable && this.locations.get(i.location)?.type === fromType).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);
@@ -6432,33 +6851,51 @@ var MesKernel = class extends FlowEngine {
   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 rc = this.recipeDef(order);
+    const ops = this.routeOps(order);
     const i = ops.findIndex((s) => s.key === t.kind);
     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.productionSpec.companyPrefix, "WIP", ++this.wipSeq);
-      const wipGtin = sgtinClass(this.productionSpec.companyPrefix, "WIP");
-      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 producedKey = this.producedMaterialKeyOf(t.kind);
       const next = ops[i + 1];
-      this.emitStationDef(order, next, wip2);
+      if (producedKey) {
+        const inputs = order.allocated.slice();
+        const made = this.serialOf(producedKey, ++this.wipSeq);
+        this.transform(inputs, [{ epc: made, gtin: this.classOf(producedKey), 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 = [made];
+      }
+      const carried = order.allocated[0];
+      if (!carried) {
+        throw new Error(
+          `order ${order.id} at step '${t.kind}': nothing to carry to '${next.key}' \u2014 the order holds no allocated material and this step declares no produced material. Declare the step's input or its output in the model.`
+        );
+      }
+      this.emitStationDef(order, next, carried);
       order.status = "op-" + next.key;
       this.emitOrder(order);
       return;
     }
-    const fgStore = this.locationByType("fg-store");
-    const wip = order.allocated[0];
+    const fgStore = this.locationOfMaterial(rc.outputs[0].material);
+    const consumed = order.allocated.slice();
+    if (!consumed.length) {
+      if (order.seedIncomplete) {
+        order.status = "blocked-seed-incomplete";
+        this.emitOrder(order);
+        return;
+      }
+      throw new Error(
+        `order ${order.id} at final step '${t.kind}': nothing allocated to consume \u2014 the kernel does not make a product out of nothing. Declare the recipe inputs, or the step's produced material.`
+      );
+    }
     const good = this.rng() < (this.yieldOf(t.kind) ?? DEFAULT_YIELD);
     t.outcome = good ? "good" : "scrap";
     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: loc.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+    this.transform(consumed, [{ 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;
@@ -6752,6 +7189,18 @@ var EmsKernel = class extends FlowEngine {
         startMs: w.startMs,
         endMs: w.endMs,
         ...w.maxKW !== void 0 ? { maxKW: w.maxKW } : {},
+        /*
+         * ── 선언된 것만의 합도 **사실로 남긴다** (2026-08-20) ────────────────────
+         *
+         * 상태에만 두면 저널을 읽는 쪽(성과·타임라인·요금 화면)은 총합만 본다. 실 서버에서 확인한 모양이
+         * 그랬다: 유령 계량기 300kW 가 섞인 구간이 「계약 1,000 초과 1,100」으로만 남고, 그중 얼마가
+         * 정체 모를 계량기인지 되짚을 길이 없었다. 지나간 구간의 두 수는 나중에 계산할 수 없다 —
+         * 그 순간의 지점별 kW 를 커널이 보관하지 않기 때문이다.
+         *
+         * `overContract` 는 여기서도 총합으로만 판정한다(요금이 그렇게 매겨진다). 선언된 것만으로는
+         * 넘지 않았다는 판단은 **읽는 쪽이** 이 두 수로 한다 — 판정을 두 벌 만들지 않는다.
+         */
+        ...w.maxDeclaredKW !== void 0 ? { maxDeclaredKW: w.maxDeclaredKW } : {},
         /* 총부하도 사실로 남긴다 — 이것이 없으면 저널을 읽는 쪽은 「무엇이 깎였나」를 되짚을 수 없다
            (요금은 순수요로 매겨지지만, 그 수요를 만든 것은 설비 부하다). */
         ...w.grossMaxKW !== void 0 ? { grossMaxKW: w.grossMaxKW } : {},
@@ -7828,13 +8277,11 @@ function retiredVocabularyIn(line) {
   FlowEngine,
   GUARD_PRAGMA,
   ILMD_ATTR,
+  ItemStore,
   LOCATION_SATURATION_NEAR,
   MATERIAL_PROPERTY,
   MES_BIZSTEP,
   MES_LOCATION_TYPES,
-  MES_PART_GTINS,
-  MES_PRODUCTS,
-  MES_PRODUCT_GTINS,
   MES_TYPES,
   MesKernel,
   OPERATION_PROPERTY,
@@ -7868,9 +8315,11 @@ function retiredVocabularyIn(line) {
   axisAppliesTo,
   axisInfo,
   axisSource,
+  bizTransactionUri,
   capabilitiesForType,
   capabilityOf,
   classClosure,
+  classIdentifierViolation,
   commandsOf,
   compareStates,
   computeOee,
@@ -7894,6 +8343,7 @@ function retiredVocabularyIn(line) {
   generationFractionAt,
   graiUri,
   hierarchyOf,
+  identityGroundingOf,
   inWorkCalendar,
   inWorkCalendarAt,
   ingest,