@things-factory/headless-twin 10.0.11 → 10.0.12

package/test/twin-model-tree-db.test.ts

@@ -76,7 +76,7 @@ before(async () => {
   domainId = d.id
   q = new TwinModelTreeQuery()
   ctx = { state: { domain: { id: domainId } } }
-  await TwinEngine.ingestMaster(domainId, master())
+  await TwinEngine.ingestMaster(domainId, master(), 'reset')
 })
 
 after(async () => {
@@ -108,13 +108,13 @@ test('수량을 곱해 내려간다 — 그리고 모르면 곱하지 않는다'
       { key: 'frame-line', label: 'f', inputs: [{ material: 'steel', qty: 4 }], outputs: [{ material: 'frame', qty: 1 }] }
     ]
   })
-  await TwinEngine.ingestMaster(domainId, noQty)
+  await TwinEngine.ingestMaster(domainId, noQty, 'reset')
   const t2 = await explode('trailer')
   assert.equal(t2.items.find((n: any) => n.id === 'frame').qty, null, '모르는 수량을 1 로 메우지 않는다')
   assert.equal(t2.items.find((n: any) => n.id === 'steel').qty, null, '모르는 값 아래는 전부 모르는 값이다')
   assert.equal(t2.qtyIncomplete, true, '합계가 성립하지 않는다는 사실을 낸다')
 
-  await TwinEngine.ingestMaster(domainId, master())
+  await TwinEngine.ingestMaster(domainId, master(), 'reset')
 })
 
 test('역전개도 같은 선언으로 — 방향만 뒤집는다', async () => {
@@ -146,11 +146,11 @@ test('사이클은 다시 탐색하지 않고 알린다', async () => {
       { key: 'frame-line', label: 'f', inputs: [{ material: 'trailer', qty: 1 }], outputs: [{ material: 'frame', qty: 1 }] }
     ]
   })
-  await TwinEngine.ingestMaster(domainId, loop)
+  await TwinEngine.ingestMaster(domainId, loop, 'reset')
   const t = await explode('trailer')
   assert.ok(t.items.length < 10, '무한히 자라지 않는다')
   assert.ok(t.cycles.length > 0, '사이클을 만났다는 사실을 말한다')
-  await TwinEngine.ingestMaster(domainId, master())
+  await TwinEngine.ingestMaster(domainId, master(), 'reset')
 })
 
 test('상한에서 끊기면 끊겼다고 알린다 — 조용히 자르지 않는다', async () => {
@@ -167,10 +167,10 @@ test('선언에 없는 자재를 참조하면 그 사실이 드러난다', async
       { key: 'trailer-line', label: 't', inputs: [{ material: 'no-such-part', qty: 1 }], outputs: [{ material: 'trailer', qty: 1 }] }
     ]
   })
-  await TwinEngine.ingestMaster(domainId, ghost)
+  await TwinEngine.ingestMaster(domainId, ghost, 'reset')
   const t = await explode('trailer')
   const child = t.items.find((n: any) => n.id === 'no-such-part')
   assert.ok(child, '가리켜진 것은 그리되')
   assert.equal(child.known, false, '선언에 없다는 사실을 함께 낸다(있는 척하지 않는다)')
-  await TwinEngine.ingestMaster(domainId, master())
+  await TwinEngine.ingestMaster(domainId, master(), 'reset')
 })

package/test/twin-origin-resync.test.ts

@@ -68,7 +68,7 @@ after(async () => {
 })
 
 test('인제스트가 원천을 각인한다 — 원천이 무엇이든 한 자리에', async () => {
-  await TwinEngine.ingestMaster(domainId, master(BORN, 3, { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } }))
+  await TwinEngine.ingestMaster(domainId, master(BORN, 3, { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } }), 'reset')
   assert.deepEqual(await originOf(BORN), { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } })
 })
 
@@ -78,7 +78,7 @@ test('원천을 모르는 재프로비전이 이미 아는 것을 지우지 않
    * 인제스트한다. 그때 `origin` 을 덮어 비우면 그 트윈은 **조용히 다시 읽을 수 없게 된다.**
    * 그런 종류의 손상은 다음번에 다시 읽으려 할 때까지 아무도 모른다.
    */
-  await TwinEngine.ingestMaster(domainId, master(BORN, 5))
+  await TwinEngine.ingestMaster(domainId, master(BORN, 5), 'reset')
   assert.deepEqual(
     await originOf(BORN),
     { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } },
@@ -90,12 +90,12 @@ test('원천을 모르는 재프로비전이 이미 아는 것을 지우지 않
 })
 
 test('새 원천을 말하면 갱신된다 — 보존은 침묵에만 적용된다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(BORN, 5, { kind: 'reference', source: 'oracle-wms' }))
+  await TwinEngine.ingestMaster(domainId, master(BORN, 5, { kind: 'reference', source: 'oracle-wms' }), 'reset')
   assert.deepEqual(await originOf(BORN), { kind: 'reference', source: 'oracle-wms' })
 })
 
 test('원천 없이 태어난 트윈은 원천이 없다 — 짐작해 채우지 않는다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(ORPHAN, 2))
+  await TwinEngine.ingestMaster(domainId, master(ORPHAN, 2), 'reset')
   assert.equal(await originOf(ORPHAN), null, '모르는 것을 아는 척하면 엉뚱한 원본으로 현장을 덮는다')
 })
 

