@operato/twin-kernel 0.0.1

package/dist-cjs/index.cjs

@@ -0,0 +1,1477 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BIZSTEP: () => BIZSTEP,
+  BTT: () => BTT,
+  BTT_DELIVERY: () => BTT_DELIVERY,
+  BTT_PRODORDER: () => BTT_PRODORDER,
+  CMD: () => CMD,
+  DISP: () => DISP,
+  EPCIS_CONTEXT: () => EPCIS_CONTEXT,
+  EventJournal: () => EventJournal,
+  FlowEngine: () => FlowEngine,
+  MES_BIZSTEP: () => MES_BIZSTEP,
+  MES_PART_GTINS: () => MES_PART_GTINS,
+  MES_PRODUCT_GTINS: () => MES_PRODUCT_GTINS,
+  MesKernel: () => MesKernel,
+  OP_EVENT: () => OP_EVENT,
+  StateProjector: () => StateProjector,
+  TwinHistory: () => TwinHistory,
+  TwinObserver: () => TwinObserver,
+  TwinRuntime: () => TwinRuntime,
+  UTC_OFFSET: () => UTC_OFFSET,
+  WmsKernel: () => WmsKernel,
+  YARD_BIZSTEP: () => YARD_BIZSTEP,
+  YmsKernel: () => YmsKernel,
+  aggregationEvent: () => aggregationEvent,
+  compareStates: () => compareStates,
+  constantDuration: () => constantDuration,
+  counterfactualAt: () => counterfactualAt,
+  fefoPolicy: () => fefoPolicy,
+  firstFitPolicy: () => firstFitPolicy,
+  gdtiUri: () => gdtiUri,
+  graiUri: () => graiUri,
+  ingest: () => ingest,
+  mapRecord: () => mapRecord,
+  monteCarloForecast: () => monteCarloForecast,
+  objectEvent: () => objectEvent,
+  partialFitPolicy: () => partialFitPolicy,
+  replay: () => replay,
+  sgtinClass: () => sgtinClass,
+  sgtinUri: () => sgtinUri,
+  ssccUri: () => ssccUri,
+  transactionEvent: () => transactionEvent,
+  transformationEvent: () => transformationEvent,
+  validateEpcisEvent: () => validateEpcisEvent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/contract.ts
+var OP_EVENT = {
+  task: "task.status",
+  equipment: "equipment.status",
+  order: "order.status"
+};
+var CMD = {
+  orderHold: "order.hold",
+  orderResume: "order.resume",
+  orderRelease: "order.release"
+};
+
+// src/divergence.ts
+function diffBy(predicted, actual, idOf, valOf) {
+  const p = new Map(predicted.map((e) => [idOf(e), valOf(e)]));
+  const a = new Map(actual.map((e) => [idOf(e), valOf(e)]));
+  const out = [];
+  for (const id of /* @__PURE__ */ new Set([...p.keys(), ...a.keys()])) {
+    const pv = p.get(id);
+    const av = a.get(id);
+    if (pv !== av) out.push({ id, predicted: pv, actual: av });
+  }
+  return out.sort((x, y) => x.id.localeCompare(y.id));
+}
+function compareStates(predicted, actual) {
+  const itemLocation = diffBy(predicted.items, actual.items, (i) => i.epc, (i) => i.location);
+  const itemDisposition = diffBy(predicted.items, actual.items, (i) => i.epc, (i) => i.disposition);
+  const nodeOccupancy = diffBy(predicted.nodes, actual.nodes, (n) => n.id, (n) => n.occupancy);
+  const orderStatus = diffBy(predicted.orders, actual.orders, (o) => o.id, (o) => o.status);
+  const hasDrift = itemLocation.length > 0 || itemDisposition.length > 0 || nodeOccupancy.length > 0 || orderStatus.length > 0;
+  return { hasDrift, itemLocation, itemDisposition, nodeOccupancy, orderStatus };
+}
+
+// src/counterfactual.ts
+var TwinHistory = class {
+  live;
+  tickMs;
+  checkpoints = [];
+  constructor(live, opts = {}) {
+    this.live = live;
+    this.tickMs = opts.tickMs ?? 1e3;
+  }
+  /** 현재를 체크포인트로 저장(호스트가 주기적으로 호출). */
+  checkpoint() {
+    this.checkpoints.push({ simMs: this.live.getSnapshot().simClockMs, twin: this.live.fork() });
+  }
+  get count() {
+    return this.checkpoints.length;
+  }
+  /** 시각 T 의 전체 커널 — T 이하 최신 체크포인트에서 fork 후 정확히 T 로 재구동(결정적). */
+  at(simMs) {
+    let best;
+    for (const c of this.checkpoints) if (c.simMs <= simMs) best = c;
+    if (!best) return void 0;
+    const t = best.twin.fork();
+    let guard = 0;
+    while (t.getSnapshot().simClockMs < simMs && guard++ < 1e6) t.tick(this.tickMs);
+    return t;
+  }
+};
+function counterfactualAt(history, atSimMs, opts) {
+  const base = history.at(atSimMs);
+  if (!base) return void 0;
+  const step = opts.tickMs ?? 1e3;
+  const target = atSimMs + opts.horizonMs;
+  const withAlt = base.fork();
+  opts.alternative(withAlt);
+  const baseline = base.fork();
+  const run = (t) => {
+    let g = 0;
+    while (t.getSnapshot().simClockMs < target && g++ < 1e6) t.tick(step);
+  };
+  run(withAlt);
+  run(baseline);
+  return { atSimMs, withAlt: withAlt.getSnapshot(), baseline: baseline.getSnapshot(), effect: compareStates(withAlt.getSnapshot(), baseline.getSnapshot()) };
+}
+
+// src/forecast.ts
+function monteCarloForecast(twin, opts) {
+  const now = twin.getSnapshot().simClockMs;
+  const step = opts.tickMs ?? 1e3;
+  const baseSeed = opts.scenario.seed ?? 1;
+  const samples = [];
+  for (let i = 0; i < opts.runs; i++) {
+    const fc = twin.fork();
+    fc.scenario.load({ ...opts.scenario, seed: baseSeed + i });
+    fc.scenario.start();
+    const target = now + opts.horizonMs;
+    let guard = 0;
+    while (fc.getSnapshot().simClockMs < target && guard++ < 1e6) fc.tick(step);
+    samples.push(opts.metric(fc.getSnapshot()));
+  }
+  return summarize(opts.runs, samples);
+}
+function summarize(runs, samples) {
+  const sorted = [...samples].sort((a, b) => a - b);
+  const pct = (p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];
+  const mean = samples.reduce((a, b) => a + b, 0) / (samples.length || 1);
+  return { runs, samples, min: sorted[0], max: sorted[sorted.length - 1], mean, p50: pct(0.5), p90: pct(0.9) };
+}
+
+// src/twin-observer.ts
+var TwinObserver = class {
+  live;
+  opts;
+  pending = [];
+  constructor(live, opts) {
+    this.live = live;
+    this.opts = opts;
+  }
+  /** 관측 1회 — 만기 예측을 실제와 대조(발산 알림) + 새 예측 생성. 호스트가 주기적으로 호출. */
+  observe() {
+    const now = this.live.getSnapshot().simClockMs;
+    const due = this.pending.filter((p) => p.horizonSimMs <= now);
+    this.pending = this.pending.filter((p) => p.horizonSimMs > now);
+    for (const p of due) {
+      const d = compareStates(p.predicted, this.live.getSnapshot());
+      if (d.hasDrift) this.opts.onDivergence?.({ forecastAtSimMs: p.madeAtSimMs, horizonSimMs: p.horizonSimMs, divergence: d });
+    }
+    const fc = this.live.fork();
+    const step = this.opts.tickMs ?? 1e3;
+    const target = now + this.opts.horizonMs;
+    let guard = 0;
+    while (fc.getSnapshot().simClockMs < target && guard++ < 1e6) fc.tick(step);
+    this.pending.push({ madeAtSimMs: now, horizonSimMs: fc.getSnapshot().simClockMs, predicted: fc.getSnapshot() });
+  }
+  /** 대기 중(아직 만기 안 된) 예측 수 — 진단용. */
+  get pendingCount() {
+    return this.pending.length;
+  }
+};
+
+// src/state-projector.ts
+var StateProjector = class {
+  master = /* @__PURE__ */ new Map();
+  items = /* @__PURE__ */ new Map();
+  aggregation = /* @__PURE__ */ new Map();
+  // parent SSCC → child EPCs
+  tasks = /* @__PURE__ */ new Map();
+  movers = /* @__PURE__ */ new Map();
+  orders = /* @__PURE__ */ new Map();
+  revision = 0;
+  constructor(board) {
+    for (const n of board.nodes) this.master.set(n.id, { id: n.id, type: n.type, capacity: n.capacity });
+    for (const m of board.movers) this.movers.set(m.id, { id: m.id, kind: m.kind, status: "idle", location: m.homeNode });
+  }
+  /** 마스터 동기 — 로케이션 추가/변경/제거. */
+  applyMaster(u) {
+    if (u.op === "remove") {
+      this.master.delete(u.node.id);
+      return;
+    }
+    const cur = this.master.get(u.node.id);
+    this.master.set(u.node.id, {
+      id: u.node.id,
+      type: u.node.type ?? cur?.type ?? "unknown",
+      capacity: u.node.capacity ?? cur?.capacity ?? 0
+    });
+  }
+  /** 이벤트 1건 반영 — eventType 으로 EPCIS vs 운영 델타 분기. */
+  apply(e) {
+    this.revision++;
+    if (e.eventType.startsWith("epcis.")) {
+      this.applyEpcis(e.data);
+      return;
+    }
+    switch (e.eventType) {
+      case OP_EVENT.task: {
+        const d = e.data;
+        this.tasks.set(d.taskId, { id: d.taskId, kind: d.kind, status: d.status, fromNode: d.fromNode, toNode: d.toNode, itemRefs: d.itemRefs, resourceRef: d.resourceRef });
+        break;
+      }
+      case OP_EVENT.equipment: {
+        const d = e.data;
+        this.movers.set(d.moverId, { id: d.moverId, kind: d.kind, status: d.status, location: d.location, motion: d.motion });
+        break;
+      }
+      case OP_EVENT.order: {
+        const d = e.data;
+        this.orders.set(d.orderId, { id: d.orderId, kind: d.kind, status: d.status, progress: d.requested ? d.fulfilled / d.requested : 0, held: d.held });
+        break;
+      }
+    }
+  }
+  applyEpcis(ev) {
+    if (ev.type === "AggregationEvent") {
+      if (ev.action === "ADD" && ev.childEPCs?.length) this.aggregation.set(ev.parentID, [...ev.childEPCs]);
+      else if (ev.action === "DELETE") this.aggregation.delete(ev.parentID);
+      return;
+    }
+    if (ev.type === "TransactionEvent") return;
+    if (ev.type === "TransformationEvent") {
+      for (const epc of ev.inputEPCList ?? []) this.remove(epc);
+      const loc2 = ev.readPoint?.id ?? "";
+      for (const epc of ev.outputEPCList ?? []) this.items.set(epc, { epc, location: loc2, disposition: ev.disposition });
+      return;
+    }
+    if (ev.action === "DELETE") {
+      for (const epc of ev.epcList) this.remove(epc);
+      return;
+    }
+    const loc = ev.readPoint?.id;
+    const gtin = ev.quantityList?.[0]?.epcClass;
+    for (const epc of ev.epcList) {
+      const cur = this.items.get(epc);
+      this.items.set(epc, { epc, gtin: gtin ?? cur?.gtin, location: loc ?? cur?.location ?? "", disposition: ev.disposition ?? cur?.disposition });
+    }
+  }
+  /** 이탈(DELETE) — 아이템 + 조립 자식(재귀) 제거. 화물 SSCC DELETE 시 팔레트도 함께 이탈. */
+  remove(epc) {
+    this.items.delete(epc);
+    const children = this.aggregation.get(epc);
+    if (children) {
+      this.aggregation.delete(epc);
+      for (const c of children) this.remove(c);
+    }
+  }
+  /** 현재 투영 State — 노드 점유는 아이템 위치 집계로 유도(pure projection). */
+  snapshot() {
+    const occ = /* @__PURE__ */ new Map();
+    for (const it of this.items.values()) occ.set(it.location, (occ.get(it.location) ?? 0) + 1);
+    return {
+      revision: this.revision,
+      nodes: [...this.master.values()].map((n) => ({ id: n.id, type: n.type, capacity: n.capacity, occupancy: occ.get(n.id) ?? 0 })),
+      items: [...this.items.values()].map((i) => ({ epc: i.epc, gtin: i.gtin, location: i.location, disposition: i.disposition })),
+      tasks: [...this.tasks.values()].map((t) => ({ ...t })),
+      movers: [...this.movers.values()].map((m) => ({ ...m })),
+      orders: [...this.orders.values()].map((o) => ({ ...o }))
+    };
+  }
+};
+
+// src/event-journal.ts
+var EventJournal = class {
+  events = [];
+  /** 이벤트 1건 기록(추가 전용). runtime/kernel 의 onEvent 에 연결. */
+  append(e) {
+    this.events.push(e);
+  }
+  get length() {
+    return this.events.length;
+  }
+  all() {
+    return this.events;
+  }
+  /** 처음 revision 개(= 시점 T까지). revision 은 emit 당 1 증가하므로 slice(0,rev). */
+  until(revision) {
+    return this.events.slice(0, revision);
+  }
+  /** revision 이후(재동기·증분 전송용). */
+  since(revision) {
+    return this.events.slice(revision);
+  }
+  /** sim 시각(ISO eventTime) 이하 이벤트. */
+  untilSimTime(iso) {
+    return this.events.filter((e) => e.eventTime <= iso);
+  }
+};
+function replay(board, events) {
+  const proj = new StateProjector(board);
+  for (const e of events) proj.apply(e);
+  return proj.snapshot();
+}
+
+// src/epcis.ts
+var EPCIS_CONTEXT = "https://ref.gs1.org/standards/epcis/2.0.0/epcis-context.jsonld";
+var UTC_OFFSET = "+00:00";
+var DISP = {
+  in_progress: "urn:epcglobal:cbv:disp:in_progress",
+  sellable: "urn:epcglobal:cbv:disp:sellable_accessible",
+  reserved: "urn:epcglobal:cbv:disp:reserved",
+  in_transit: "urn:epcglobal:cbv:disp:in_transit",
+  non_sellable: "urn:epcglobal:cbv:disp:non_sellable_other"
+  // 불량/scrap
+};
+function ssccUri(companyPrefix, serial) {
+  return `urn:epc:id:sscc:${companyPrefix}.${String(serial).padStart(10, "0")}`;
+}
+function sgtinClass(companyPrefix, itemRef) {
+  return `urn:epc:idpat:sgtin:${companyPrefix}.${itemRef}.*`;
+}
+function gdtiUri(companyPrefix, docType, serial) {
+  return `urn:epc:id:gdti:${companyPrefix}.${docType}.${serial}`;
+}
+function header(type, eventTime, bizStep) {
+  return { "@context": EPCIS_CONTEXT, type, eventTime, eventTimeZoneOffset: UTC_OFFSET, bizStep };
+}
+function common(type, eventTime, action, bizStep) {
+  return { ...header(type, eventTime, bizStep), action };
+}
+function objectEvent(p) {
+  const e = { ...common("ObjectEvent", p.eventTime, p.action, p.bizStep), epcList: p.epcList };
+  if (p.disposition) e.disposition = p.disposition;
+  if (p.quantityList) e.quantityList = p.quantityList;
+  if (p.readPoint) e.readPoint = { id: p.readPoint };
+  if (p.bizLocation) e.bizLocation = { id: p.bizLocation };
+  if (p.bizTransactionList) e.bizTransactionList = p.bizTransactionList;
+  return e;
+}
+function aggregationEvent(p) {
+  const e = { ...common("AggregationEvent", p.eventTime, p.action, p.bizStep), parentID: p.parentID };
+  if (p.disposition) e.disposition = p.disposition;
+  if (p.childEPCs) e.childEPCs = p.childEPCs;
+  if (p.childQuantityList) e.childQuantityList = p.childQuantityList;
+  if (p.readPoint) e.readPoint = { id: p.readPoint };
+  if (p.bizLocation) e.bizLocation = { id: p.bizLocation };
+  return e;
+}
+function transactionEvent(p) {
+  const e = {
+    ...common("TransactionEvent", p.eventTime, p.action, p.bizStep),
+    bizTransactionList: p.bizTransactionList
+  };
+  if (p.disposition) e.disposition = p.disposition;
+  if (p.parentID) e.parentID = p.parentID;
+  if (p.epcList) e.epcList = p.epcList;
+  if (p.quantityList) e.quantityList = p.quantityList;
+  if (p.readPoint) e.readPoint = { id: p.readPoint };
+  if (p.bizLocation) e.bizLocation = { id: p.bizLocation };
+  return e;
+}
+function transformationEvent(p) {
+  const e = header("TransformationEvent", p.eventTime, p.bizStep);
+  if (p.disposition) e.disposition = p.disposition;
+  if (p.inputEPCList) e.inputEPCList = p.inputEPCList;
+  if (p.inputQuantityList) e.inputQuantityList = p.inputQuantityList;
+  if (p.outputEPCList) e.outputEPCList = p.outputEPCList;
+  if (p.outputQuantityList) e.outputQuantityList = p.outputQuantityList;
+  if (p.transformationID) e.transformationID = p.transformationID;
+  if (p.readPoint) e.readPoint = { id: p.readPoint };
+  if (p.bizLocation) e.bizLocation = { id: p.bizLocation };
+  if (p.bizTransactionList) e.bizTransactionList = p.bizTransactionList;
+  return e;
+}
+var ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var TZ_RE = /^[+-]\d{2}:\d{2}$/;
+var ACTIONS = ["ADD", "OBSERVE", "DELETE"];
+function validateEpcisEvent(e) {
+  const v = [];
+  if (e["@context"] !== EPCIS_CONTEXT) v.push("@context \uB204\uB77D/\uBD88\uC77C\uCE58");
+  if (!["ObjectEvent", "AggregationEvent", "TransactionEvent", "TransformationEvent"].includes(e.type)) v.push(`\uC54C \uC218 \uC5C6\uB294 type: ${e.type}`);
+  if (typeof e.eventTime !== "string" || !ISO_RE.test(e.eventTime)) v.push("eventTime ISO8601 \uC544\uB2D8");
+  if (typeof e.eventTimeZoneOffset !== "string" || !TZ_RE.test(e.eventTimeZoneOffset)) v.push("eventTimeZoneOffset \uD615\uC2DD \uC624\uB958");
+  if (typeof e.bizStep !== "string" || !e.bizStep) v.push("bizStep \uB204\uB77D");
+  if (e.type === "ObjectEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!Array.isArray(e.epcList)) v.push("ObjectEvent.epcList \uB204\uB77D");
+    else if (e.epcList.length === 0 && !e.quantityList?.length) v.push("ObjectEvent: epcList/quantityList \uB458 \uB2E4 \uBE44\uC5B4\uC788\uC74C");
+  } else if (e.type === "AggregationEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!e.parentID) v.push("AggregationEvent.parentID \uB204\uB77D");
+    if (!e.childEPCs?.length && !e.childQuantityList?.length) v.push("AggregationEvent: childEPCs/childQuantityList \uB458 \uB2E4 \uBE44\uC5B4\uC788\uC74C");
+  } else if (e.type === "TransactionEvent") {
+    if (!ACTIONS.includes(e.action)) v.push(`action \uBD80\uC815: ${e.action}`);
+    if (!Array.isArray(e.bizTransactionList) || e.bizTransactionList.length === 0) v.push("TransactionEvent.bizTransactionList \uB204\uB77D");
+  } else if (e.type === "TransformationEvent") {
+    if (!e.inputEPCList?.length && !e.inputQuantityList?.length) v.push("TransformationEvent: input \uBE44\uC5B4\uC788\uC74C");
+    if (!e.outputEPCList?.length && !e.outputQuantityList?.length) v.push("TransformationEvent: output \uBE44\uC5B4\uC788\uC74C");
+  }
+  const qtyLists = [
+    "quantityList" in e ? e.quantityList : void 0,
+    "childQuantityList" in e ? e.childQuantityList : void 0,
+    "inputQuantityList" in e ? e.inputQuantityList : void 0,
+    "outputQuantityList" in e ? e.outputQuantityList : void 0
+  ];
+  for (const list of qtyLists) for (const q of list ?? []) {
+    if (!q.epcClass?.startsWith("urn:epc:idpat:") && !q.epcClass?.startsWith("urn:epc:class:")) v.push(`quantity epcClass \uBD80\uC815: ${q.epcClass}`);
+    if (typeof q.quantity !== "number" || q.quantity < 0) v.push("quantity \uBD80\uC815");
+  }
+  return v;
+}
+
+// src/wms-profile.ts
+var BIZSTEP = {
+  receiving: "urn:epcglobal:cbv:bizstep:receiving",
+  storing: "urn:epcglobal:cbv:bizstep:storing",
+  picking: "urn:epcglobal:cbv:bizstep:picking",
+  packing: "urn:epcglobal:cbv:bizstep:packing",
+  staging_outbound: "urn:epcglobal:cbv:bizstep:staging_outbound",
+  shipping: "urn:epcglobal:cbv:bizstep:shipping",
+  replenishing: "urn:epcglobal:cbv:bizstep:replenishing"
+};
+var BTT = {
+  po: "urn:epcglobal:cbv:btt:po",
+  so: "urn:epcglobal:cbv:btt:so"
+};
+
+// src/allocation-policy.ts
+function freeBinsFirstFit(slots) {
+  const sorted = [...slots].sort((a, b) => a.id.localeCompare(b.id));
+  for (const b of sorted) if (b.occupancy + b.reserved < b.capacity) return b.id;
+  return null;
+}
+function sortByEpc(available) {
+  return [...available].sort((a, b) => a.epc.localeCompare(b.epc));
+}
+var firstFitPolicy = {
+  selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
+  selectStock: ({ qty, available }) => {
+    if (available.length < qty) return [];
+    return sortByEpc(available).slice(0, qty).map((s) => s.epc);
+  }
+};
+var partialFitPolicy = {
+  selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
+  selectStock: ({ qty, available }) => sortByEpc(available).slice(0, qty).map((s) => s.epc)
+};
+var fefoPolicy = {
+  selectPlacement: ({ slots }) => freeBinsFirstFit(slots),
+  selectStock: ({ qty, available }) => {
+    if (available.length < qty) return [];
+    const byExpiry = [...available].sort((a, b) => (a.expiry ?? Infinity) - (b.expiry ?? Infinity) || a.epc.localeCompare(b.epc));
+    return byExpiry.slice(0, qty).map((s) => s.epc);
+  }
+};
+
+// src/duration-estimator.ts
+var constantDuration = (ms) => ({ estimate: () => ms });
+
+// src/face2-adapter.ts
+function get(obj, path) {
+  return path.split(".").reduce((o, k) => o == null ? o : o[k], obj);
+}
+function resolve(v, record) {
+  if (v === void 0) return void 0;
+  if (v.startsWith("$.")) {
+    const r = get(record, v.slice(2));
+    return r === void 0 || r === null ? void 0 : String(r);
+  }
+  return v;
+}
+function mapRecord(record, mapping, eventTime) {
+  const epc = resolve(mapping.epc, record);
+  return objectEvent({
+    eventTime,
+    action: resolve(mapping.action, record) ?? "",
+    bizStep: resolve(mapping.bizStep, record) ?? "",
+    disposition: resolve(mapping.disposition, record),
+    epcList: epc ? [epc] : [],
+    readPoint: resolve(mapping.readPoint, record),
+    bizLocation: resolve(mapping.bizLocation, record)
+  });
+}
+function ingest(records, rules, opts) {
+  const ruleByType = new Map(rules.map((r) => [r.sourceType, r]));
+  const accepted = [];
+  const rejected = [];
+  let seq = 0;
+  for (const record of records) {
+    const rule = ruleByType.get(String(record["sourceType"]));
+    if (!rule) {
+      rejected.push({ record, errors: [`\uB9E4\uCE6D \uB8F0 \uC5C6\uC74C: sourceType=${record["sourceType"]}`] });
+      continue;
+    }
+    const eventTime = (opts.eventTimePath ? resolve("$." + opts.eventTimePath, record) : void 0) ?? opts.defaultEventTime;
+    const ev = mapRecord(record, rule.mapping, eventTime);
+    const errors = validateEpcisEvent(ev);
+    if (errors.length) {
+      rejected.push({ record, errors });
+      continue;
+    }
+    accepted.push({
+      eventId: `${opts.tenantId}-ingest-${++seq}`,
+      eventType: `epcis.${ev.type}`,
+      eventTime: ev.eventTime,
+      tenantId: opts.tenantId,
+      data: ev
+    });
+  }
+  return { accepted, rejected };
+}
+
+// src/runtime.ts
+var TwinRuntime = class {
+  kernel;
+  subscribers = /* @__PURE__ */ new Set();
+  currentRevision;
+  constructor(kernel) {
+    this.kernel = kernel;
+    this.currentRevision = kernel.getSnapshot().revision;
+    kernel.onEvent((event) => {
+      this.currentRevision++;
+      const msg = { kind: "delta", revision: this.currentRevision, event };
+      for (const s of this.subscribers) s(msg);
+    });
+  }
+  /** State 채널 구독 — 즉시 현재 snapshot, 이후 델타(revision 연속). 멀티 구독자 독립. */
+  subscribe(handler) {
+    handler({ kind: "snapshot", revision: this.currentRevision, state: this.kernel.getSnapshot() });
+    this.subscribers.add(handler);
+    return { unsubscribe: () => {
+      this.subscribers.delete(handler);
+    } };
+  }
+  /** gap(revision 불연속) 감지 시 재동기 — 현재 스냅샷. */
+  resync() {
+    return { revision: this.currentRevision, state: this.kernel.getSnapshot() };
+  }
+  /** 클록-싱크 하트비트 메시지 — host 가 자기 send-rate 로 방송(⊥ tick). 클라 보간의 nowSim. */
+  nowClock() {
+    return { kind: "clock", revision: this.currentRevision, simClockMs: this.kernel.getSnapshot().simClockMs };
+  }
+  /** Command 채널. */
+  dispatch(cmd) {
+    return this.kernel.dispatch(cmd);
+  }
+  /** Clock — host 가 서버 클럭/RAF 로 구동. 실행당 엔진 1개(ADR-0010). */
+  tick(dtMs) {
+    this.kernel.tick(dtMs);
+  }
+  /** Scenario 채널(sim 모드). */
+  get scenario() {
+    return this.kernel.scenario;
+  }
+  get revision() {
+    return this.currentRevision;
+  }
+};
+
+// src/yms-profile.ts
+var YARD_BIZSTEP = {
+  arriving: "urn:epcglobal:cbv:bizstep:arriving",
+  // 게이트-인
+  staging: "urn:epcglobal:cbv:bizstep:staging",
+  // 야드 슬롯 주차·대기
+  loading: "urn:epcglobal:cbv:bizstep:loading",
+  // 도크 작업(상차: 트레일러←화물)
+  unloading: "urn:epcglobal:cbv:bizstep:unloading",
+  // 도크 작업(하차: 트레일러→화물)
+  departing: "urn:epcglobal:cbv:bizstep:departing"
+  // 게이트-아웃
+};
+var BTT_DELIVERY = "urn:epcglobal:cbv:btt:deliv";
+function graiUri(companyPrefix, assetType, serial) {
+  return `urn:epc:id:grai:${companyPrefix}.${assetType}.${String(serial).padStart(6, "0")}`;
+}
+
+// src/mes-profile.ts
+var MES_BIZSTEP = {
+  receiving: "urn:epcglobal:cbv:bizstep:receiving",
+  // 원자재 수령
+  producing: "urn:epcglobal:cbv:bizstep:commissioning",
+  // 생산(제품 최초 생성)
+  storing: "urn:epcglobal:cbv:bizstep:storing"
+  // 완제품 저장
+};
+var BTT_PRODORDER = "urn:epcglobal:cbv:btt:prodorder";
+function sgtinUri(companyPrefix, itemRef, serial) {
+  return `urn:epc:id:sgtin:${companyPrefix}.${itemRef}.${serial}`;
+}
+
+// src/flow-engine.ts
+var BASE_EPOCH = Date.parse("2026-01-01T00:00:00Z");
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  const fn = () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  Object.defineProperty(fn, "state", { get: () => a, set: (v) => {
+    a = v >>> 0;
+  } });
+  return fn;
+}
+var FlowEngine = class {
+  tenantId;
+  nodes = /* @__PURE__ */ new Map();
+  items = /* @__PURE__ */ new Map();
+  movers = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  orders = /* @__PURE__ */ new Map();
+  revision = 0;
+  clockMs = 0;
+  rng = mulberry32(1);
+  policy;
+  /** duration 시임(선택) — 미주입 시 도메인 상수. 씬/보드 바인딩이 거리·속도 기반 estimator 주입. */
+  durationEstimator;
+  epcSeq = 0;
+  taskSeq = 0;
+  orderSeq = 0;
+  soSeq = 0;
+  handlers = [];
+  gens = [];
+  generating = false;
+  speed = 1;
+  eventSeq = 0;
+  constructor(tenantId, policy) {
+    this.tenantId = tenantId;
+    this.policy = policy;
+  }
+  // ── TwinKernel (mechanics, 도메인 무관) ───────────────────────────────────
+  loadBoard(def) {
+    for (const n of def.nodes) this.nodes.set(n.id, { id: n.id, type: n.type, capacity: n.capacity, occupancy: 0, status: "idle" });
+    for (const m of def.movers) {
+      const mover = { id: m.id, kind: m.kind, location: m.homeNode, status: "idle", taskId: null, runMs: 0, setupMs: 0, downMs: 0, goodCount: 0, scrapCount: 0 };
+      if (m.mtbfMs !== void 0) {
+        mover.mtbfMs = m.mtbfMs;
+        mover.mttrMs = m.mttrMs;
+        mover.nextFailureMs = this.sampleExp(m.mtbfMs);
+      }
+      this.movers.set(m.id, mover);
+    }
+  }
+  onEvent(handler) {
+    this.handlers.push(handler);
+    return () => {
+      const i = this.handlers.indexOf(handler);
+      if (i >= 0) this.handlers.splice(i, 1);
+    };
+  }
+  /**
+   * Command 채널 — 트윈의 "행위(act)" 면. 코어 공통 커맨드(order.hold/resume)는 여기서,
+   * 도메인 커맨드(order.release 등)는 handleCommand 로 위임. 커맨드는 sim 상태를 변이하고
+   * State 델타를 유발한다(command → 행위 → 관측 폐루프).
+   */
+  dispatch(cmd) {
+    const ok = () => ({ commandId: cmd.commandId, accepted: true });
+    const fail = (error) => ({ commandId: cmd.commandId, accepted: false, error });
+    switch (cmd.type) {
+      case CMD.orderHold:
+      case CMD.orderResume: {
+        const orderId = cmd.args?.orderId;
+        const order = orderId ? this.orders.get(orderId) : void 0;
+        if (!order) return fail(`order \uC5C6\uC74C: ${orderId}`);
+        order.held = cmd.type === CMD.orderHold;
+        this.emitOrder(order);
+        return ok();
+      }
+      default:
+        return this.handleCommand(cmd);
+    }
+  }
+  /** 도메인 커맨드 처리(order.release 등). 기본은 거절 — 도메인이 override. */
+  handleCommand(cmd) {
+    return { commandId: cmd.commandId, accepted: false, error: `\uC54C \uC218 \uC5C6\uB294 \uCEE4\uB9E8\uB4DC: ${cmd.type}` };
+  }
+  scenario = {
+    load: (def) => {
+      this.rng = mulberry32((def.seed ?? 1) >>> 0);
+      this.speed = def.speed ?? 1;
+      this.gens = def.generators.map((spec) => ({ spec, nextMs: 0 }));
+    },
+    start: () => {
+      if (this.generating) return;
+      this.generating = true;
+      for (const g of this.gens) g.nextMs = this.clockMs + this.intervalMs(g.spec);
+    },
+    pause: () => {
+      this.generating = false;
+    },
+    reset: () => {
+      this.generating = false;
+      this.gens = [];
+    },
+    setSpeed: (f) => {
+      this.speed = f;
+    }
+  };
+  tick(dtMs) {
+    const dt = dtMs * this.speed;
+    this.clockMs += dt;
+    if (this.generating) this.generate();
+    this.processFailures(dt);
+    this.processOrders();
+    this.processTasks(dt);
+  }
+  getSnapshot() {
+    return {
+      revision: this.revision,
+      simClockMs: this.clockMs,
+      nodes: [...this.nodes.values()].map((n) => ({ ...n })),
+      items: [...this.items.values()].map((i) => ({ epc: i.epc, gtin: i.gtin, qty: i.qty, location: i.location, disposition: i.disposition, expiry: i.expiry })),
+      movers: [...this.movers.values()].map((m) => {
+        const s = { id: m.id, kind: m.kind, location: m.location, status: m.status, taskId: m.taskId ?? void 0, oee: this.oeeOf(m) };
+        const t = m.taskId ? this.tasks.get(m.taskId) : void 0;
+        if (t && t.status === "in-progress" && t.intent !== "process") s.motion = { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs - (t.durationMs - t.remainingMs), durationMs: t.durationMs, progress: this.progressOf(t), elapsedMs: t.durationMs - t.remainingMs };
+        return s;
+      }),
+      tasks: [...this.tasks.values()].map((t) => ({ id: t.id, kind: t.kind, status: t.status, itemRefs: [t.itemEpc], fromNode: t.fromNode, toNode: t.toNode, resourceRef: t.resource ?? void 0, progress: t.status === "in-progress" ? this.progressOf(t) : void 0 })),
+      orders: [...this.orders.values()].map((o) => ({ id: o.id, kind: o.kind, status: o.status, progress: o.requested ? o.fulfilled / o.requested : 0, held: o.held }))
+    };
+  }
+  /**
+   * fork — 현재 상태를 정확히 복제한 새 엔진 (디지털트윈 본연: "현재로부터 예측").
+   * 원본(live/sim)은 계속 진행, fork 는 what-if 를 앞으로 굴려 forecast·발산(predicted vs actual) 검사에 쓴다.
+   * fork 는 자기 구독자·시나리오를 갖고 원본과 격리(handlers·gens 비움, generating=false).
+   * rng 는 fork 의 시나리오 load 시 재시드(드레인 예측은 생성 없어 rng 무관·결정적).
+   */
+  fork(tenantId = this.tenantId) {
+    const Ctor = this.constructor;
+    const clone = new Ctor(tenantId, this.policy);
+    const skip = /* @__PURE__ */ new Set(["policy", "scenario", "tenantId", "handlers", "durationEstimator"]);
+    for (const key of Object.keys(this)) {
+      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);
+    }
+    clone.rng.state = this.rng.state;
+    clone.durationEstimator = this.durationEstimator;
+    return clone;
+  }
+  // ── 보호 헬퍼 (도메인 hook 에서 사용) ──────────────────────────────────────
+  now() {
+    return new Date(BASE_EPOCH + this.clockMs).toISOString();
+  }
+  randInt(min, max) {
+    return max <= min ? min : min + Math.floor(this.rng() * (max - min + 1));
+  }
+  /** task 소요 산출 — estimator 주입 시 그 값, 미주입/undefined 시 도메인 상수(fallback). "얼마"만 소비, "경로"는 씬. */
+  durationOf(ctx, fallbackMs) {
+    return this.durationEstimator?.estimate(ctx) ?? fallbackMs;
+  }
+  /** skuMix 에서 weight 로 gtin 선택(rng) — 도착/오더 자극의 품목 결정. */
+  pickGtin(mix) {
+    const total = mix.reduce((s, m) => s + m.weight, 0);
+    let r = this.rng() * total;
+    for (const m of mix) {
+      r -= m.weight;
+      if (r <= 0) return m.gtin;
+    }
+    return mix[mix.length - 1].gtin;
+  }
+  nodeByType(type) {
+    for (const n of this.nodes.values()) if (n.type === type) return n;
+    return void 0;
+  }
+  /**
+   * process 변화 대수(EPCIS TransformationEvent · ISA-95 Material Consumed/Produced · 씬 Processable.transform).
+   * inputs 소비 → outputs 생산. 입출력 arity 가 곧 대수:
+   *   merge N→1(조립) · split 1→N(분해) · transform 1→1(타입변경) · loss N→0(소실) · gain 0→N(부산물·생성).
+   * 아이템 상태(소비/생산)와 노드 점유를 갱신하고 계보(TransformationEvent)를 방출한다.
+   * 도메인은 이 원시만 호출 — onTaskComplete 의 소비/생산/EPCIS 손코딩을 대체.
+   */
+  transform(inputs, outputs, opts) {
+    for (const epc of inputs) {
+      const it = this.items.get(epc);
+      if (!it) continue;
+      const n = this.nodes.get(it.location);
+      if (n) n.occupancy--;
+      this.items.delete(epc);
+    }
+    for (const o of outputs) {
+      this.items.set(o.epc, { epc: o.epc, gtin: o.gtin, qty: o.qty, location: o.location, disposition: o.disposition });
+      const n = this.nodes.get(o.location);
+      if (n) n.occupancy++;
+    }
+    this.emit(transformationEvent({
+      eventTime: this.now(),
+      bizStep: opts.bizStep,
+      disposition: opts.disposition,
+      inputEPCList: inputs.length ? inputs.slice() : void 0,
+      outputEPCList: outputs.length ? outputs.map((o) => o.epc) : void 0,
+      transformationID: opts.transformationId,
+      readPoint: opts.readPoint,
+      bizLocation: opts.bizLocation ?? opts.readPoint,
+      bizTransactionList: opts.bizTransactionList
+    }));
+  }
+  /**
+   * containment 조립(EPCIS AggregationEvent ADD) — 자식들을 부모(용기)로 집約.
+   * consume 지정 시 자식이 컨테이너로 흡수되며 독립 아이템에서 이탈(dematerialize: ObjectEvent DELETE + 제거).
+   * 미지정 시 이벤트만(자식은 독립 아이템 유지 — 예: WMS 패킹, 적재된 채 도착).
+   */
+  aggregate(parent, children, opts) {
+    this.emit(aggregationEvent({ eventTime: this.now(), action: "ADD", bizStep: opts.bizStep, disposition: opts.disposition, parentID: parent, childEPCs: children.slice(), readPoint: opts.readPoint, bizLocation: opts.bizLocation }));
+    if (opts.consume) {
+      this.emit(objectEvent({ eventTime: this.now(), action: "DELETE", bizStep: opts.bizStep, disposition: opts.consume.disposition, epcList: children.slice(), readPoint: opts.consume.readPoint }));
+      for (const c of children) {
+        const it = this.items.get(c);
+        if (it) {
+          const n = this.nodes.get(it.location);
+          if (n) n.occupancy--;
+          this.items.delete(c);
+        }
+      }
+    }
+  }
+  /**
+   * containment 분해(EPCIS AggregationEvent DELETE) — 부모(용기)에서 자식들을 풀어냄.
+   * materialize 지정 시 자식이 독립 아이템으로 등장(materialize: 노드 배치 + occupancy + ObjectEvent ADD).
+   * 미지정 시 이벤트만.
+   */
+  disaggregate(parent, children, opts) {
+    this.emit(aggregationEvent({ eventTime: this.now(), action: "DELETE", bizStep: opts.bizStep, parentID: parent, childEPCs: children.slice(), readPoint: opts.readPoint }));
+    if (opts.materialize) {
+      const m = opts.materialize;
+      for (const c of children) {
+        this.items.set(c, { epc: c, location: m.location, disposition: m.disposition });
+        const n = this.nodes.get(m.location);
+        if (n) n.occupancy++;
+        this.emit(objectEvent({ eventTime: this.now(), action: "ADD", bizStep: opts.bizStep, disposition: m.disposition, epcList: [c], readPoint: m.location, bizLocation: m.location }));
+      }
+    }
+  }
+  /** 품질 보고(OEE Quality) — 도메인이 완료 시 자원별 양품/불량 1건 계상(예: 용접 수율). */
+  recordOutput(moverId, good) {
+    const m = moverId ? this.movers.get(moverId) : void 0;
+    if (!m) return;
+    if (good) m.goodCount++;
+    else m.scrapCount++;
+  }
+  /** 무버 OEE(스냅샷 파생) — Availability×Performance×Quality. planned = 설비 존재 sim 시간(clockMs). */
+  oeeOf(m) {
+    const planned = this.clockMs;
+    const uptime = Math.max(0, planned - m.setupMs - m.downMs);
+    const availability = planned > 0 ? uptime / planned : 1;
+    const performance = uptime > 0 ? Math.min(1, m.runMs / uptime) : m.runMs > 0 ? 1 : 0;
+    const totalQ = m.goodCount + m.scrapCount;
+    const quality = totalQ > 0 ? m.goodCount / totalQ : 1;
+    return {
+      availability,
+      performance,
+      quality,
+      overall: availability * performance * quality,
+      runMs: m.runMs,
+      setupMs: m.setupMs,
+      downMs: m.downMs,
+      idleMs: Math.max(0, uptime - m.runMs),
+      goodCount: m.goodCount,
+      scrapCount: m.scrapCount
+    };
+  }
+  /** 정책에 넘길 특정 타입 노드의 관측 뷰 — 예약(그 노드로 향하는 in-flight task) 포함. */
+  slotViews(nodeType) {
+    const reserved = /* @__PURE__ */ new Map();
+    for (const t of this.tasks.values()) if (t.status !== "completed") reserved.set(t.toNode, (reserved.get(t.toNode) ?? 0) + 1);
+    const views = [];
+    for (const n of this.nodes.values()) if (n.type === nodeType) views.push({ id: n.id, capacity: n.capacity, occupancy: n.occupancy, reserved: reserved.get(n.id) ?? 0 });
+    return views;
+  }
+  emit(event) {
+    this.revision++;
+    const e = { eventId: `${this.tenantId}-evt-${++this.eventSeq}`, eventType: `epcis.${event.type}`, eventTime: event.eventTime, tenantId: this.tenantId, 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 };
+    for (const h of this.handlers) h(e);
+  }
+  emitTask(t) {
+    this.emitOp(OP_EVENT.task, { taskId: t.id, kind: t.kind, status: t.status, fromNode: t.fromNode, toNode: t.toNode, itemRefs: [t.itemEpc], resourceRef: t.resource ?? void 0 });
+  }
+  emitMover(m, motion) {
+    this.emitOp(OP_EVENT.equipment, { moverId: m.id, kind: m.kind, status: m.status, location: m.location, motion });
+  }
+  emitOrder(o) {
+    this.emitOp(OP_EVENT.order, { orderId: o.id, kind: o.kind, status: o.status, requested: o.requested, fulfilled: o.fulfilled, held: o.held });
+  }
+  // ── 내부 mechanics ─────────────────────────────────────────────────────────
+  intervalMs(spec) {
+    const base = 36e5 / spec.rate.meanPerHour;
+    return spec.rate.distribution === "poisson" ? -Math.log(1 - this.rng()) * base : base;
+  }
+  /** 지수분포 표본(고장/수리 간격) — mean 을 평균으로 하는 무기억 프로세스. */
+  sampleExp(meanMs) {
+    return -Math.log(1 - this.rng()) * meanMs;
+  }
+  /**
+   * 확률적 설비 고장(MTBF/MTTR) — mtbf 지정 무버만 참여(미지정=고장 없음, rng 무소비 → byte-identical).
+   * up: nextFailure 도래 시 down(수리까지 repairUntil). down: downMs 누적, repair 도래 시 up(다음 고장 예약).
+   * down 중 무버는 배정 불가 + 진행중 task 동결(processTasks 가 skip) → OEE Availability 손실.
+   */
+  processFailures(dt) {
+    for (const m of this.movers.values()) {
+      if (m.mtbfMs === void 0) continue;
+      if (m.status === "down") {
+        m.downMs += dt;
+        if (this.clockMs >= (m.repairUntilMs ?? 0)) {
+          m.status = m.taskId ? "busy" : "idle";
+          m.repairUntilMs = void 0;
+          m.nextFailureMs = this.clockMs + this.sampleExp(m.mtbfMs);
+          this.emitMover(m);
+        }
+      } else if (this.clockMs >= (m.nextFailureMs ?? Infinity)) {
+        m.status = "down";
+        m.repairUntilMs = this.clockMs + this.sampleExp(m.mttrMs ?? m.mtbfMs);
+        m.nextFailureMs = void 0;
+        this.emitMover(m);
+      }
+    }
+  }
+  progressOf(t) {
+    return t.durationMs <= 0 ? 1 : Math.min(1, Math.max(0, (t.durationMs - t.remainingMs) / t.durationMs));
+  }
+  generate() {
+    for (const g of this.gens) {
+      while (this.clockMs >= g.nextMs) {
+        if (g.spec.kind === "inbound-arrival") this.onArrival(g.spec);
+        else if (g.spec.kind === "outbound-order") this.onOrder(g.spec);
+        g.nextMs += this.intervalMs(g.spec);
+      }
+    }
+  }
+  processOrders() {
+    for (const o of this.orders.values()) if (o.status === "created" && !o.held) this.allocate(o);
+  }
+  processTasks(dt) {
+    for (const t of this.tasks.values()) {
+      if (t.status !== "created") continue;
+      if (t.intent === "dwell") {
+        t.status = "in-progress";
+        t.remainingMs = t.durationMs;
+        this.emitTask(t);
+        continue;
+      }
+      const mover = [...this.movers.values()].find((m) => m.status === "idle" && (t.resourceType === void 0 || m.kind === t.resourceType));
+      if (!mover) continue;
+      if (t.setupMs && t.changeoverKey !== void 0 && mover.lastChangeoverKey !== void 0 && mover.lastChangeoverKey !== t.changeoverKey) {
+        t.appliedSetupMs = t.setupMs;
+        t.durationMs += t.setupMs;
+      }
+      if (t.changeoverKey !== void 0) mover.lastChangeoverKey = t.changeoverKey;
+      mover.status = "busy";
+      mover.taskId = t.id;
+      t.status = "in-progress";
+      t.resource = mover.id;
+      t.remainingMs = t.durationMs;
+      this.emitTask(t);
+      if (t.intent === "process") this.emitMover(mover);
+      else this.emitMover(mover, { fromNode: t.fromNode, toNode: t.toNode, startedAtSimMs: this.clockMs, durationMs: t.durationMs, progress: 0, elapsedMs: 0 });
+    }
+    for (const t of this.tasks.values()) {
+      if (t.status !== "in-progress") continue;
+      if (t.resource && this.movers.get(t.resource)?.status === "down") continue;
+      t.remainingMs -= dt;
+      if (t.remainingMs > 0) continue;
+      this.onTaskComplete(t);
+      t.status = "completed";
+      if (!t.resource) {
+        this.emitTask(t);
+        continue;
+      }
+      const mover = this.movers.get(t.resource);
+      const setup = t.appliedSetupMs ?? 0;
+      mover.setupMs += setup;
+      mover.runMs += t.durationMs - setup;
+      mover.status = "idle";
+      mover.taskId = null;
+      if (t.intent !== "process") mover.location = t.toNode;
+      this.emitTask(t);
+      this.emitMover(mover);
+    }
+  }
+};
+
+// src/kernel.ts
+var TRAVEL_MS = 3e4;
+var COMPANY_PREFIX = "0614141";
+var SHELF_MS = 30 * 24 * 36e5;
+var SHELF_JITTER_MS = 5 * 24 * 36e5;
+var WmsKernel = class extends FlowEngine {
+  poSeq = 0;
+  constructor(tenantId, policy = firstFitPolicy) {
+    super(tenantId, policy);
+  }
+  /** 입고 도착 — §4 라이프사이클: ASN(PO) → 팔레트 조립 → 수령 → putaway task. */
+  onArrival(spec) {
+    const dock = this.nodeByType("dock");
+    if (!dock) return;
+    const epc = ssccUri(COMPANY_PREFIX, ++this.epcSeq);
+    const gtin = this.pickGtin(spec.content.skuMix);
+    const qty = this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max);
+    const po = gdtiUri(COMPANY_PREFIX, "401", ++this.poSeq);
+    const eventTime = this.now();
+    const qtyList = [{ epcClass: gtin, quantity: qty }];
+    const poTxn = [{ type: BTT.po, bizTransaction: po }];
+    const expiry = this.clockMs + SHELF_MS - this.epcSeq % 5 * SHELF_JITTER_MS;
+    this.items.set(epc, { epc, gtin, qty, location: dock.id, disposition: DISP.in_progress, expiry });
+    dock.occupancy++;
+    this.emit(transactionEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, bizTransactionList: poTxn, epcList: [epc], quantityList: qtyList, readPoint: dock.id }));
+    this.emit(aggregationEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, parentID: epc, childQuantityList: qtyList, readPoint: dock.id }));
+    this.emit(objectEvent({ eventTime, action: "ADD", bizStep: BIZSTEP.receiving, disposition: DISP.in_progress, epcList: [epc], quantityList: qtyList, readPoint: dock.id, bizLocation: dock.id, bizTransactionList: poTxn }));
+    const binId = this.policy.selectPlacement({ item: { epc, gtin, qty }, slots: this.slotViews("storage") });
+    if (!binId) return;
+    const id = `task-${++this.taskSeq}`;
+    const task = { id, kind: "putaway", status: "created", itemEpc: epc, fromNode: dock.id, toNode: binId, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "putaway", fromNode: dock.id, toNode: binId }, TRAVEL_MS) };
+    this.tasks.set(id, task);
+    this.emitTask(task);
+  }
+  /**
+   * SO 오더 자극(생성기) → 오더 생성. `linesPerOrder` 지정 시 멀티SKU(라인별 distinct gtin),
+   * 미지정 시 단일 SKU(기존 경로 — rng 소비 순서 보존 = pickGtin → randInt).
+   */
+  onOrder(spec) {
+    const lpl = spec.content.linesPerOrder;
+    if (!lpl) {
+      this.createSalesOrder([{ gtin: this.pickGtin(spec.content.skuMix), qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) }]);
+      return;
+    }
+    const n = Math.min(this.randInt(lpl.min, lpl.max), spec.content.skuMix.length);
+    const lines = [];
+    let pool = spec.content.skuMix;
+    for (let i = 0; i < n && pool.length > 0; i++) {
+      const gtin = this.pickGtin(pool);
+      lines.push({ gtin, qty: this.randInt(spec.content.qtyPerLine.min, spec.content.qtyPerLine.max) });
+      pool = pool.filter((m) => m.gtin !== gtin);
+    }
+    this.createSalesOrder(lines);
+  }
+  /** Command 채널 — 오더 즉시 투입(트랜잭션 프론트엔드/prescriptive). */
+  handleCommand(cmd) {
+    if (cmd.type === CMD.orderRelease) {
+      const a = cmd.args;
+      const lines = a?.lines ?? (a?.gtin ? [{ gtin: a.gtin, qty: a.qty ?? 1 }] : []);
+      if (lines.length === 0) return { commandId: cmd.commandId, accepted: false, error: "order.release: gtin \uB610\uB294 lines \uD544\uC694" };
+      this.createSalesOrder(lines);
+      return { commandId: cmd.commandId, accepted: true };
+    }
+    return super.handleCommand(cmd);
+  }
+  createSalesOrder(lines) {
+    const id = `order-${++this.orderSeq}`;
+    const so = gdtiUri(COMPANY_PREFIX, "402", ++this.soSeq);
+    const requested = lines.reduce((s, l) => s + l.qty, 0);
+    const order = {
+      id,
+      kind: "outbound",
+      status: "created",
+      requested,
+      fulfilled: 0,
+      bizTransaction: so,
+      allocated: [],
+      picked: [],
+      shipmentEpc: null,
+      lines: lines.map((l) => ({ gtin: l.gtin, requested: l.qty }))
+    };
+    this.orders.set(id, order);
+    this.emitOrder(order);
+  }
+  /**
+   * created 오더를 정책으로 할당 → SO TransactionEvent(라인 통합) + pick task(라인별).
+   * 라인마다 selectStock(정책) → firstFit=라인 전량확보 대기 / partialFit=가용분 백오더.
+   * 멀티SKU 는 여러 라인의 팔레트를 한 오더로 모아 단일 출하(finalizeOrder 통합 화물).
+   */
+  allocate(o) {
+    const staging = this.nodeByType("staging");
+    if (!staging || !o.lines) return;
+    const chosenAll = [];
+    for (const line of o.lines) {
+      const already = o.allocated.filter((e) => this.items.get(e)?.gtin === line.gtin).length;
+      const need = line.requested - already;
+      if (need <= 0) continue;
+      const available = [...this.items.values()].filter((i) => i.gtin === line.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "storage").map((i) => ({ epc: i.epc, location: i.location, qty: i.qty ?? 1, expiry: i.expiry }));
+      const chosen = this.policy.selectStock({ gtin: line.gtin, qty: need, available });
+      for (const epc of chosen) {
+        this.items.get(epc).disposition = DISP.reserved;
+        o.allocated.push(epc);
+        chosenAll.push(epc);
+      }
+    }
+    if (chosenAll.length === 0) return;
+    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: BIZSTEP.picking, bizTransactionList: [{ type: BTT.so, bizTransaction: o.bizTransaction }], epcList: chosenAll.slice() }));
+    for (const epc of chosenAll) {
+      const it = this.items.get(epc);
+      const id = `task-${++this.taskSeq}`;
+      const task = { id, kind: "pick", status: "created", itemEpc: epc, fromNode: it.location, toNode: staging.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "pick", fromNode: it.location, toNode: staging.id }, TRAVEL_MS), orderId: o.id };
+      this.tasks.set(id, task);
+      this.emitTask(task);
+    }
+    o.status = "picking";
+    this.emitOrder(o);
+  }
+  /** 태스크 완료 — 이동 반영 후 putaway=storing, pick=picking(+전량 시 pack→stage→ship). */
+  onTaskComplete(t) {
+    const item = this.items.get(t.itemEpc);
+    const from = this.nodes.get(t.fromNode);
+    const to = this.nodes.get(t.toNode);
+    from.occupancy--;
+    to.occupancy++;
+    item.location = to.id;
+    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 }));
+      return;
+    }
+    item.disposition = DISP.reserved;
+    this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: BIZSTEP.picking, disposition: DISP.reserved, epcList: [item.epc], quantityList: [{ epcClass: item.gtin, quantity: item.qty }], readPoint: to.id, bizLocation: to.id }));
+    const order = t.orderId ? this.orders.get(t.orderId) : void 0;
+    if (!order) return;
+    order.picked.push(item.epc);
+    if (order.picked.length === order.allocated.length) this.finalizeOrder(order, to);
+  }
+  /** 전량 피킹 → packing(조립)·staging·shipping 마감. 화물 사이트 이탈, 백오더 잔량 재할당. */
+  finalizeOrder(order, staging) {
+    const shipDock = this.nodeByType("dock-ship") ?? staging;
+    const eventTime = this.now();
+    const shipment = ssccUri(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 });
+    order.status = "packed";
+    this.emit(objectEvent({ eventTime, action: "OBSERVE", bizStep: BIZSTEP.staging_outbound, disposition: DISP.reserved, epcList: [shipment], readPoint: staging.id, bizLocation: staging.id, bizTransactionList: soTxn }));
+    this.emit(objectEvent({ eventTime, action: "DELETE", bizStep: BIZSTEP.shipping, disposition: DISP.in_transit, epcList: [shipment], readPoint: shipDock.id, bizTransactionList: soTxn }));
+    order.fulfilled += order.allocated.length;
+    if (order.lines) for (const epc of order.picked) {
+      const g = this.items.get(epc)?.gtin;
+      const line = order.lines.find((l) => l.gtin === g && l.requested > 0);
+      if (line) line.requested--;
+    }
+    for (const epc of order.picked) {
+      this.items.delete(epc);
+      staging.occupancy--;
+    }
+    if (order.fulfilled >= order.requested) order.status = "shipped";
+    else {
+      order.allocated = [];
+      order.picked = [];
+      order.status = "created";
+    }
+    this.emitOrder(order);
+  }
+};
+
+// src/yms-kernel.ts
+var TRAVEL_MS2 = 2e4;
+var DWELL_MS = 3e4;
+var WINDOW_DELAY_MS = 4e4;
+var CARGO_PER_TRAILER = 2;
+var CP = "0614141";
+var YmsKernel = class extends FlowEngine {
+  doorRR = 0;
+  cargoSeq = 0;
+  trailerCargo = /* @__PURE__ */ new Map();
+  // 트레일러 epc → 화물 SSCC(하차 전 opaque / 상차 예약분)
+  apptMode = /* @__PURE__ */ new Map();
+  // orderId → 상하차 모드(생성 시 캡처)
+  /** 야드 운영 정책(상하차 방식). 기본 drop(야드 버퍼). live 는 게이트/도크 직행. */
+  mode;
+  constructor(tenantId, policy = firstFitPolicy, mode = "drop") {
+    super(tenantId, policy);
+    this.mode = mode;
+  }
+  /** 인바운드(하차) 자극 — 화물 적재된 트레일러 도착. */
+  onArrival(_spec) {
+    this.spawnAppointment("appointment");
+  }
+  /** 아웃바운드(상차) 자극 — 빈 트레일러 도착(도크에서 staging 화물 적재 예정). */
+  onOrder(_spec) {
+    this.spawnAppointment("appointment-out");
+  }
+  /** 게이트-인 — 트레일러 도착 → 어포인트먼트(도크도어 배정 + 창). drop 은 야드 주차 태스크, live 는 게이트 대기. */
+  spawnAppointment(kind) {
+    const gate = this.nodeByType("gate");
+    const doors = [...this.nodes.values()].filter((n) => n.type === "dock-door").sort((a, b) => a.id.localeCompare(b.id));
+    if (!gate || doors.length === 0) return;
+    const inbound = kind === "appointment";
+    const epc = graiUri(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));
+      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 order = { id, kind, status: "created", requested: 1, fulfilled: 0, bizTransaction: appt, allocated: [epc], picked: [], dockDoor: door.id, windowStartMs: this.clockMs + WINDOW_DELAY_MS };
+    this.orders.set(id, order);
+    this.apptMode.set(id, this.mode);
+    this.emitOrder(order);
+    if (this.mode === "drop") {
+      const slotId = this.policy.selectPlacement({ item: { epc, gtin: "trailer", qty: 1 }, slots: this.slotViews("yard-slot") });
+      if (!slotId) return;
+      const task = { id: `task-${++this.taskSeq}`, kind: "spot", status: "created", itemEpc: epc, fromNode: gate.id, toNode: slotId, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "spot", fromNode: gate.id, toNode: slotId }, TRAVEL_MS2) };
+      this.tasks.set(task.id, task);
+      this.emitTask(task);
+    }
+  }
+  /**
+   * 스케줄 게이트(base 가 created 오더마다 매 tick 호출) — 조건 충족 시 도크로 이동:
+   *   ① 창 도래(clock ≥ windowStart)  ② 배정 도크도어 예약 가능
+   *   ③ drop: 트레일러가 야드 주차됨 / live: 게이트 대기 중  ④ 아웃바운드: staging 적재 화물 충분
+   * 하나라도 안 되면 대기(다음 tick 재시도). = 시간창 예약 스케줄링.
+   */
+  allocate(o) {
+    const trailer = this.items.get(o.allocated[0]);
+    if (!trailer) return;
+    if (this.clockMs < (o.windowStartMs ?? 0)) return;
+    const door = this.nodes.get(o.dockDoor);
+    const inflight = [...this.tasks.values()].some((t) => t.status !== "completed" && t.toNode === door.id);
+    if (door.occupancy > 0 || inflight) return;
+    const mode = this.apptMode.get(o.id) ?? "drop";
+    if (mode === "drop" && this.nodes.get(trailer.location)?.type !== "yard-slot") return;
+    const outbound = o.kind === "appointment-out";
+    const bizStep = outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading;
+    if (outbound) {
+      const staging = this.nodeByType("staging");
+      const reserved = new Set([...this.trailerCargo.values()].flat());
+      const avail = [...this.items.values()].filter((i) => i.location === staging?.id && i.disposition === DISP.sellable && !reserved.has(i.epc)).sort((a, b) => a.epc.localeCompare(b.epc));
+      if (!staging || avail.length < CARGO_PER_TRAILER) return;
+      this.trailerCargo.set(trailer.epc, avail.slice(0, CARGO_PER_TRAILER).map((i) => i.epc));
+    }
+    trailer.disposition = DISP.reserved;
+    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep, bizTransactionList: [{ type: BTT_DELIVERY, bizTransaction: o.bizTransaction }], epcList: [trailer.epc], readPoint: door.id }));
+    const dockKind = mode === "drop" ? "pull" : "spot-live";
+    const task = { id: `task-${++this.taskSeq}`, kind: dockKind, status: "created", itemEpc: trailer.epc, fromNode: trailer.location, toNode: door.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: dockKind, fromNode: trailer.location, toNode: door.id }, TRAVEL_MS2), orderId: o.id };
+    this.tasks.set(task.id, task);
+    this.emitTask(task);
+    o.status = "docking";
+    this.emitOrder(o);
+  }
+  /** 태스크 완료 — 목적지 타입으로 분기: yard-slot=주차, dock-door=상/하차+depart, gate=출차. */
+  onTaskComplete(t) {
+    const trailer = this.items.get(t.itemEpc);
+    const from = this.nodes.get(t.fromNode);
+    const to = this.nodes.get(t.toNode);
+    from.occupancy--;
+    to.occupancy++;
+    trailer.location = to.id;
+    if (t.kind === "dwell") {
+      const gate = this.nodeByType("gate");
+      const dep = { id: `task-${++this.taskSeq}`, kind: "depart", status: "created", itemEpc: trailer.epc, fromNode: t.toNode, toNode: gate.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "depart", fromNode: t.toNode, toNode: gate.id }, TRAVEL_MS2), orderId: t.orderId };
+      this.tasks.set(dep.id, dep);
+      this.emitTask(dep);
+      return;
+    }
+    if (to.type === "yard-slot") {
+      trailer.disposition = DISP.sellable;
+      this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: YARD_BIZSTEP.staging, disposition: DISP.sellable, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+      return;
+    }
+    if (to.type === "dock-door") {
+      const order2 = t.orderId ? this.orders.get(t.orderId) : void 0;
+      const outbound = order2?.kind === "appointment-out";
+      const staging = this.nodeByType("staging");
+      const cargo = this.trailerCargo.get(trailer.epc) ?? [];
+      this.emit(objectEvent({ eventTime: this.now(), action: "OBSERVE", bizStep: outbound ? YARD_BIZSTEP.loading : YARD_BIZSTEP.unloading, disposition: DISP.in_progress, epcList: [trailer.epc], readPoint: to.id, bizLocation: to.id }));
+      if (outbound) {
+        if (cargo.length && staging) {
+          this.aggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.loading, readPoint: to.id, consume: { readPoint: staging.id, disposition: DISP.in_transit } });
+        }
+        this.trailerCargo.delete(trailer.epc);
+        trailer.disposition = DISP.sellable;
+      } else if (cargo.length && staging) {
+        this.disaggregate(trailer.epc, cargo, { bizStep: YARD_BIZSTEP.unloading, readPoint: to.id, materialize: { location: staging.id, disposition: DISP.sellable } });
+        this.trailerCargo.delete(trailer.epc);
+      }
+      const dwell = { id: `task-${++this.taskSeq}`, kind: "dwell", status: "created", itemEpc: trailer.epc, fromNode: to.id, toNode: to.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "dwell", fromNode: to.id, toNode: to.id }, DWELL_MS), orderId: t.orderId, intent: "dwell" };
+      this.tasks.set(dwell.id, dwell);
+      this.emitTask(dwell);
+      if (order2) {
+        order2.status = "dwelling";
+        this.emitOrder(order2);
+      }
+      return;
+    }
+    this.emit(objectEvent({ eventTime: this.now(), action: "DELETE", bizStep: YARD_BIZSTEP.departing, disposition: DISP.in_transit, epcList: [trailer.epc], readPoint: to.id }));
+    this.items.delete(trailer.epc);
+    to.occupancy--;
+    const order = t.orderId ? this.orders.get(t.orderId) : void 0;
+    if (order) {
+      order.fulfilled = 1;
+      order.status = "departed";
+      this.emitOrder(order);
+    }
+  }
+};
+
+// src/mes-kernel.ts
+var CYCLE_MS = 4e4;
+var SETUP_MS = 15e3;
+var CP2 = "0614141";
+var WIP_ITEMREF = "066666";
+var WIP_GTIN = sgtinClass(CP2, WIP_ITEMREF);
+var 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 MesKernel = class extends FlowEngine {
+  wipSeq = 0;
+  prodSeq = 0;
+  constructor(tenantId, policy = firstFitPolicy) {
+    super(tenantId, policy);
+  }
+  productOf(gtin) {
+    return PRODUCTS.find((p) => p.gtin === gtin);
+  }
+  /** 부품 수령(다품종) — skuMix 의 gtin 으로 부품 종류 결정. */
+  onArrival(spec) {
+    const rawStore = this.nodeByType("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 을 오더에 기록. */
+  onOrder(_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.orders.set(id, order);
+    this.emitOrder(order);
+  }
+  /** 할당 — 제품 BOM 각 라인의 부품 예약(하나라도 부족하면 대기) + op1(cut, 체인지오버 셋업). */
+  allocate(o) {
+    const cut = this.nodeByType("cut-station");
+    const product = this.productOf(o.gtin);
+    if (!cut || !product) return;
+    const picks = [];
+    for (const line of product.bom) {
+      const available = [...this.items.values()].filter((i) => i.gtin === line.part.gtin && i.disposition === DISP.sellable && this.nodes.get(i.location)?.type === "raw-store").map((i) => ({ epc: i.epc, location: i.location, qty: 1 }));
+      const 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) {
+      this.items.get(epc).disposition = DISP.reserved;
+      o.allocated.push(epc);
+    }
+    this.emit(transactionEvent({ eventTime: this.now(), action: "ADD", bizStep: MES_BIZSTEP.producing, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: o.bizTransaction }], epcList: o.allocated.slice() }));
+    const task = { id: `task-${++this.taskSeq}`, kind: "cut", status: "created", itemEpc: o.allocated[0], fromNode: cut.id, toNode: cut.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "cut", fromNode: cut.id, toNode: cut.id, resourceKind: "cutter" }, CYCLE_MS), orderId: o.id, resourceType: "cutter", changeoverKey: product.gtin, setupMs: SETUP_MS, intent: "process" };
+    this.tasks.set(task.id, task);
+    this.emitTask(task);
+    o.status = "op-cut";
+    this.emitOrder(o);
+  }
+  /** op 완료 = 변환. cut: BOM 부품 소비 → WIP. weld: WIP → 완제품(수율: 양품/불량 → OEE 품질 보고). */
+  onTaskComplete(t) {
+    const order = this.orders.get(t.orderId);
+    const product = this.productOf(order.gtin);
+    const eventTime = this.now();
+    if (t.kind === "cut") {
+      const cut = this.nodes.get(t.toNode);
+      const weld2 = this.nodeByType("weld-station");
+      const inputs = order.allocated.slice();
+      const wip2 = sgtinUri(CP2, WIP_ITEMREF, ++this.wipSeq);
+      this.transform(inputs, [{ epc: wip2, gtin: WIP_GTIN, qty: 1, location: cut.id, disposition: DISP.in_progress }], { bizStep: MES_BIZSTEP.producing, disposition: DISP.in_progress, transformationId: order.bizTransaction, readPoint: cut.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+      order.allocated = [wip2];
+      const wtask = { id: `task-${++this.taskSeq}`, kind: "weld", status: "created", itemEpc: wip2, fromNode: weld2.id, toNode: weld2.id, resource: null, remainingMs: 0, durationMs: this.durationOf({ kind: "weld", fromNode: weld2.id, toNode: weld2.id, resourceKind: "welder" }, CYCLE_MS), orderId: order.id, resourceType: "welder", changeoverKey: product.gtin, setupMs: SETUP_MS, intent: "process" };
+      this.tasks.set(wtask.id, wtask);
+      this.emitTask(wtask);
+      order.status = "op-weld";
+      this.emitOrder(order);
+      return;
+    }
+    const weld = this.nodes.get(t.toNode);
+    const fgStore = this.nodeByType("fg-store");
+    const wip = order.allocated[0];
+    const good = this.rng() < YIELD;
+    this.recordOutput(t.resource, good);
+    const disp = good ? DISP.sellable : DISP.non_sellable;
+    const outputEpc = sgtinUri(CP2, product.ref, ++this.prodSeq);
+    this.transform([wip], [{ epc: outputEpc, gtin: product.gtin, qty: 1, location: fgStore.id, disposition: disp }], { bizStep: MES_BIZSTEP.producing, disposition: disp, transformationId: order.bizTransaction, readPoint: weld.id, bizTransactionList: [{ type: BTT_PRODORDER, bizTransaction: order.bizTransaction }] });
+    this.emit(objectEvent({ eventTime, 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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BIZSTEP,
+  BTT,
+  BTT_DELIVERY,
+  BTT_PRODORDER,
+  CMD,
+  DISP,
+  EPCIS_CONTEXT,
+  EventJournal,
+  FlowEngine,
+  MES_BIZSTEP,
+  MES_PART_GTINS,
+  MES_PRODUCT_GTINS,
+  MesKernel,
+  OP_EVENT,
+  StateProjector,
+  TwinHistory,
+  TwinObserver,
+  TwinRuntime,
+  UTC_OFFSET,
+  WmsKernel,
+  YARD_BIZSTEP,
+  YmsKernel,
+  aggregationEvent,
+  compareStates,
+  constantDuration,
+  counterfactualAt,
+  fefoPolicy,
+  firstFitPolicy,
+  gdtiUri,
+  graiUri,
+  ingest,
+  mapRecord,
+  monteCarloForecast,
+  objectEvent,
+  partialFitPolicy,
+  replay,
+  sgtinClass,
+  sgtinUri,
+  ssccUri,
+  transactionEvent,
+  transformationEvent,
+  validateEpcisEvent
+});