@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/warm-start.test.ts

@@ -1,297 +0,0 @@
-/*
- * ★ 웜스타트 판정 검증 — 재기동하는 커널에 직전 관측 상태를 심을지.
- *
- * 이 판정은 **양쪽으로 오류 없이 틀린 값을 낸다**: 심어야 할 때 안 심으면 있는 재고가 0 으로 보이고
- * (2026-07-31 hatiolab-wms — 저널에 입고 540·출고 94 인데 재고 화면이 비어 있었다),
- * 벤치에 심으면 용량 측정이 오염된다. 둘 다 화면에는 아무 이상이 없어 보인다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { planLiveContinuity, planWarmStart, unwrapState } from '../server/engine/warm-start.ts'
-
-const STATE = {
-  locations: [{ id: 'dock-recv' }, { id: 'rack-1' }],
-  items: [{ epc: 'a' }, { epc: 'b' }, { epc: 'c' }],
-  equipment: [{ id: 'fork-1' }],
-  orders: [{ id: 'SO-1', kind: 'outbound', status: 'created', progress: 0.5 }],
-  tasks: [{ id: 't1' }]
-}
-
-test('상태가 있으면 심는다 — 재고·노드·무버', () => {
-  const plan = planWarmStart(STATE, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.itemCount, 3)
-  assert.equal(plan.equipmentCount, 1)
-  assert.deepEqual(plan.seed.locations, STATE.locations)
-})
-
-test('원값 없는 오더는 심지 않는다 — 남은 수량을 알 수 없어 지어내야 하기 때문', () => {
-  /* STATE 의 오더는 progress 만 들고 있다 — 커널 판정(requested !== undefined)과 같은 기준으로 뺀다. */
-  const plan = planWarmStart(STATE, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.seed.orders, undefined)
-  assert.equal(plan.orderCount, 0)
-  assert.equal(plan.ordersWithoutDemand, 1)
-})
-
-test('뺀 오더의 수를 센다 — "주문이 없다" 와 "주문을 못 심었다" 가 같아지면 안 된다', () => {
-  /*
-   * 이 숫자가 로그의 근거다. 세지 않고 알리지 않고 빼면, 재기동 후 빈 주문 목록을 보고
-   * 사용자는 "원래 없었다" 로 읽는다. 실제로 그 화면이 오래 남아 있었다.
-   */
-  const mixed = {
-    ...STATE,
-    orders: [
-      { id: 'SO-1', kind: 'outbound', status: 'created', progress: 0.5 },
-      { id: 'SO-2', kind: 'outbound', status: 'created', requested: 100, fulfilled: 40 },
-      { id: 'SO-3', kind: 'outbound', status: 'created', requested: 30 }
-    ]
-  }
-  const plan = planWarmStart(mixed, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.orderCount, 2)
-  assert.equal(plan.ordersWithoutDemand, 1)
-  assert.deepEqual((plan.seed.orders as any[]).map(o => o.id), ['SO-2', 'SO-3'])
-})
-
-test('진행 중 주문을 심는다 — 재기동하면 주문이 사라졌던 결함의 회귀 방지', () => {
-  /*
-   * 예전에는 씨앗이 자리·물품·설비 셋만 넘겨, 재고는 맞는데 주문 목록이 비었다. 원값이 있는
-   * 오더는 반드시 씨앗에 실려야 한다 — 이 단언이 그 결함으로 되돌아가는 것을 막는다.
-   */
-  const plan = planWarmStart(
-    { ...STATE, orders: [{ id: 'SO-9', kind: 'outbound', status: 'created', requested: 50, fulfilled: 10, lines: [{ gtin: 'g1', requested: 50 }] }] },
-    undefined,
-    true
-  )
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.orderCount, 1)
-  assert.equal(plan.ordersWithoutDemand, 0)
-  assert.equal((plan.seed.orders as any[])[0].requested, 50)
-  assert.equal((plan.seed.orders as any[])[0].fulfilled, 10)
-})
-
-test('작업·사람·자산도 함께 심는다 — 커널이 심을 수 있는 축을 호스트가 버리지 않는다', () => {
-  const plan = planWarmStart(
-    { ...STATE, persons: [{ id: 'p1' }, { id: 'p2' }], assets: [{ id: 'pallet-1' }] },
-    undefined,
-    true
-  )
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.taskCount, 1)
-  assert.equal(plan.personCount, 2)
-  assert.equal(plan.assetCount, 1)
-  assert.deepEqual(plan.seed.tasks, STATE.tasks)
-  assert.equal((plan.seed.persons as any[]).length, 2)
-})
-
-test('없는 축은 씨앗에 키를 만들지 않는다 — 빈 배열로 커널 판정을 흐리지 않는다', () => {
-  const plan = planWarmStart({ locations: [{ id: 'n1' }], items: [], equipment: [] }, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.deepEqual(Object.keys(plan.seed).sort(), ['equipment', 'items', 'locations'])
-})
-
-test('오더만 있어도 심는다 — 구조가 모델에서 오는 경우가 있다', () => {
-  const plan = planWarmStart({ orders: [{ id: 'SO-1', requested: 10 }] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.orderCount, 1)
-})
-
-test('벤치 트윈에는 심지 않는다 — 새 시작에서 용량을 재는 것이 목적이다', () => {
-  const plan = planWarmStart(STATE, 'bench', true)
-  assert.deepEqual(plan, { action: 'skip', reason: 'bench' })
-})
-
-test('벤치 판정은 상태 유무보다 먼저다 — 상태가 없어도 이유는 bench 여야 한다', () => {
-  /* 이유가 뒤바뀌면 로그가 "심을 게 없었다" 로 남아, 벤치를 의도적으로 비웠다는 사실이 사라진다. */
-  assert.deepEqual(planWarmStart(null, 'bench', true), { action: 'skip', reason: 'bench' })
-})
-
-test('심을 상태가 없으면 알리지 않고 넘어간다 — 처음 만든 트윈의 정상 경로다', () => {
-  assert.deepEqual(planWarmStart(null, undefined, true), { action: 'skip', reason: 'no-state' })
-  assert.deepEqual(planWarmStart(undefined, undefined, true), { action: 'skip', reason: 'no-state' })
-  assert.deepEqual(planWarmStart({ locations: [], items: [], equipment: [] }, undefined, true), { action: 'skip', reason: 'no-state' })
-})
-
-test('노드만 있어도 심는다 — 구조 배치가 복원되면 화면이 살아난다', () => {
-  const plan = planWarmStart({ locations: [{ id: 'n1' }], items: [], equipment: [] }, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.itemCount, 0)
-})
-
-test('커널이 주입을 지원하지 않으면 알린다 — 알리지 않고 빈 채로 뜨면 안 된다', () => {
-  assert.deepEqual(planWarmStart(STATE, undefined, false), { action: 'skip', reason: 'unsupported' })
-})
-
-test('심을 게 없으면 미지원이어도 경고할 일이 아니다', () => {
-  /* 미지원 경고가 매 기동마다 뜨면 진짜 경고가 묻힌다. */
-  assert.deepEqual(planWarmStart(null, undefined, false), { action: 'skip', reason: 'no-state' })
-})
-
-test('빠진 배열은 빈 배열로 다뤄지되 없는 것을 지어내지 않는다', () => {
-  const plan = planWarmStart({ items: [{ epc: 'a' }] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.deepEqual(plan.seed.locations, [])
-  assert.deepEqual(plan.seed.equipment, [])
-  assert.equal(plan.itemCount, 1)
-})
-
-test('확인해 둔 주목 신호를 이어받는다 — 재기동하면 다시 빨개지던 것', () => {
-  /*
-   * 확인 처리는 상태에서 파생되지 않는 유일한 축이다. 씨앗에서 빠지면 재기동 후 확인해 둔 신호가
-   * 전부 다시 활성으로 뜬다 — 오류는 나지 않고, 사용자는 "또 터졌다" 로 읽는다.
-   */
-  const plan = planWarmStart({ ...STATE, acked: ['bottleneck:bin-1', 'breakdown:fk-1'] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.deepEqual(plan.seed.acked, ['bottleneck:bin-1', 'breakdown:fk-1'])
-  assert.equal(plan.ackedCount, 2)
-})
-
-test('확인 처리만 있어도 복원한다 — 신호를 확인해 둔 사실 자체가 이어받을 가치가 있다', () => {
-  const plan = planWarmStart({ acked: ['bottleneck:bin-1'] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.ackedCount, 1)
-})
-
-test('확인 처리가 문자열 목록이 아니면 없는 것으로 본다 — 지어내지 않는다', () => {
-  const plan = planWarmStart({ ...STATE, acked: 'nope' } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.ackedCount, 0)
-  assert.equal(plan.seed.acked, undefined)
-})
-
-/*
- * ── 겹포장 회귀 방지 (2026-08-05) ──────────────────────────────────────────
- * 체크포인트가 `{revision, state:{revision, state:{실제}}}` 로 저장돼, 꺼낸 값에 축이 하나도 없었다.
- * 판정은 "심을 것이 없다"(no-state)로 답하고 **알리지 않고** 넘어갔다 — 저널에 수천 건이 있고 캐시도
- * 최신인데 트윈이 빈 채로 떴다. 오류도 로그도 없어서 이 경로가 처음부터 죽어 있었다.
- */
-test('봉투로 감싸여 와도 벗겨서 심는다 — 체크포인트가 겹포장돼 복원이 죽었던 자리', () => {
-  const enveloped = { revision: 2684, state: { revision: 2684, state: STATE } }
-  const plan = planWarmStart(enveloped as any, undefined, true)
-  assert.equal(plan.action, 'hydrate', '봉투를 받으면 심을 것이 없다고 답하면 안 된다')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.itemCount, 3)
-  assert.deepEqual(plan.seed.locations, STATE.locations)
-})
-
-test('한 겹 봉투도 벗긴다 — 저장 방식이 바뀌는 동안 두 모양이 함께 남는다', () => {
-  const plan = planWarmStart({ revision: 1, state: STATE } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.itemCount, 3)
-})
-
-test('벗길 것이 없으면 그대로 쓴다 — 상태를 봉투로 착각하지 않는다', () => {
-  const plan = planWarmStart(STATE, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.itemCount, 3)
-})
-
-test('빈 봉투는 여전히 no-state — 벗겼는데도 아무 축이 없으면 심을 것이 없다', () => {
-  assert.deepEqual(planWarmStart({ revision: 5, state: { revision: 5 } } as any, undefined, true), { action: 'skip', reason: 'no-state' })
-})
-
-test('unwrapState 는 상태를 먼저 알아본다 — state 라는 이름의 축이 있어도 벗기지 않는다', () => {
-  const st = { items: [{ epc: 'a' }], state: 'whatever' }
-  assert.equal(unwrapState(st as any), st, '축이 있으면 그것이 상태다')
-})
-
-/*
- * ── 「언제부터인가」도 씨앗에 실린다 (2026-08-18) ─────────────────────────────
- * 확인과 같은 성질이다 — 상태에서 파생되지 않으므로 넘기지 않으면 사라진다. 사라지면 세 시간째
- * 지속된 조건이 재기동 뒤 「0초째」가 되고, 화면은 사람을 잘못된 순서로 움직인다.
- */
-test('주목 신호 시작 시각이 씨앗에 실린다 — 재기동 뒤 지속 시간이 거짓이 되지 않게', () => {
-  const since = [{ id: 'bottleneck:bin-1', since: '2026-08-18T01:00:00.000Z' }]
-  const plan = planWarmStart({ ...STATE, attentionSince: since } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.deepEqual(plan.seed.attentionSince, since)
-  assert.equal(plan.attentionSinceCount, 1)
-})
-
-test('시작 시각만 있어도 복원한다 — 그 사실 자체가 이어받을 가치가 있다', () => {
-  const plan = planWarmStart({ attentionSince: [{ id: 'a', since: '2026-08-18T01:00:00.000Z' }] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.attentionSinceCount, 1)
-})
-
-test('모양이 아닌 시작 시각은 없는 것으로 본다 — 지어낸 시각을 심지 않는다', () => {
-  const plan = planWarmStart({ ...STATE, attentionSince: ['bottleneck:bin-1', { id: 'ok', since: 5 }, { since: '2026-08-18T01:00:00.000Z' }] } as any, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.attentionSinceCount, 0)
-  assert.equal(plan.seed.attentionSince, undefined)
-})
-
-/*
- * ── 미러 재기동의 연속성 (2026-08-18) ────────────────────────────────────────
- * 미러는 오랫동안 아무것도 이어받지 않았다 — 진실이 원천에 있으니 옳았지만, 원천이 **애초에 다시 말해
- * 주지 않는 축**까지 함께 버렸다. 그래서 재기동하면 오류 없이 값이 작아졌다.
- */
-test('미러는 되풀어 주지 않는 축만 이어받는다 — 관측 축은 원천에서 온다', () => {
-  const plan = planLiveContinuity({
-    ...STATE,
-    acked: ['bottleneck:bin-1'],
-    attentionSince: [{ id: 'bottleneck:bin-1', since: '2026-08-18T01:00:00.000Z' }],
-    energy: { points: [{ id: 'm-1', kWhAtWindowStart: 1000, samplesInWindow: 3 }], closed: [], closedTotal: 0 }
-  })
-  assert.equal(plan.ackedCount, 1)
-  assert.equal(plan.attentionSinceCount, 1)
-  assert.equal(plan.energy, true)
-  /* 관측 축은 **일부러** 넣지 않는다 — 심으면 부팅 전에 떠난 물건이 되살아난다. */
-  assert.equal((plan.seed as any).locations, undefined)
-  assert.equal((plan.seed as any).items, undefined)
-  assert.equal((plan.seed as any).equipment, undefined)
-  assert.equal((plan.seed as any).orders, undefined)
-})
-
-test('에너지가 없는 트윈은 에너지를 이어받지 않는다 — 없는 것을 있다고 하지 않는다', () => {
-  const plan = planLiveContinuity({ ...STATE, acked: ['x'] })
-  assert.equal(plan.energy, false)
-  assert.equal((plan.seed as any).energy, undefined)
-})
-
-test('이어받을 것이 없으면 빈 씨앗이다 — 빈 주입으로 로그만 남기지 않는다', () => {
-  const plan = planLiveContinuity(STATE)
-  assert.deepEqual(plan.seed, {})
-  assert.equal(plan.ackedCount + plan.attentionSinceCount, 0)
-  assert.equal(plan.energy, false)
-})
-
-test('겹포장된 체크포인트도 벗겨 읽는다 — 한 번은 반드시 만난다', () => {
-  const plan = planLiveContinuity({ revision: 42, state: { acked: ['a'], energy: { points: [] } } })
-  assert.equal(plan.ackedCount, 1)
-  assert.equal(plan.energy, true)
-})
-
-/* 배선이 사라지면 미러는 알리지 않고 예전으로 돌아간다 — 소스 모양으로 못 박는다(엔진은 DB 를 물고 있다). */
-test('미러 기동이 연속성 씨앗을 심는다 — 배선이 사라지지 않게', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const at = src.indexOf('static startLive(')
-  assert.ok(at > 0)
-  const body = src.slice(at, src.indexOf('\n  static ', at + 10))
-  assert.match(body, /seedLiveContinuity\(domainId, id, kernel\)/, '미러가 연속성을 이어받아야 한다')
-  assert.ok(
-    body.indexOf('seedLiveContinuity') < body.indexOf('delete this.recovered[key]'),
-    '캐시를 지우기 전에 심는다 — 순서가 뒤집히면 늘 빈손이다'
-  )
-})

package/test/withheld-door.test.ts

@@ -1,95 +0,0 @@
-/*
- * ★ **원본에 있는데 세우지 않은 것** — 그 사실이 스쳐 지나가지 않게.
- *
- * ── 무엇이 아무 신호도 내지 않았나 (2026-08-24) ────────────────────────────────────────────
- * 커넥터가 원본의 사실 일부를 **일부러 받지 않는 일이 정상이다**(입자가 안 맞는다 · 받으면 상태가
- * 거짓이 된다 · 커널 어휘로 옮길 수 없다). 그때 경고를 내는데, 그 경고의 유일한 소비처가 **프로비저닝
- * 마법사**였다 — 트윈을 만드는 동안만 뜨는 화면이다.
- *
- * 그래서 「지시되지 않은 생산계획 8건을 세우지 않았다」가 **한 번 스쳐 지나갈 뿐**이었고, 나중에
- * 사용자가 「원본보다 계획이 적다」를 물으면 답이 어디에도 없었다.
- *
- * 그 사실은 한 번의 사건이 아니라 **상태의 성질**이다 — 세우지 않은 것은 **지금도** 트윈에 없다.
- *
- * ── `unhandled` 의 형제다 ──────────────────────────────────────────────────
- *   `unhandled`   리듀서가 **받았는데** 담을 자리를 몰랐다
- *   여기          커넥터가 **보지만 일부러 보내지 않았다** — 이유와 함께
- *
- * ── 그래서 문에서 조회까지 걷는다 ───────────────────────────────────────────
- * 오늘 「계약에 자리는 있고 그 자리로 가는 길이 없다」를 여섯 번 만났다. 장부만 검사하면 어댑터가
- * 부를 문이 없는 것을 못 잡는다 — 그것이 그 결함들이 살아남은 방식이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
-
-const req = createRequire(import.meta.url)
-const { newIngestLedger, recordWithheld, ingestHealth } = req('../dist-server/engine/ingest-health.js')
-
-const REASON = '아직 지시되지 않은 생산계획을 세우지 않았다 — 커널의 created 는 「할당해도 되는 오더」를 뜻한다'
-
-test('★ 세우지 않은 것이 조회에 나온다 — 유입이 한 건도 없어도', () => {
-  /*
-   * 이 갈래가 중요하다: 원본이 말하는데 **전부** 안 받는 경우가 있고, 그때 유입은 0 이다.
-   * 유입 있는 갈래에서만 내면 바로 그 상황에서 들어온 것이 없어진다.
-   */
-  const l = newIngestLedger()
-  recordWithheld(l, REASON, 8, Date.parse('2026-08-24T11:19:16.000Z'))
-  const view: any = ingestHealth(l)
-  assert.equal(view.withheld?.length, 1)
-  assert.equal(view.withheld[0].reason, REASON)
-  assert.equal(view.withheld[0].count, 8)
-  assert.equal(view.withheld[0].lastAt, '2026-08-24T11:19:16.000Z', '언제 그랬는지 함께 — 「지금도 그런가」를 사람이 판정한다')
-})
-
-test('주기마다 불러도 부풀지 않는다 — 누적이 아니라 **지금 세우지 않은 수**다', () => {
-  /* 8건이 매 주기 다시 보고되면 8 이어야 한다. 더해서 800 이 되면 거짓이다. */
-  const l = newIngestLedger()
-  for (let i = 0; i < 100; i++) recordWithheld(l, REASON, 8, 1000 + i)
-  assert.equal(l.withheld.length, 1)
-  assert.equal(l.withheld[0].count, 8)
-  assert.equal(l.withheld[0].lastAtMs, 1099, '마지막 시각으로 움직인다')
-})
-
-test('수가 달라지면 마지막 수로 덮는다 — 낡은 수가 남지 않게', () => {
-  const l = newIngestLedger()
-  recordWithheld(l, REASON, 8, 1000)
-  recordWithheld(l, REASON, 3, 2000)
-  assert.equal(l.withheld[0].count, 3)
-})
-
-test('이유가 여럿이면 각자 한 줄 — 다른 사실을 한 줄로 뭉치지 않는다', () => {
-  const l = newIngestLedger()
-  recordWithheld(l, REASON, 8, 1000)
-  recordWithheld(l, '사람이 올린 문서라 자재와 이어지지 않는다', 46, 1000)
-  assert.equal((ingestHealth(l) as any).withheld.length, 2)
-})
-
-test('말하지 않은 것은 만들지 않는다 — 빈 목록을 「세우지 않은 것이 있다」로 읽히게 하지 않는다', () => {
-  const l = newIngestLedger()
-  assert.equal((ingestHealth(l) as any).withheld, undefined, '키 자체가 없다')
-  recordWithheld(l, REASON, 0, 1000)
-  assert.equal(l.withheld, undefined, '0 은 적지 않는다')
-  recordWithheld(l, '', 5, 1000)
-  assert.equal(l.withheld, undefined, '이유 없는 것은 적지 않는다')
-})
-
-test('★ 어댑터가 부를 문이 있고, 그 문이 장부에 닿는다', () => {
-  /*
-   * 이 단정이 오늘 여섯 번 만난 부류를 막는다. 장부만 검사하면 **어댑터가 부를 통로가 없는 것**을
-   * 못 잡고, 그러면 보내는 쪽에는 「알렸다」로 보이고 화면에는 「없다」로 보인다.
-   */
-  const adapter = readFileSync(new URL('../server/service/reference/reference-adapter.ts', import.meta.url), 'utf-8')
-  assert.match(adapter, /onWithheld\?: \(info: \{ reason: string; count: number \}\) => void/, '계약에 통로가 있다')
-
-  const live = readFileSync(new URL('../server/service/reference/reference-live.ts', import.meta.url), 'utf-8')
-  const wired = live.slice(live.indexOf('onWithheld'), live.indexOf('onWithheld') + 260)
-  assert.match(wired, /recordIngestWithheld/, '그 통로가 장부로 이어진다')
-
-  const engine = readFileSync(new URL('../server/engine/twin-engine.ts', import.meta.url), 'utf-8')
-  const fn = engine.slice(engine.indexOf('static recordIngestWithheld'))
-  assert.match(fn.slice(0, 700), /recordWithheld\(ledger/, '엔진이 장부에 적는다')
-  /* 실패로 적지 않는다 — 어댑터의 옳은 판단이고, 오류로 적으면 화면이 원본을 의심한다. */
-  assert.doesNotMatch(fn.slice(0, 700), /lastError|status:/, '오류로 적지 않는다')
-})

package/test/yield-loop.test.ts

@@ -1,199 +0,0 @@
-/*
- * **한 바퀴** — 커널이 라인을 돌리고, 그 이벤트를 계산해, 배운 수율이 다시 커널로 들어간다.
- *
- * ── 왜 이 시험이 필요했나 (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 } = require('@operato/twin-kernel')
-/* 이 시험이 쓰는 부품 품번을 여기서 선언합니다 — 커널이 생성한 값을 가져다 쓰지 않습니다(0.7.40 이
-   그 export 를 제거했습니다). 프리픽스는 GS1 이 예제로 지정한 952 대역입니다. */
-const MES_PART_GTINS = { partA: 'urn:epc:idpat:sgtin:9521321.011111.*', partB: 'urn:epc:idpat:sgtin:9521321.022222.*' } /* 선언(SPEC.binding)과 같은 값이어야 자극이 그 자재로 들어옵니다. */
-
-/** 보드·자극은 커널 시험(`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 } }
-    }
-  ]
-}
-
-
-/**
- * 이 라인의 **생산 선언** — 커널이 더는 내장 데모 제품을 들지 않습니다(0.7.43).
- *
- * 무엇을 만드는가는 모델이 정합니다. 그래서 이 시험도 자기 자재·라우트·레시피를 선언하고, 자재는
- * 자기 보관 자리를, 현장은 작업지시의 문서 타입을 선언합니다. 프리픽스는 GS1 이 예제로 지정한 952
- * 대역입니다 — 실 배정 대역을 시험 데이터에 쓰지 않습니다.
- */
-const PREFIX = '9521321'
-const SPEC = {
-  companyPrefix: PREFIX,
-  binding: { partA: '011111', partB: '022222', unit: '033333' },
-  identity: { documentTypes: { workorder: '403' } },
-  definition: {
-    materials: [
-      { key: 'partA', label: '부품 A', locationType: 'raw-store' },
-      { key: 'partB', label: '부품 B', locationType: 'raw-store' },
-      { key: 'unit', label: '완성품', locationType: 'fg-store' }
-    ],
-    locationTypes: [
-      { key: 'raw-store', label: '자재 보관' },
-      { key: 'cut-station', label: '절단' },
-      { key: 'weld-station', label: '용접' },
-      { key: 'paint-booth', label: '도장' },
-      { key: 'assembly-line', label: '조립' },
-      { key: 'fg-store', label: '완제품 보관' }
-    ],
-    resourceTypes: [
-      { key: 'cutter', label: '절단기' },
-      { key: 'welder', label: '용접기' },
-      { key: 'painter', label: '도장기' },
-      { key: 'assembler', label: '조립기' }
-    ],
-    operations: [
-      { key: 'cut', label: '절단', intent: 'process', locationType: 'cut-station', resourceType: 'cutter', duration: 'PT1M' },
-      { key: 'weld', label: '용접', intent: 'process', locationType: 'weld-station', resourceType: 'welder', duration: 'PT1M' },
-      { key: 'paint', label: '도장', intent: 'process', locationType: 'paint-booth', resourceType: 'painter', duration: 'PT1M' },
-      { key: 'assembly', label: '조립', intent: 'process', locationType: 'assembly-line', resourceType: 'assembler', duration: 'PT1M' }
-    ],
-    routes: [{ key: 'line', label: '라인', steps: ['cut', 'weld', 'paint', 'assembly'] }],
-    recipes: [
-      {
-        key: 'unit',
-        label: '완성품',
-        route: 'line',
-        inputs: [{ material: 'partA', qty: 1 }, { material: 'partB', qty: 1 }],
-        outputs: [{ material: 'unit', qty: 1 }]
-      }
-    ]
-  }
-}
-
-/** 라인을 한 바퀴 돌린다 — 부품을 채우고 작업지시를 흘리고 배수한다. */
-function runLine(declaredYieldPct?: number): { events: any[]; kernel: any } {
-  const k: any = new MesKernel('plantA', undefined, SPEC)
-  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)
-})

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "../tsconfig-base.json",
-  "compilerOptions": {
-    "outDir": "./dist-server",
-    /* shared/ 는 별도 산출(dist-shared) — 여기 섞이면 dist-server/server/ 로 한 겹 밀린다. */
-    "rootDir": "./server",
-    "baseUrl": "./",
-    "skipLibCheck": true,
-    /* 시험은 소스를 그대로 불러오므로 지역 import 가 `.ts` 여야 하고, 산출물은 `.js` 여야 한다.
-       이 옵션이 컴파일 때 확장자를 바꿔 준다(twin-ai 가 이미 쓰는 관행 — 두 규칙을 함께 지킨다). */
-    "rewriteRelativeImportExtensions": true
-  },
-  "include": ["./server/**/*"],
-  "exclude": ["**/*.spec.ts"]
-}

package/tsconfig.shared.json

@@ -1,23 +0,0 @@
-/*
- * 공유 어휘 빌드 — 서버와 **브라우저가 함께 보는** 순수 모듈.
- *
- * 왜 서버 빌드와 따로인가 (2026-08-07):
- * 이 파일들은 `server/engine/` 안에 있었고, 화면 코드가 `dist-server/engine/*.js` 를 깊이 참조했다.
- * 그런데 `build:server` 는 `rm -rf dist-server` 로 시작한다. tsc 가 다시 채우기 전 그 틈에 webpack 이
- * 컴파일하면 해석에 실패하고, 그 실패가 `bootstrap.js` 를 죽여 **앱 전체가 백지**가 된다. 콘솔에
- * 오류 한 줄 없이 화면만 빈다. 실제로 그렇게 한 번 멈췄다.
- *
- * 그래서 산출 자리를 서버와 분리한다. `dist-shared` 는 서버를 다시 빌드해도 지워지지 않는다.
- * (`build:shared` 도 일부러 clean 하지 않는다 — 지우는 순간이 곧 그 틈이다. 전체 정리는 `clean` 이 한다.)
- */
-{
-  "extends": "../tsconfig-base.json",
-  "compilerOptions": {
-    "outDir": "./dist-shared",
-    "rootDir": "./shared",
-    "baseUrl": "./",
-    "declaration": true,
-    "skipLibCheck": true
-  },
-  "include": ["./shared/**/*"]
-}