package/test/yield-loop.test.ts

@@ -0,0 +1,144 @@
+/*
+ * **한 바퀴** — 커널이 라인을 돌리고, 그 이벤트를 접어, 배운 수율이 다시 커널로 들어간다.
+ *
+ * ── 왜 이 시험이 필요했나 (2026-08-19) ─────────────────────────────────────
+ * 층마다 시험이 있었다(커널 7 · 호스트 9). 그런데 **사슬이 이어졌는지**는 층 시험으로 알 수 없다 —
+ * 이벤트 모양이 한 칸만 어긋나도 각 층은 통과하면서 전체는 조용히 상수로 돈다.
+ *
+ * 실 앱에서 보려고 데모 MES 트윈으로 한 바퀴를 돌리려 했는데 두 번 막혔다: ① 데모의 자극(시나리오)은
+ * **시드 때만 실려서** 트윈을 재기동하면 사라진다 ② 모델에서 읽은 값으로 자극을 재구성했지만 부품 도착이
+ * 레시피 입력과 맞물리지 않아 라인이 돌지 않았다. 그 두 개는 **데모 데이터의 문제**이고, 우리가 증명해야
+ * 하는 것(사슬)과는 다른 문제다.
+ *
+ * 그래서 여기서 **DB·서버 없이** 진짜 사슬을 돌린다: 커널(MES) → `task.status` 이벤트 → 호스트의 실제
+ * 폴드(`foldKpi`) → 실제 추정기(`buildYieldEstimator`) → 커널 시임. 가짜 이벤트를 손으로 만들지 않는다 —
+ * 커널이 낸 것을 그대로 접는다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createRequire } from 'node:module'
+
+import { foldKpi } from '../server/engine/kpi-fold.ts'
+import { buildYieldEstimator } from '../server/engine/measured-yield.ts'
+
+/* 커널은 한 벌로 묶인 산출물로 들어온다(서브패스는 exports 로 막혀 있다 — property-effects 시험과 같은 이유). */
+const require = createRequire(import.meta.url)
+const { MesKernel, MES_PART_GTINS } = require('@operato/twin-kernel')
+
+/** 보드·자극은 커널 시험(`mes.test.ts`)의 것과 같은 모양 — 여기서 공장을 지어내지 않는다. */
+function board() {
+  return {
+    locations: [
+      { id: 'raw-store', type: 'raw-store', capacity: 500 },
+      { id: 'cut-station', type: 'cut-station', capacity: 20 },
+      { id: 'weld-station', type: 'weld-station', capacity: 20 },
+      { id: 'paint-booth', type: 'paint-booth', capacity: 20 },
+      { id: 'assembly-line', type: 'assembly-line', capacity: 20 },
+      { id: 'fg-store', type: 'fg-store', capacity: 200 }
+    ],
+    equipment: [
+      { id: 'cutter-1', kind: 'cutter', homeLocation: 'cut-station' },
+      { id: 'welder-1', kind: 'welder', homeLocation: 'weld-station' },
+      { id: 'painter-1', kind: 'painter', homeLocation: 'paint-booth' },
+      { id: 'assembler-1', kind: 'assembler', homeLocation: 'assembly-line' }
+    ]
+  }
+}
+
+const partsInbound = {
+  seed: 3,
+  generators: [
+    {
+      kind: 'inbound-arrival',
+      rate: { distribution: 'constant', meanPerHour: 720 },
+      content: { skuMix: [{ gtin: MES_PART_GTINS.partA, weight: 1 }, { gtin: MES_PART_GTINS.partB, weight: 1 }], qtyPerLine: { min: 1, max: 1 } }
+    }
+  ]
+}
+const workOrders = {
+  seed: 7,
+  generators: [
+    {
+      kind: 'outbound-order',
+      rate: { distribution: 'constant', meanPerHour: 360 },
+      content: { skuMix: [{ gtin: MES_PART_GTINS.partA, weight: 1 }], qtyPerLine: { min: 1, max: 1 } }
+    }
+  ]
+}
+
+/** 라인을 한 바퀴 돌린다 — 부품을 채우고 작업지시를 흘리고 배수한다. */
+function runLine(declaredYieldPct?: number): { events: any[]; kernel: any } {
+  const k: any = new MesKernel('plantA')
+  const events: any[] = []
+  k.onEvent((e: any) => events.push(e))
+  k.loadTwinModel(board())
+  /* 선언값을 넣어 두면 「실측이 선언을 이긴다」를 같은 라인에서 확인할 수 있다. */
+  if (declaredYieldPct !== undefined) k.declareParameters({ assembly: { yield: String(declaredYieldPct / 100) } })
+  k.scenario.load(partsInbound)
+  k.scenario.start()
+  for (let i = 0; i < 400; i++) k.tick(1000)
+  k.scenario.pause()
+  for (let i = 0; i < 30; i++) k.tick(1000)
+  k.scenario.load(workOrders)
+  k.scenario.start()
+  for (let i = 0; i < 300; i++) k.tick(1000)
+  k.scenario.pause()
+  for (let i = 0; i < 4000; i++) k.tick(1000)
+  return { events, kernel: k }
+}
+
+/** 커널 이벤트를 저널 줄 모양으로 — 호스트가 DB 에서 읽는 것과 같은 모양(payload 안에 data). */
+const asJournal = (events: any[]) =>
+  events.filter(e => e.eventType === 'task.status').map(e => ({ eventType: 'task.status', eventTime: e.eventTime, payload: { data: e.data } }))
+
+const window = (rows: { eventTime: string }[]) => {
+  const times = rows.map(r => Date.parse(r.eventTime)).filter(n => Number.isFinite(n))
+  return { fromMs: Math.min(...times) - 1000, toMs: Math.max(...times) + 1000 }
+}
+
+test('한 바퀴: 커널이 판정을 내고 → 폴드가 종류별로 세고 → 추정기가 비율을 배운다', () => {
+  const { events } = runLine()
+  const rows = asJournal(events)
+  assert.ok(rows.length > 50, `작업 전이가 충분히 나야 한다(관측 ${rows.length})`)
+
+  /* 호스트의 **실제** 폴드로 접는다 — 시험용 계산을 따로 만들지 않는다. */
+  const kpi = foldKpi(rows as any, window(rows as any), { groupBy: 'taskKind' })
+  const judged = (kpi.groups?.items ?? []).filter(g => g.quality)
+  assert.ok(judged.length > 0, '품질이 세어진 종류가 있어야 한다')
+  for (const g of judged) {
+    assert.ok(g.quality!.good + g.quality!.scrap > 0)
+    assert.ok(g.quality!.good + g.quality!.scrap <= g.tasks, '판정 수는 완료 수를 넘지 못한다')
+  }
+  /* 판정이 없는 종류도 있어야 한다 — 중간 스테이션은 품질을 가리지 않는다(분모에 섞이면 안 된다). */
+  assert.ok((kpi.groups?.items ?? []).some(g => !g.quality), '판정하지 않는 공정이 있다')
+
+  const learned = buildYieldEstimator(kpi.groups?.items, { minSamples: 5 })
+  assert.ok(Object.keys(learned.learned).length > 0, '수율을 배워야 한다')
+  for (const [kind, ratio] of Object.entries(learned.learned)) {
+    assert.ok(ratio >= 0 && ratio <= 1, `${kind} 의 비율이 0..1 이어야 한다(관측 ${ratio})`)
+    const s = learned.samples[kind]
+    assert.equal(learned.learned[kind], s.good / (s.good + s.scrap), '비율은 판정 수에서 곧바로 나온다')
+  }
+})
+
+test('배운 값이 커널로 되돌아가 선언값을 이긴다 — 사슬의 마지막 칸', () => {
+  /* 선언 60% 로 라인을 돌린다(그 현장의 이력이 그렇게 남는다). */
+  const { events } = runLine(60)
+  const rows = asJournal(events)
+  const kpi = foldKpi(rows as any, window(rows as any), { groupBy: 'taskKind' })
+  const learned = buildYieldEstimator(kpi.groups?.items, { minSamples: 5 })
+  const kinds = Object.keys(learned.learned)
+  assert.ok(kinds.length > 0, '이력에서 배운 종류가 있어야 한다')
+
+  /* 새 커널에 그 이력을 실으면 — 선언값(90%)이 아니라 이력값으로 답한다. */
+  const k2: any = new MesKernel('plantA')
+  k2.declareParameters(Object.fromEntries(kinds.map(kind => [kind, { yield: '0.9' }])))
+  k2.yieldEstimator = learned.estimator
+  for (const kind of kinds) {
+    assert.equal(k2.yieldOf(kind), learned.learned[kind], `${kind}: 이력값이 이긴다`)
+    assert.deepEqual(k2.specCoverage().operations.find((o: any) => o.kind === kind)?.parameterBasis, { yield: 'measured' })
+  }
+  /* 이력이 없는 종류는 그대로 선언값이다 — 배운 것만 이긴다(전부 덮지 않는다). */
+  k2.declareParameters({ 'never-run': { yield: '0.5' } })
+  assert.equal(k2.yieldOf('never-run'), 0.5)
+})