@operato/twin-kernel 0.4.1 → 0.4.3

package/dist-cjs/index.cjs

@@ -118,6 +118,7 @@ __export(index_exports, {
   transformationEvent: () => transformationEvent,
   validateDomainDefinition: () => validateDomainDefinition,
   validateEpcisEvent: () => validateEpcisEvent,
+  validateScenario: () => validateScenario,
   weekdayAt: () => weekdayAt,
   workingTimeOfWeek: () => workingTimeOfWeek
 });
@@ -390,8 +391,21 @@ var OP_EVENT = {
   /** 물리 자산 상태 전이 — 어디 있나·무엇을 싣고 있나(빈 팔레트인가). */
   asset: "asset.status",
   order: "order.status",
-  quality: "quality.output"
+  quality: "quality.output",
   // 품질 산출(양품/불량) — OEE quality 입력. live 누적기가 이걸로 good/scrap 정확 추적.
+  /**
+   * 주목 신호 확인(ack) — **사람이 한 행위**라 파생될 수 없다.
+   *
+   * 다른 파생 상태는 상태에서 다시 계산된다(주목 신호 자체가 그렇다). 그런데 "누가 이것을 봤다" 는
+   * 계산으로 되살릴 수 없다. 저널에 남기지 않으면 재기동하면 확인해 둔 신호가 다시 빨개지고,
+   * 과거를 되짚어도 그때 무엇을 확인했는지 알 수 없다 — 저널이 현실을 불완전하게 담는 자리였다.
+   */
+  /*
+   * 값이 커맨드(`CMD.attentionAck='attention.ack'`)와 겹치지 않게 **과거형**으로 둔다 — 커맨드는
+   * "확인해라"(요청)이고 이벤트는 "확인했다"(사실)다. 같은 문자열을 쓰면 저널에서 요청과 사실이
+   * 구별되지 않는다.
+   */
+  attentionAck: "attention.acked"
 };
 var CMD = {
   orderHold: "order.hold",
@@ -433,6 +447,50 @@ function readBoardAssets(def) {
   return list.map((a) => normalizeHomeLocation(a));
 }
 
+// src/scenario-validate.ts
+var DISTRIBUTIONS = /* @__PURE__ */ new Set(["poisson", "uniform", "constant", "profile"]);
+var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+var bad = (errorCode, errorParams) => ({ ok: false, errorCode, errorParams });
+function validateGenerator(g, at) {
+  if (!g || typeof g !== "object") return bad("scenario-generator-invalid", { at });
+  if (!g.kind || typeof g.kind !== "string") return bad("scenario-generator-kind-required", { at });
+  const rate = g.rate;
+  if (!rate || typeof rate !== "object") return bad("scenario-rate-required", { at, kind: g.kind });
+  if (!isNum(rate.meanPerHour) || rate.meanPerHour < 0) return bad("scenario-rate-mean-invalid", { at, kind: g.kind });
+  if (!DISTRIBUTIONS.has(rate.distribution)) return bad("scenario-rate-distribution-invalid", { at, kind: g.kind, distribution: String(rate.distribution ?? "") });
+  if (rate.distribution === "profile" && !Array.isArray(rate.profile)) return bad("scenario-rate-profile-required", { at, kind: g.kind });
+  const content = g.content;
+  if (!content || typeof content !== "object") return bad("scenario-content-required", { at, kind: g.kind });
+  if (!Array.isArray(content.skuMix) || content.skuMix.length === 0) return bad("scenario-sku-mix-required", { at, kind: g.kind });
+  for (const s of content.skuMix) {
+    if (!s?.gtin || typeof s.gtin !== "string") return bad("scenario-sku-gtin-required", { at, kind: g.kind });
+    if (!isNum(s.weight) || s.weight <= 0) return bad("scenario-sku-weight-invalid", { at, kind: g.kind, gtin: String(s.gtin) });
+  }
+  const q = content.qtyPerLine;
+  if (!q || !isNum(q.min) || !isNum(q.max)) return bad("scenario-qty-required", { at, kind: g.kind });
+  if (q.min < 0 || q.max < q.min) return bad("scenario-qty-range-invalid", { at, kind: g.kind, min: q.min, max: q.max });
+  const l = content.linesPerOrder;
+  if (l && (!isNum(l.min) || !isNum(l.max) || l.min < 1 || l.max < l.min)) return bad("scenario-lines-range-invalid", { at, kind: g.kind });
+  if (g.stimulus !== void 0 && g.stimulus !== "arrival" && g.stimulus !== "order") {
+    return bad("scenario-stimulus-invalid", { at, kind: g.kind, stimulus: String(g.stimulus) });
+  }
+  return { ok: true };
+}
+function validateScenario(def) {
+  if (!def || typeof def !== "object") return bad("scenario-invalid");
+  if (def.seed !== void 0 && !isNum(def.seed)) return bad("scenario-seed-invalid");
+  if (def.speed !== void 0 && (!isNum(def.speed) || def.speed <= 0)) return bad("scenario-speed-invalid");
+  if (def.horizon !== void 0 && (!isNum(def.horizon) || def.horizon < 0)) return bad("scenario-horizon-invalid");
+  const gens = def.generators;
+  if (gens === void 0) return { ok: true };
+  if (!Array.isArray(gens)) return bad("scenario-generators-invalid");
+  for (let i = 0; i < gens.length; i++) {
+    const r = validateGenerator(gens[i], i);
+    if (!r.ok) return r;
+  }
+  return { ok: true };
+}
+
 // src/domain-definition.ts
 var OP_PARAM = {
   /** 양품률(0..1, 무차원). 없으면 커널 기본값 — 기본값을 쓴 사실은 `specCoverage()` 가 밝힌다. */
@@ -858,6 +916,8 @@ var ObservedReducer = class {
   persons = /* @__PURE__ */ new Map();
   assets = /* @__PURE__ */ new Map();
   orders = /* @__PURE__ */ new Map();
+  /** 확인해 둔 주목 신호 id — `attention.acked` 이벤트로만 들어온다(계산으로 만들지 않는다). */
+  acked = /* @__PURE__ */ new Set();
   revision = 0;
   /** 받은 정정 선언 — 상태에 반영하지 않되 **버리지도 않는다**(소비처가 볼 수 있게). */
   corrections = [];
@@ -1095,6 +1155,11 @@ var ObservedReducer = class {
         this.touchLocation(d.location);
         break;
       }
+      case OP_EVENT.attentionAck: {
+        const d = e.data;
+        if (d?.id) this.acked.add(d.id);
+        return;
+      }
       case OP_EVENT.order: {
         const d = e.data;
         if (this.stale(`order:${d.orderId}`, e)) return;
@@ -1311,7 +1376,8 @@ var ObservedReducer = class {
       assets: [...this.assets.values()].map((a) => ({ ...a, ...this.effectivityPart(a) })),
       tasks: [...this.tasks.values()].map((t) => ({ ...t })),
       equipment: [...this.equipment.values()].map((m) => ({ ...m, ...this.effectivityPart(m), ...this.offShiftPart(`eq:${m.id}`) })),
-      orders: [...this.orders.values()].map((o) => ({ ...o }))
+      orders: [...this.orders.values()].map((o) => ({ ...o })),
+      acked: [...this.acked]
     };
   }
 };
@@ -1372,24 +1438,27 @@ var BTT = {
   po: "urn:epcglobal:cbv:btt:po",
   so: "urn:epcglobal:cbv:btt:so"
 };
-var WMS_LOCATION_TYPES = ["dock", "storage", "staging", "dock-ship"];
+var WMS_LOCATION_TYPES = ["dock", "storage", "staging", "dock-ship", "vas-station"];
 var WMS_TYPES = [
-  ...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"] }
+  ...WMS_LOCATION_TYPES.filter((k) => k !== "vas-station").map((k) => ({ key: k, role: "location", label: `twin.type.${k}`, standardClass: { epcis: "bizLocation" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable"] })),
+  { key: "vas-station", role: "location", label: "twin.type.vas-station", standardClass: { epcis: "bizLocation", isa95: "WorkCenter" }, identity: { scheme: "gs1:SGLN" }, capabilities: ["storable", "processable"] },
+  { key: "forklift", role: "equipment", label: "twin.type.forklift", standardClass: { epcis: "object", iso55000: "Asset" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["mobile", "operable"] },
+  /** 유통가공 작업자·작업대 설비 — 가공을 수행하는 능동 자원(ISA-95 `Equipment`). */
+  { key: "packer", role: "equipment", label: "twin.type.packer", standardClass: { epcis: "object", isa95: "Equipment" }, identity: { scheme: "gs1:GIAI" }, capabilities: ["processable", "operable"] }
 ];
 
 // src/capability.ts
 var CAPABILITIES = {
   operable: {
     key: "operable",
-    label: "\uC6B4\uC601",
+    label: "twin.capability.operable",
     semantics: "\uB2A5\uB3D9 \uC790\uC6D0\uC758 \uC6B4\uC601 \uC0C1\uD0DC(\uC720\uD734/\uAC00\uB3D9/\uACE0\uC7A5). status \uAD50\uCC28 \uAD00\uC2EC\uC0AC\uB97C \uC5EC\uAE30 \uD558\uB098\uB85C.",
     stateFields: ["status"],
     results: ["statusChanged"]
   },
   storable: {
     key: "storable",
-    label: "\uC800\uC7A5",
+    label: "twin.capability.storable",
     semantics: "\uC544\uC774\uD15C\uC744 \uBCF4\uC720\uD558\uB294 \uC704\uCE58 \u2014 \uC810\uC720/\uC6A9\uB7C9. (\uC52C \uAE30\uC81C: Capacity)",
     stateFields: ["occupancy", "capacity"],
     invariants: ["0 <= occupancy <= capacity (capacity>0)"],
@@ -1397,7 +1466,7 @@ var CAPABILITIES = {
   },
   mobile: {
     key: "mobile",
-    label: "\uC774\uB3D9",
+    label: "twin.capability.mobile",
     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"],
@@ -1405,14 +1474,14 @@ var CAPABILITIES = {
   },
   processable: {
     key: "processable",
-    label: "\uAC00\uACF5",
+    label: "twin.capability.processable",
     semantics: "\uBCC0\uD658/\uAC00\uACF5 \uC218\uD589 \u2014 \uC0B0\uCD9C(\uC591\uD488/\uBD88\uB7C9). \uC6B4\uC601 status \uB294 Operable \uC870\uD569. progress \uBC29\uCD9C\uC740 \uD6C4\uC18D.",
     stateFields: ["output"],
     results: ["completed"]
   },
   trackable: {
     key: "trackable",
-    label: "\uCD94\uC801",
+    label: "twin.capability.trackable",
     semantics: "\uC624\uB354/\uC544\uC774\uD15C \uC0DD\uC560 \uCD94\uC801 \u2014 \uC0DD\uC560\uB2E8\uACC4(\uB3C4\uBA54\uC778 \uB77C\uBCA8, \uBB34\uBC29\uC5B8)\xB7\uC9C4\uD589\xB7\uBCF4\uB958.",
     stateFields: ["lifecycle", "progress", "held"],
     results: ["lifecycleChanged"]
@@ -2023,6 +2092,7 @@ var FlowEngine = class {
   // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
   loadBoard(def) {
     this.boardDef = def;
+    if (def.productionSpec?.definition?.operations?.length) this.loadOperations(def.productionSpec.definition.operations);
     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]));
@@ -2075,6 +2145,7 @@ var FlowEngine = class {
     this.revision = from;
   }
   hydrateObserved(snap, orders = []) {
+    for (const id of snap.acked ?? []) this._acked.add(id);
     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 });
     }
@@ -2282,6 +2353,14 @@ var FlowEngine = class {
   _attentionSince = /* @__PURE__ */ new Map();
   // 확인(ack)된 주목 신호 id — 조건 지속돼도 acknowledged 로 표시(재발 시 재활성)
   dispatch(cmd) {
+    this._correlationId = cmd.correlationId ?? cmd.commandId;
+    try {
+      return this.dispatchInner(cmd);
+    } finally {
+      this._correlationId = void 0;
+    }
+  }
+  dispatchInner(cmd) {
     const ok = () => ({ commandId: cmd.commandId, accepted: true });
     const fail = (errorCode, errorParams) => ({ commandId: cmd.commandId, accepted: false, errorCode, errorParams, error: errorCode });
     switch (cmd.type) {
@@ -2296,7 +2375,10 @@ var FlowEngine = class {
       }
       case CMD.attentionAck: {
         const id = cmd.args?.id;
-        if (id) this._acked.add(id);
+        if (id) {
+          this._acked.add(id);
+          this.emitOp(OP_EVENT.attentionAck, { id, at: this.now() });
+        }
         return ok();
       }
       // Operable 코어 — 자원(설비·설비) 제어. capability-keyed(resourceId), 모든 operable 자원 공통.
@@ -2475,7 +2557,9 @@ var FlowEngine = class {
         ...o.endTime ? { endTime: o.endTime } : {},
         held: o.held
       })),
-      attentions: this.computeAttentions()
+      attentions: this.computeAttentions(),
+      /* 확인해 둔 신호 — 스냅샷으로 왕복해야 재기동 후에도 확인 상태가 유지된다. */
+      acked: [...this._acked]
     };
   }
   /*
@@ -2614,6 +2698,15 @@ var FlowEngine = class {
    * 오퍼레이션 명세를 싣는다 — 도메인 정의(ISA-95 OperationsSegment)의 시뮬 명세를 커널이 소비하는 입구.
    * 같은 key 를 다시 실으면 덮어쓴다(정의가 권위).
    */
+  /**
+   * 선언된 오퍼레이션들 — 도메인 커널이 "무엇을 만들 수 있나" 를 물을 수 있게.
+   *
+   * `operationSpecs` 를 도메인이 직접 뒤지지 않게 읽기 창구를 둔다: 저장 형태(맵)가 바뀌어도
+   * 도메인은 몰라야 하고, 도메인이 그 맵에 쓰는 일이 생기면 정의가 권위라는 규약이 깨진다.
+   */
+  declaredOperations() {
+    return [...this.operationSpecs.values()];
+  }
   loadOperations(ops = []) {
     for (const o of ops) if (o?.key) this.operationSpecs.set(o.key, o);
   }
@@ -2929,14 +3022,25 @@ var FlowEngine = class {
     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;
   }
+  /**
+   * 지금 처리 중인 커맨드의 상관값 — **디스패치 동안에만 있다.**
+   *
+   * 커맨드가 낳은 이벤트에 이 값을 실어야 "이 지시가 실제로 무엇을 일으켰나" 를 나중에 물을 수 있다.
+   * 그게 없으면 승인 기록은 "허락했다" 까지이고, 그 뒤 공장이 어떻게 움직였는지와 이어지지 않는다.
+   *
+   * **한계를 밝힌다**: 여기서 잇는 것은 그 자리에서 방출된 이벤트뿐이다. 나중 틱에 일어나는 후속
+   * (예: resourceDown 이 정한 수리 완료)은 시뮬 시간의 결과라 이어지지 않는다. 즉시 인과만 잇는다 —
+   * 먼 인과까지 같은 값으로 묶으면 "이 승인 때문"이라는 말이 사실보다 넓어진다.
+   */
+  _correlationId;
   emit(event) {
     this.revision++;
-    const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType: `epcis.${event.type}`, eventTime: event.eventTime, tenantId: this.tenantId, data: event };
+    const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType: `epcis.${event.type}`, eventTime: event.eventTime, tenantId: this.tenantId, ...this._correlationId ? { correlationId: this._correlationId } : {}, data: event };
     for (const h of this.handlers) h(e);
   }
   emitOp(eventType, data) {
     this.revision++;
-    const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, data };
+    const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType, eventTime: this.now(), tenantId: this.tenantId, ...this._correlationId ? { correlationId: this._correlationId } : {}, data };
     for (const h of this.handlers) h(e);
   }
   /**
@@ -3682,6 +3786,59 @@ var FlowEngine = class {
   }
 };
 
+// src/make-to-order.ts
+function producedByIndex(ops) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const op of ops) {
+    if (op.intent !== "process") continue;
+    for (const m of op.materialSpecification ?? []) {
+      if (m.use !== "produced") continue;
+      if (!m.materialDefinition) continue;
+      if (!idx.has(m.materialDefinition)) idx.set(m.materialDefinition, op);
+    }
+  }
+  return idx;
+}
+var consumedOf = (op) => (op.materialSpecification ?? []).filter((m) => m.use === "consumed" && (m.quantity ?? 0) > 0);
+var outputPerRun = (op, gtin) => {
+  const spec = (op.materialSpecification ?? []).find((m) => m.use === "produced" && m.materialDefinition === gtin);
+  return Math.max(1, spec?.quantity ?? 1);
+};
+function planMakeToOrder(gtin, shortQty, ops, stock, locations) {
+  const op = producedByIndex(ops).get(gtin);
+  if (!op) return { steps: [], reason: "not-producible" };
+  const station = op.locationType ? locations.find((l) => l.type === op.locationType) : void 0;
+  if (!station) return { steps: [], reason: "no-station" };
+  const need = consumedOf(op);
+  if (!need.length) {
+    return { steps: [{ step: "process", operation: op.key, at: station.id }] };
+  }
+  const runs = Math.max(1, Math.ceil(shortQty / outputPerRun(op, gtin)));
+  const feeds = [];
+  let short = false;
+  for (const req of need) {
+    const want = (req.quantity ?? 0) * runs;
+    const atStation = stock.filter((s) => s.location === station.id && matches(s, req)).reduce((n, s) => n + s.qty, 0);
+    let missing = want - atStation;
+    if (missing <= 0) continue;
+    for (const s of stock) {
+      if (missing <= 0) break;
+      if (s.location === station.id || !s.sellable || !matches(s, req)) continue;
+      const take = Math.min(s.qty, missing);
+      feeds.push({ step: "feed", gtin: s.gtin, from: s.location, to: station.id, qty: take });
+      missing -= take;
+    }
+    if (missing > 0) short = true;
+  }
+  if (short) return { steps: [], reason: "short-materials" };
+  if (feeds.length) return { steps: feeds, reason: "waiting-feed" };
+  return { steps: [{ step: "process", operation: op.key, at: station.id }] };
+}
+function matches(s, req) {
+  if (req.materialDefinition) return s.gtin === req.materialDefinition;
+  return false;
+}
+
 // src/kernel.ts
 var TRAVEL_MS = 3e4;
 var COMPANY_PREFIX = "0614141";
@@ -3809,7 +3966,7 @@ var WmsKernel = class extends FlowEngine {
         chosenAll.push(epc);
       }
     }
-    if (chosenAll.length === 0) return;
+    if (chosenAll.length === 0) return this.makeShortLines(o);
     this.reserve(chosenAll, BIZSTEP.storing);
     this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: BIZSTEP.picking, bizTransactionList: [{ type: BTT.so, bizTransaction: o.bizTransaction }], epcList: chosenAll.slice() }));
     for (const epc of chosenAll) {
@@ -3824,6 +3981,7 @@ var WmsKernel = class extends FlowEngine {
   }
   /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
   onTaskComplete(t) {
+    if (t.intent === "process") return this.onProcessComplete(t);
     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);
@@ -3831,6 +3989,10 @@ var WmsKernel = class extends FlowEngine {
     from.occupancy--;
     to.occupancy++;
     item.location = 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;
+    }
     if (t.kind === "putaway") {
       item.disposition = DISP.sellable;
       this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: BIZSTEP.storing, disposition: DISP.sellable, epcList: [item.epc], quantityList: [{ epcClass: item.gtin, quantity: item.qty }], readPoint: to.id, bizLocation: to.id }));
@@ -3843,6 +4005,112 @@ var WmsKernel = class extends FlowEngine {
     order.picked.push(item.epc);
     if (order.picked.length === order.allocated.length) this.finalizeOrder(order, to);
   }
+  // ── 수요가 부르는 생산(유통가공) ────────────────────────────────────────────
+  /**
+   * 부족한 라인을 **만들어서** 채운다 — 부품 이송 → 가공 → 되돌리기 3단 사슬.
+   *
+   * 사슬인 이유는 커널의 두 규칙 때문이다(둘 다 의도된 규칙이라 우회하지 않는다):
+   * 자재는 **작업이 일어나는 자리에** 있어야 소비되고, 산출물은 `in_progress` 로 태어나 **팔 수 있는
+   * 재고가 아니다.** 그래서 부품을 작업대로 옮기고, 가공하고, 나온 것을 보관 자리로 되돌린다.
+   *
+   * **한 오더에 사슬 하나만** 굴린다. 매 tick 마다 다시 발행하면 같은 부품을 두 번 끌어오는 작업이
+   * 쌓이고, 그중 하나만 성공한 뒤 나머지는 영원히 재료를 기다린다.
+   */
+  makeShortLines(o) {
+    if (!o.lines?.length) return;
+    if (this.hasOpenMakeChain(o.id)) return;
+    const stock = this.stockLines();
+    const locations = [...this.locations.values()].map((l) => ({ id: l.id, type: l.type }));
+    const ops = this.declaredOperations();
+    for (const line of o.lines) {
+      const have = stock.filter((s) => s.gtin === line.gtin && s.sellable && this.locations.get(s.location)?.type === "storage").reduce((n, s) => n + s.qty, 0);
+      const short = line.requested - have;
+      if (short <= 0) continue;
+      const plan = planMakeToOrder(line.gtin, short, ops, stock, locations);
+      for (const step of plan.steps) {
+        if (step.step === "feed") this.issueFeed(o, step.gtin, step.from, step.to, step.qty);
+        else this.issueProcess(o, step.operation, step.at);
+      }
+      if (plan.steps.length) return;
+    }
+  }
+  /** 이 오더가 굴리고 있는 생산 사슬이 있나 — 이송·가공·되돌리기 중 하나라도 열려 있으면 그렇다. */
+  hasOpenMakeChain(orderId) {
+    for (const t of this.tasks.values()) {
+      if (t.orderId !== orderId || t.status === "completed") continue;
+      if (t.kind === "feed" || t.intent === "process") return true;
+      if (t.kind === "putaway" && t.orderId === orderId) return true;
+    }
+    return false;
+  }
+  /** 지금 재고 — 판단 함수가 보는 형태로. */
+  stockLines() {
+    return [...this.items.values()].filter((i) => i.gtin).map((i) => ({ gtin: i.gtin, location: i.location, qty: i.qty ?? 1, sellable: i.disposition === DISP.sellable }));
+  }
+  /** 부품을 작업대로 — 팔레트 이동이므로 피킹과 같은 기제다(부분 소비는 코어가 한다). */
+  issueFeed(o, gtin, from, to, qty) {
+    const src = [...this.items.values()].find((i) => i.gtin === gtin && i.location === from && i.disposition === DISP.sellable);
+    if (!src) return;
+    src.disposition = DISP.reserved;
+    this.pushTask(o, "feed", src.epc, from, to);
+  }
+  /** 가공 — 작업 종류를 **오퍼레이션 키**로 둔다(코어가 그 키로 명세를 찾는다). */
+  issueProcess(o, operation, at) {
+    this.pushTask(o, operation, "", at, at, "process");
+  }
+  pushTask(o, kind, itemEpc, from, to, intent) {
+    const id = `task-${++this.taskSeq}`;
+    const task = {
+      id,
+      kind,
+      status: "created",
+      itemEpc,
+      fromNode: from,
+      toNode: to,
+      resource: null,
+      remainingMs: 0,
+      durationMs: this.durationOf({ kind, fromNode: from, toNode: to }, TRAVEL_MS),
+      ...intent ? { intent } : {},
+      ...o ? { orderId: o.id } : {}
+    };
+    this.tasks.set(id, task);
+    this.emitTask(task);
+  }
+  /**
+   * 가공 완료 — 코어가 이미 소비(시작)와 산출(완료 직전)을 실행했다. 남은 일은 만든 것을 **재고로
+   * 들여놓는 것**이다: 산출물은 `in_progress` 로 태어나 팔 수 있는 재고가 아니다.
+   *
+   * ── 왜 팔레트로 묶나 ───────────────────────────────────────────────────────
+   * 코어의 산출은 **클래스+수량 줄**이고 그 키에는 자리가 박혀 있다(`품목@자리`). 창고의 출고 경로는
+   * 직렬 물류단위(팔레트 SSCC)를 다루므로, 그 줄을 그대로 출고에 태우면 키를 EPC 로 착각해 조회가
+   * 깨진다(실제로 그렇게 터졌다). 억지로 태우면 EPCIS 에도 **EPC 가 아닌 문자열**이 `epcList` 로
+   * 나가는데, 그것은 코어가 산출에서 경계한 바로 그 일이다.
+   *
+   * 그래서 만든 물건을 **입고가 하는 것과 같은 방식**으로 들여놓는다: 팔레트(SSCC)를 만들고 그 안에
+   * 세트 N개를 담는다(AggregationEvent). 현장에서도 가공물은 팔레트에 실려 보관으로 간다.
+   * 그 뒤는 기존 경로 그대로다 — `putaway` 로 보관 자리에 넣으면 판매 가능이 된다.
+   */
+  onProcessComplete(t) {
+    const made = (t.materialActual ?? []).filter((m) => m.use === "produced");
+    const order = t.orderId ? this.orders.get(t.orderId) : void 0;
+    const at = t.toNode;
+    for (const m of made) {
+      const key = subLotIdOf(m.definitionId, at);
+      const row = this.items.get(key);
+      if (!row) continue;
+      const qty = row.qty ?? 0;
+      if (qty <= 0) continue;
+      this.items.delete(key);
+      const pallet = ssccUri(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);
+    }
+  }
   /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
   finalizeOrder(order, staging) {
     const shipDock = this.locationByType("dock-ship") ?? staging;
@@ -4067,13 +4335,18 @@ var MesKernel = class extends FlowEngine {
   wipSeq = 0;
   prodSeq = 0;
   /** 정의-구동 모드(선택). 미지정 시 레거시 하드코딩 경로 — byte-identical. */
-  mesSpec;
-  constructor(tenantId, policy = firstFitPolicy, mesSpec) {
+  productionSpec;
+  constructor(tenantId, policy = firstFitPolicy, productionSpec) {
     super(tenantId, policy);
-    this.mesSpec = mesSpec;
-    if (mesSpec?.definition?.operations) {
-      this.loadOperations(mesSpec.definition.operations);
-      this.assertNoDoubleProduction(mesSpec.definition.operations);
+    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"
+      );
     }
   }
   /**
@@ -4089,10 +4362,10 @@ var MesKernel = class extends FlowEngine {
    * 모든 계산이 거짓이 된다).
    */
   assertNoDoubleProduction(ops) {
-    const bad = ops.filter((o) => (o.materialSpecification ?? []).some((m) => m.use === "produced")).map((o) => o.key);
-    if (!bad.length) return;
+    const bad2 = ops.filter((o) => (o.materialSpecification ?? []).some((m) => m.use === "produced")).map((o) => o.key);
+    if (!bad2.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.`
+      `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.`
     );
   }
   productOf(gtin) {
@@ -4121,7 +4394,7 @@ var MesKernel = class extends FlowEngine {
   }
   /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
   onArrival(spec) {
-    if (this.mesSpec) return this.onArrivalDef(spec);
+    if (this.productionSpec) return this.onArrivalDef(spec);
     const rawStore = this.locationByType("raw-store");
     if (!rawStore) return;
     const gtin = this.pickGtin(spec.content.skuMix);
@@ -4134,7 +4407,7 @@ var MesKernel = class extends FlowEngine {
   }
   /** 작업지시 — 제품 2종 교대(체인지오버 유발). 제품 gtin 을 오더에 기록. */
   onOrder(_spec) {
-    if (this.mesSpec) return this.onOrderDef(_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);
@@ -4144,7 +4417,7 @@ var MesKernel = class extends FlowEngine {
   }
   /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + 라우트 첫 스테이션(절단) 태스크. */
   allocate(o) {
-    if (this.mesSpec) return this.allocateDef(o);
+    if (this.productionSpec) return this.allocateDef(o);
     const s0 = ROUTE[0];
     const first = this.locationByType(s0.locationType);
     const product = this.productOf(o.gtin);
@@ -4179,12 +4452,12 @@ var MesKernel = class extends FlowEngine {
    * 하나가 정확도 추세 전체를 죽였다.** 이제 코어가 이 답을 보고 그 작업만 접는다.
    */
   canComplete(t) {
-    if (this.mesSpec) return !!(t.orderId && this.orders.get(t.orderId));
+    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);
   }
   onTaskComplete(t) {
-    if (this.mesSpec) return this.onTaskCompleteDef(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`);
@@ -4217,15 +4490,15 @@ var MesKernel = class extends FlowEngine {
   }
   // ── 정의-구동 모드 (도메인 정의 데이터로 실행 — 레거시와 분리, 하드코딩 대체) ──
   recipeDef() {
-    const d = this.mesSpec.definition;
-    return this.mesSpec.recipeKey ? d.recipes?.find((r) => r.key === this.mesSpec.recipeKey) : d.recipes?.[0];
+    const d = this.productionSpec.definition;
+    return this.productionSpec.recipeKey ? d.recipes?.find((r) => r.key === this.productionSpec.recipeKey) : d.recipes?.[0];
   }
   /** 자재 키 → 구체 gtin 클래스(idpat). 구체 식별은 바인딩+prefix 로 인스턴스가 주입. */
   classOf(materialKey) {
-    return sgtinClass(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey]);
+    return sgtinClass(this.productionSpec.companyPrefix, this.productionSpec.binding[materialKey]);
   }
   serialOf(materialKey, serial) {
-    return sgtinUri(this.mesSpec.companyPrefix, this.mesSpec.binding[materialKey], serial);
+    return sgtinUri(this.productionSpec.companyPrefix, this.productionSpec.binding[materialKey], serial);
   }
   /**
    * 라우트를 용량 계산에 알려 준다 — 수율을 거슬러 올릴 때 순서가 곧 계산이다.
@@ -4234,13 +4507,13 @@ var MesKernel = class extends FlowEngine {
    * 틀린다). 생산 정의를 가진 커널만 이 답을 안다.
    */
   routeKeys() {
-    if (!this.mesSpec) return void 0;
-    const d = this.mesSpec.definition;
+    if (!this.productionSpec) return void 0;
+    const d = this.productionSpec.definition;
     return d.routes?.find((r) => r.key === this.recipeDef().route)?.steps;
   }
   /** recipe.route → 오퍼레이션 시퀀스 해소. */
   routeOps() {
-    const d = this.mesSpec.definition;
+    const d = this.productionSpec.definition;
     const route = d.routes?.find((r) => r.key === this.recipeDef().route);
     return (route?.steps ?? []).map((sk) => d.operations?.find((o) => o.key === sk)).filter((o) => !!o);
   }
@@ -4261,7 +4534,7 @@ var MesKernel = class extends FlowEngine {
   onOrderDef(_spec) {
     const rc = this.recipeDef();
     const id = `order-${++this.orderSeq}`;
-    const wo = gdtiUri(this.mesSpec.companyPrefix, "403", ++this.soSeq);
+    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) };
     this.orders.set(id, order);
     this.emitOrder(order);
@@ -4304,8 +4577,8 @@ var MesKernel = class extends FlowEngine {
     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");
+      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 next = ops[i + 1];
@@ -4473,6 +4746,7 @@ function retiredVocabularyIn(line) {
   transformationEvent,
   validateDomainDefinition,
   validateEpcisEvent,
+  validateScenario,
   weekdayAt,
   workingTimeOfWeek
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@operato/twin-kernel",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "description": "Twin Domain Kernel — framework-agnostic, zero-dep (domain + sim + 3-channel contract). WMS/YMS/MES, EPCIS 2.0 · ISA-95.",
   "publishConfig": {