@things-factory/headless-twin 10.0.19 → 10.1.0

package/test/ingest-dedupe.test.ts

@@ -0,0 +1,56 @@
+/*
+ * 같은 사실을 두 번 받았을 때 한 번으로 세는 근거 — **정체**.
+ *
+ * 정체를 못 만들면 그 사실은 dedupe 밖이고, 다시 받을 때마다 저널에 새로 앉는다. backfill 이 그것을
+ * 드러냈다(2026-09-06).
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { factIdentity, takeUnidentified } from '../server/engine/ingest-dedupe.js'
+
+/* ── 주체가 subjectId 인 사실 ───────────────────────────────────────────────── */
+
+test('★ 처분과 시험은 subjectId 가 주체다 — 그 이름이 없으면 정체가 안 만들어진다', () => {
+  /*
+   * [측정함 2026-09-06] `fillTwinScope` 를 돌릴 때마다 처분 4건 · 시험 3건이 다시 앉았다. 나머지
+   * 34건은 걸러지는데 이 둘만 계속 늘었다.
+   *
+   * 원인은 `discriminatorsOf` 에 `subjectId` 가 없어서 `parts` 가 비고, `factIdentity` 가
+   * `undefined` 를 낸 것이다. 정체가 없으면 dedupe 밖이다.
+   */
+  const disposition = {
+    eventType: 'nonconformance.disposition',
+    eventTime: '2026-09-01T02:50:51.832Z',
+    data: { subjectId: 'LOT-A', decision: 'scrap', quantity: 50 }
+  }
+  const id = factIdentity(disposition)
+  assert.ok(id, '정체를 못 만들면 다시 받을 때마다 새로 앉는다')
+  assert.ok(id!.includes('subject=LOT-A'), `주체가 정체에 안 들어갔다: ${id}`)
+})
+
+test('★ 다른 로트의 같은 처분은 다른 사실이다', () => {
+  const at = '2026-09-01T02:50:51.832Z'
+  const a = factIdentity({ eventType: 'nonconformance.disposition', eventTime: at, data: { subjectId: 'LOT-A', decision: 'scrap' } })
+  const b = factIdentity({ eventType: 'nonconformance.disposition', eventTime: at, data: { subjectId: 'LOT-F', decision: 'scrap' } })
+  assert.notEqual(a, b, '두 로트의 처분이 한 사실로 뭉쳤다')
+})
+
+test('★ 같은 사실을 다시 받으면 같은 정체다 — backfill 이 저널을 안 부풀린다', () => {
+  const rec = { eventType: 'nonconformance.disposition', eventTime: '2026-09-01T02:50:51.832Z', data: { subjectId: 'LOT-A', decision: 'scrap', quantity: 50 } }
+  assert.equal(factIdentity(rec), factIdentity({ ...rec, data: { ...rec.data } }))
+})
+
+test('★ 시험 결과는 명세도 가른다 — 같은 대상에 시험이 여럿이다', () => {
+  const at = '2026-09-01T00:00:00.000Z'
+  const a = factIdentity({ eventType: 'test.result', eventTime: at, data: { subjectId: 'EQ-1', specId: 'CP-PBA-INCOMING' } })
+  const b = factIdentity({ eventType: 'test.result', eventTime: at, data: { subjectId: 'EQ-1', specId: 'CP-PBA-TEST' } })
+  assert.notEqual(a, b, '같은 대상의 두 시험이 한 사실로 뭉쳤다')
+})
+
+test('★ 정체를 못 만든 것을 센다 — 조용히 dedupe 밖으로 나가지 않는다', () => {
+  takeUnidentified()
+  assert.equal(factIdentity({ eventType: 'made.up.kind', eventTime: '2026-09-01T00:00:00.000Z', data: {} }), undefined)
+  assert.deepEqual(takeUnidentified(), { 'made.up.kind': 1 })
+  assert.deepEqual(takeUnidentified(), {}, '읽고 비운다')
+})

package/test/ingest-expected-quiet.test.ts

@@ -0,0 +1,111 @@
+/*
+ * ★ **지금은 조용한 것이 정상이다** — 밤마다 나던 거짓 빨강.
+ *
+ * ── 무엇이 틀렸나 (2026-09-04) ──────────────────────────────────────────────
+ * 유입 건강이 **한 자로 전부를 쟀다.** 10분 안에 아무것도 오지 않으면 「유입 없음」이다. 그런데
+ * 태양광은 밤에 발전하지 않고, 업무시간만 도는 원천은 저녁에 아무것도 내지 않는다. 정상인데
+ * **매일 밤 절반이 빨갛게 났다.**
+ *
+ * 거짓 빨강이 쌓이면 진짜 빨강도 같이 안 읽힌다. 오늘 UX 레인이 「늘 참인 경고는 벽지가 된다」고
+ * 한 것과 같은 부류다 — 사흘이면 그 자리에 무엇이 적혀도 안 읽는다.
+ *
+ * 그리고 15분마다 긷는 원천은 긷는 사이마다 빨갛다. 이 파일이 고치는 코드가 그 한계를 **스스로
+ * 주석에 적어 두고 있었다**: 「주기를 알게 되면 그 값으로 견주는 것이 맞다」.
+ *
+ * ── 초록도 빨강도 아닌 셋째 값 ──────────────────────────────────────────────
+ * 조용한 시간을 초록으로 칠하면 **밤에 정말 끊긴 원천**을 아침까지 아무도 모른다. 그래서 답은
+ * 「지금은 안 오는 것이 맞다」이고, 그것은 다른 값이어야 한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { syncVerdictOf, STALE_AFTER_MS } from '../server/engine/ingest-health.js'
+
+const NOW = 1_800_000_000_000
+const long = NOW - STALE_AFTER_MS - 60_000 /* 한 창을 넘긴 침묵 */
+
+const at = (over: Record<string, unknown> = {}) =>
+  syncVerdictOf({
+    feedState: 'attached',
+    recent: { offered: 100, rejected: 0 },
+    lastAtMs: NOW - 1_000,
+    nowMs: NOW,
+    lastUndeliveredAtMs: -1,
+    offeredTotal: 100,
+    ...over
+  } as any)
+
+/* ── 조용한 시간 ──────────────────────────────────────────────────────────── */
+
+test('★ 조용한 시간의 긴 침묵은 「유입 없음」이 아니다', () => {
+  assert.equal(at({ lastAtMs: long, quietNow: true }), 'expected-quiet')
+})
+
+test('★ 같은 침묵이 활동 시간이면 「유입 없음」이다', () => {
+  assert.equal(at({ lastAtMs: long, quietNow: false }), 'no-traffic')
+})
+
+test('★ 달력을 선언하지 않았으면 지금까지처럼 답한다 — 모르는 것을 「조용할 때」로 읽지 않는다', () => {
+  /*
+   * `quietNow` 를 주지 않은 원천이 전부 「지금은 조용한 시간」이 되면, 정말 끊긴 원천이 통째로
+   * 조용해진다. 없으면 옛 거동 그대로다.
+   */
+  assert.equal(at({ lastAtMs: long }), 'no-traffic')
+})
+
+test('★ 조용한 시간이어도 사실이 사라지고 있으면 그것이 먼저다', () => {
+  /*
+   * 버려지는 중은 **몇 시든 문제**다. 밤이라고 덮으면 밤새 새는 것을 아침에 안다.
+   */
+  const v = at({ lastAtMs: long, quietNow: true, lastUndeliveredAtMs: NOW - 1_000 })
+  assert.equal(v, 'twin-not-running')
+})
+
+test('★ 조용한 시간이어도 결선이 없으면 그것이 먼저다', () => {
+  assert.equal(at({ feedState: 'detached', lastAtMs: long, quietNow: true }), 'not-connected')
+})
+
+test('★ 한 번도 받지 않았는데 지금이 조용한 시간이면 「모른다」가 아니다', () => {
+  /*
+   * 밤에 처음 붙인 태양광 연결이 「기다린다」로 보이면, 사람이 아침까지 무엇을 기다리는지 모른다.
+   */
+  assert.equal(at({ lastAtMs: -1, recent: null, offeredTotal: 0, quietNow: true }), 'expected-quiet')
+  assert.equal(at({ lastAtMs: -1, recent: null, offeredTotal: 0 }), 'unknown')
+})
+
+test('★ 창이 비었어도 조용한 시간이면 정상이다', () => {
+  assert.equal(at({ recent: { offered: 0, rejected: 0 }, quietNow: true }), 'expected-quiet')
+  assert.equal(at({ recent: { offered: 0, rejected: 0 } }), 'no-traffic')
+})
+
+test('조용한 시간에도 받고 있으면 받는 중이다 — 침묵이 아니면 이 축이 개입하지 않는다', () => {
+  assert.equal(at({ quietNow: true }), 'syncing')
+})
+
+/* ── 원천이 선언한 주기 ──────────────────────────────────────────────────── */
+
+test('★ 15분마다 긷는 원천은 그 주기 안에서 정상이다', () => {
+  /*
+   * 창 하나(10분)로 재면 긷는 사이마다 빨갛다. 원천이 주기를 선언하면 그것으로 견준다.
+   */
+  const twelveMin = NOW - 12 * 60_000
+
+  assert.equal(at({ lastAtMs: twelveMin }), 'no-traffic', '선언이 없으면 옛 거동')
+  assert.equal(at({ lastAtMs: twelveMin, expectedSilenceMs: 20 * 60_000 }), 'syncing')
+})
+
+test('★ 선언한 주기를 넘기면 그때는 「유입 없음」이다 — 선언이 면죄부가 아니다', () => {
+  const thirtyMin = NOW - 30 * 60_000
+  assert.equal(at({ lastAtMs: thirtyMin, expectedSilenceMs: 20 * 60_000 }), 'no-traffic')
+})
+
+test('0이나 음수 주기는 선언이 아니다 — 창 하나로 돌아간다', () => {
+  for (const bad of [0, -1, NaN]) {
+    assert.equal(at({ lastAtMs: long, expectedSilenceMs: bad }), 'no-traffic', `${bad} 를 주기로 받았다`)
+  }
+})
+
+test('★ 주기와 달력은 다른 축이다 — 주기를 넘겼는데 조용한 시간이면 정상이다', () => {
+  const thirtyMin = NOW - 30 * 60_000
+  assert.equal(at({ lastAtMs: thirtyMin, expectedSilenceMs: 20 * 60_000, quietNow: true }), 'expected-quiet')
+})

package/test/ingest-idempotent.test.ts

@@ -130,3 +130,82 @@ test('트윈마다 따로 센다 — 한 트윈의 되풀이가 다른 트윈을
   const { duplicates } = b.filter([energy('inv-1', 1)])
   assert.equal(duplicates, 0)
 })
+
+/* ════════════════════════════════════════════════════════════════════════════
+ * ★ **구별할 값이 봉투 안에 있으면 다 본다** — 골라 쓰고 나머지를 버리던 자리.
+ *
+ * ── 실측 (2026-09-05, 인티그레이션·plant 레인) ─────────────────────────────
+ * plant 이 실적 둘을 보냈는데 한 건이 저널에 안 남았다.
+ *
+ *   seq 36   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-01 · goodCount 12
+ *   seq 41   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-02 · goodCount  9
+ *
+ * 시각이 같았고(원본이 끝시각을 복사) 대상을 **먼저 걸리는 하나**로 골라서 `moverId` 가 이겼다.
+ * 거부가 아니라 **되풀이로 세어졌다** — 유입 장부에 `offered 5 · rejected 0 · journaled 3`.
+ *
+ * 원인이 시험 데이터였다고 해서 거동이 옳아지지 않는다. 두 봉투는 `taskId` 도 수량도 달랐고,
+ * **구별할 값이 이미 봉투 안에 있었는데 판정이 그것을 안 봤다.**
+ *
+ * ── 이 파일이 스스로 적어 둔 값 ───────────────────────────────────────────
+ *   「모르는 것을 같다고 판단하면 서로 다른 사실이 하나로 합쳐진다.
+ *    알리지 않고 잃는 것보다 두 번 세는 것이 낫다.」
+ *
+ * 지금 거동은 **알리지 않고 잃는 쪽**이었다.
+ * ════════════════════════════════════════════════════════════════════════════ */
+
+const AT_36 = '2026-09-05T06:50:00.000Z'
+const quality = (taskId: string, goodCount: number) => ({
+  eventType: 'quality.output',
+  data: { moverId: 'EQ-CT-MWELD-01', taskId, goodCount, at: AT_36 }
+})
+
+test('★ 한 설비가 두 작업을 같은 시각에 보고해도 두 사실이다 — 실제로 한 건을 잃던 그 줄', () => {
+  const a = factIdentity(quality('PR-CT-WIRE-01', 12))
+  const b = factIdentity(quality('PR-CT-WIRE-02', 9))
+
+  assert.ok(a && b, '정체를 못 만들면 거르지 않는다 — 이 검사가 뜻이 없다')
+  assert.notEqual(a, b, '작업이 다른 두 실적이 한 사실이 됐다')
+})
+
+test('★ 같은 봉투를 다시 보내면 여전히 같은 사실이다 — 넓혀도 되풀이는 잡힌다', () => {
+  /*
+   * 넓히는 것이 「되풀이를 놓친다」로 이어지지 않는다는 것이 이 변경의 근거다. 같은 봉투는 이
+   * 값들이 전부 같으므로 정체도 같다.
+   */
+  assert.equal(factIdentity(quality('PR-CT-WIRE-01', 12)), factIdentity(quality('PR-CT-WIRE-01', 12)))
+})
+
+test('★ 한 개체의 서로 다른 관측을 가른다 — EPCIS 는 그것이 정상이다', () => {
+  /*
+   * 저널 246만 건에 옛 규칙을 다시 걸어 여섯 묶음이 나왔고 전부 이 모양이었다. 한 물건이 한
+   * 순간에 입고이면서 개시일 수 있다 — 표준에서 이상한 일이 아닌데 규칙이 그 셋을 안 봤다.
+   */
+  const epc = 'urn:epc:id:sgtin:9521321.011111.1'
+  const receiving = {
+    eventType: 'epcis.ObjectEvent',
+    data: { epcList: [epc], bizStep: 'receiving', action: 'ADD', disposition: 'sellable_accessible', eventTime: AT_36 }
+  }
+  const commissioning = {
+    eventType: 'epcis.ObjectEvent',
+    data: { epcList: [epc], bizStep: 'commissioning', action: 'OBSERVE', disposition: 'reserved', eventTime: AT_36 }
+  }
+
+  assert.notEqual(factIdentity(receiving), factIdentity(commissioning), '입고와 개시가 한 사실이 됐다')
+})
+
+test('★ 참조가 달라도 갈린다 — 주체만 보고 나머지를 버리지 않는다', () => {
+  /*
+   * 「주체를 먼저 본다」는 판단 자체는 옳았다. 틀린 것은 **고르고 나머지를 버린 것**이다.
+   */
+  const one = { eventType: 'task.status', data: { taskId: 'T-1', orderId: 'order-1', at: AT_36 } }
+  const two = { eventType: 'task.status', data: { taskId: 'T-1', orderId: 'order-2', at: AT_36 } }
+
+  assert.notEqual(factIdentity(one), factIdentity(two))
+})
+
+test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
+  /* 가르는 값이 하나도 없으면 정체를 안 만든다(거르지 않고 통과) — 그 경계가 살아 있는지. */
+  assert.equal(factIdentity({ eventType: 'x', data: { at: AT_36 } }), undefined, '대상 없는 봉투에 정체를 만들었다')
+  assert.equal(factIdentity({ eventType: 'x', data: { taskId: 'T-1' } }), undefined, '시각 없는 봉투에 정체를 만들었다')
+  assert.ok(factIdentity(quality('T-1', 1))!.includes('task=T-1'), '작업이 정체에 안 들어갔다')
+})

package/test/ingest-reconcile-four-ways.test.ts

@@ -0,0 +1,97 @@
+/*
+ * ★ **셈이 닫혀야 한다** — 두 갈래로는 큰 수가 「사라졌다」로 떠 있게 된다.
+ *
+ * ── 실측 (2026-09-05, 인티그레이션·plant 레인) ─────────────────────────────
+ * plant 아웃박스와 저널을 손으로 맞춰 보니 정확히 닫혔다.
+ *
+ *   나간 것 157 = 앉은 것 46 + 거절 2 + 어휘 1 + 되풀이 108
+ *
+ * 되풀이 108은 하네스가 같은 실적을 같은 시각으로 다시 보낸 것이고 **합친 것이 옳은 거동**이다.
+ * 어휘 1은 저널에 안 가는 것이 옳다(시각축이 없다).
+ *
+ * ── 왜 두 갈래로는 안 되나 ────────────────────────────────────────────────
+ *   두 갈래   157 − 46 − 2 = 109 「설명 못 함」
+ *   네 갈래   157 − 46 − 2 − 108 − 1 = 0
+ *
+ * **109 를 「사라졌다」로 내면 그날부터 아무도 그 수를 안 본다.** 늘 큰 수가 떠 있으면 진짜로 하나
+ * 사라진 날을 못 본다 — 오늘 이 저장소에서 「늘 참인 경고는 벽지가 된다」로 여러 번 나온 것이다.
+ *
+ * ── 그리고 되풀이 108은 잰 값이 아니었다 ──────────────────────────────────
+ * 뺄셈으로만 구할 수 있었다. 어휘 항이 없어서다. 그 뺄셈을 코드가 하려면 넷이 다 있어야 한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  newIngestLedger,
+  recordIngest,
+  recordDuplicates,
+  recordVocabulary,
+  recordJournalWrite
+} from '../server/engine/ingest-health.js'
+
+const T0 = 1_757_000_000_000
+
+test('★ 넷을 다 세면 셈이 0으로 닫힌다 — 실측한 그 수로', () => {
+  const ledger = newIngestLedger()
+
+  /* 나간 것 157 · 거절 2 */
+  recordIngest(ledger, 157, [{ errors: ['x'] }, { errors: ['y'] }], T0)
+  /* 저널에 앉은 것 46 */
+  recordJournalWrite(ledger, 46, T0)
+  /* 합친 것 108 */
+  recordDuplicates(ledger, 108, T0)
+  /* 저널에 안 가는 어휘 1 */
+  recordVocabulary(ledger, 1)
+
+  const w = ledger.window
+  const unexplained = w.offered - w.rows - w.rejected - ledger.duplicates - w.vocabulary
+
+  assert.equal(unexplained, 0, `설명 못 한 것이 ${unexplained} 남았다 — 셈이 안 닫힌다`)
+})
+
+test('★ 어휘 항이 없으면 그 수가 「사라졌다」로 남는다 — 이 항의 존재 이유', () => {
+  const ledger = newIngestLedger()
+  recordIngest(ledger, 20, undefined, T0)
+  recordJournalWrite(ledger, 17, T0)
+  recordVocabulary(ledger, 1)
+
+  const w = ledger.window
+  /* 어휘를 안 빼면 셋이 빈 것으로 보인다 — 실제로 사라진 것은 둘이다. */
+  assert.equal(w.offered - w.rows, 3, '실측 상황을 못 만들고 있다')
+  assert.equal(w.offered - w.rows - w.vocabulary, 2, '어휘를 빼도 수가 안 맞는다')
+})
+
+test('★ 어휘는 저널 수에 안 들어간다 — 두 번 세면 셈이 음수가 된다', () => {
+  const ledger = newIngestLedger()
+  recordIngest(ledger, 1, undefined, T0)
+  recordVocabulary(ledger, 1)
+
+  assert.equal(ledger.window.rows, 0, '어휘가 저널 수에 섞였다')
+  assert.equal(ledger.window.vocabulary, 1)
+})
+
+test('★ 창이 갈리면 각 창이 자기 어휘를 든다 — 누적으로 비교하면 안 된다', () => {
+  /*
+   * 인티그레이션 레인이 짚은 것: `mes-line-a` 가 커서 48 · 저널 11 인데 결함이 아니다(그 사이
+   * 저널을 비웠다). **창 단위로** 맞춰야 한다.
+   */
+  const ledger = newIngestLedger()
+  recordIngest(ledger, 5, undefined, T0)
+  recordVocabulary(ledger, 2)
+  assert.equal(ledger.window.vocabulary, 2)
+
+  /* 창을 넘긴다 — 새 창은 0에서 시작한다. */
+  recordIngest(ledger, 5, undefined, T0 + 700_000)
+  assert.equal(ledger.window.vocabulary, 0, '새 창이 앞 창의 어휘를 물고 왔다')
+  assert.equal(ledger.vocabulary, 2, '누적은 남아야 한다')
+})
+
+test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
+  const ledger = newIngestLedger()
+  assert.equal(ledger.window.vocabulary, 0, '새 창에 그 항이 없다')
+  recordVocabulary(ledger, 0)
+  assert.equal(ledger.vocabulary, 0, '0을 세었다 — 모르면 안 적는다')
+  recordVocabulary(ledger, -3)
+  assert.equal(ledger.vocabulary, 0, '음수를 세었다')
+})

package/test/ingest-rules-header.test.ts

@@ -0,0 +1,100 @@
+/*
+ * 트윈의 고정 유입 규칙이 **표준 헤더 필드를 세 갈래 모두에서** 통과시키나.
+ *
+ * ── 왜 필요한가 (2026-09-07) ────────────────────────────────────────────────
+ * 같은 결함이 이 저장소에서 네 번 났고, 네 번 다 **층이 달랐다.**
+ *
+ * ```
+ * 1  EpcisHeaderOptions 에 칸이 없다        objectEvent 만 자기 인자로 갖고 있었다
+ * 2  매핑 스펙에 칸이 없다                  커넥터가 선언할 자리가 없었다
+ * 3  이 파일의 규칙 셋에 칸이 없다           선언해도 여기서 사라졌다
+ * 4  받는 쪽                                — 이건 처음부터 서 있었다
+ * ```
+ *
+ * 세 층이 각각 새는 자리였고, **아래 두 층을 고친 뒤에도 위층에서 계속 사라졌다.** 계약을 열고
+ * 「됐다」고 한 것이 아니라 인티그레이션 레인이 이 규칙 그대로 `mapRecord` 를 돌려 봐서 찾았다.
+ *
+ * 그래서 이 시험은 **계약이 아니라 이 파일의 규칙**을 돌린다. 계약 쪽 시험이 초록이어도 여기서
+ * 사라질 수 있다는 것이 오늘 실제로 일어난 일이다.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { mapRecordChecked } from '@operato/ops-contract'
+
+import { canonicalRulesForTest } from '../server/engine/canonical-ingest.js'
+
+const AT = '2026-09-07T02:00:00.000Z'
+
+/** 세 갈래가 각자 성립하는 최소 레코드 — 헤더 값은 같은 것을 싣는다. */
+const HEADER = {
+  bizStep: 'urn:epcglobal:cbv:bizstep:storing',
+  disposition: 'urn:epcglobal:cbv:disp:in_progress',
+  readPoint: 'urn:epc:id:sgln:0614141.00001.0',
+  bizLocation: 'urn:epc:id:sgln:0614141.00002.0',
+  bizTransactionList: [{ type: 'urn:epcglobal:cbv:btt:po', bizTransaction: 'urn:epcglobal:cbv:bt:0614141:order-33' }],
+  errorDeclaration: { declarationTime: AT, reason: 'urn:epcglobal:cbv:er:incorrect_data' }
+}
+
+const RECORDS: { sourceType: string; record: Record<string, unknown> }[] = [
+  { sourceType: 'twin', record: { ...HEADER, action: 'OBSERVE', epc: 'urn:epc:id:sgtin:0614141.107346.2018' } },
+  {
+    sourceType: 'twin-transformation',
+    record: {
+      ...HEADER,
+      inputEPCList: ['urn:epc:id:sgtin:0614141.107346.1000'],
+      outputEPCList: ['urn:epc:id:sgtin:0614141.107346.2000'],
+      transformationID: 'urn:uuid:11111111-2222-3333-4444-555555555555'
+    }
+  },
+  {
+    sourceType: 'twin-aggregation',
+    record: { ...HEADER, action: 'ADD', parentID: 'urn:epc:id:sscc:0614141.1234567890', childEPCs: ['urn:epc:id:sgtin:0614141.107346.2018'] }
+  }
+]
+
+function mapWith(sourceType: string, record: Record<string, unknown>): any {
+  const rule = canonicalRulesForTest().find(r => r.sourceType === sourceType)
+
+  assert.ok(rule, `${sourceType} 규칙이 없다 — 갈래가 사라졌다`)
+
+  return mapRecordChecked(record as any, rule!.mapping as any, AT)
+}
+
+test('규칙이 셋이다 — 갈래가 줄면 그 사실이 조용히 사라진다', () => {
+  assert.deepEqual(
+    canonicalRulesForTest().map(r => r.sourceType).sort(),
+    ['twin', 'twin-aggregation', 'twin-transformation']
+  )
+})
+
+for (const { sourceType, record } of RECORDS) {
+  test(`${sourceType} 이 오더 참조를 커널까지 넘긴다 — 이 파일에서 사라지던 자리다`, () => {
+    const { event, errors } = mapWith(sourceType, record)
+
+    assert.deepEqual(errors, [], `${sourceType}: 성립하는 레코드인데 오류가 났다`)
+    assert.deepEqual(
+      event.bizTransactionList,
+      HEADER.bizTransactionList,
+      `${sourceType}: 오더 참조가 사라졌다 — 커넥터가 실어도 저널의 biz_transaction 이 빈다`
+    )
+  })
+
+  test(`${sourceType} 이 나머지 헤더 필드도 함께 넘긴다 — 하나만 보면 다음 것이 또 샌다`, () => {
+    const { event } = mapWith(sourceType, record)
+
+    assert.equal(event.bizStep, HEADER.bizStep)
+    assert.equal(event.disposition, HEADER.disposition)
+    assert.equal(event.readPoint?.id, HEADER.readPoint)
+    assert.equal(event.bizLocation?.id, HEADER.bizLocation)
+    assert.equal(event.errorDeclaration?.declarationTime, AT)
+  })
+}
+
+test('오더 참조를 안 실으면 그 칸을 만들지 않는다 — 빈 배열은 「참조가 없다」와 다르다', () => {
+  const { bizTransactionList: _drop, ...bare } = RECORDS[0].record
+  const { event, errors } = mapWith('twin', bare)
+
+  assert.deepEqual(errors, [])
+  assert.equal('bizTransactionList' in event, false)
+})

package/test/ingest-window-rolls-unobserved.test.ts

@@ -0,0 +1,72 @@
+/*
+ * ★ **보는 사람이 없어도 창이 닫힌다** — 아무도 안 보는 트윈일수록 기록이 없었다.
+ *
+ * ── 실측 (2026-09-05) ──────────────────────────────────────────────────────
+ *   mes-miratek   사실 46건 · 62분에 흩어짐   창  1개
+ *   mes-line-a    사실 11건                   창 48개
+ *
+ * **사실 수와 창 수가 거꾸로다.** 창은 「다음 사건이 왔을 때」와 「누가 물어볼 때」만 굴렀고,
+ * `ingestHealthOf()` 가 굴리는 쪽이 실제로 창을 만들고 있었다 — 점검표·화면이 계속 묻는 트윈만
+ * 기록이 쌓였다.
+ *
+ * 그래서 **아무도 안 보는 트윈일수록 기록이 없었다.** 사실이 조용히 사라지는 것을 잡으려고 만든
+ * 장부가 정확히 그 반대로 돌았다. 실제로 137봉투가 장부 없이 지나갔다(인티그레이션 레인 실측).
+ *
+ * ── 왜 주기인가 ────────────────────────────────────────────────────────────
+ * 창이 닫히는 이유는 **시간이 지난 것**이다. 사건도 질의도 그것을 알려 주는 신호일 뿐이고 둘 다
+ * 안 올 수 있다. 시간은 늘 지나므로 주기가 그 사실에 맞는 신호다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { INGEST_WINDOW_MS, newIngestLedger, recordJournalWrite, rollIngestWindow } from '../server/engine/ingest-health.js'
+
+const T0 = 1_757_000_000_000
+
+test('★ 사건도 질의도 없이 시간만 지나면 창이 닫힌다', () => {
+  const ledger = newIngestLedger()
+  const closed: any[] = []
+
+  /* 사실 하나가 들어와 창이 열린다. */
+  recordJournalWrite(ledger, 1, T0, w => closed.push(w))
+  assert.equal(closed.length, 0, '열리자마자 닫히면 안 된다')
+
+  /* 그 뒤로 아무 일도 없다 — 주기만 온다. */
+  rollIngestWindow(ledger, T0 + INGEST_WINDOW_MS + 1, INGEST_WINDOW_MS, w => closed.push(w))
+
+  assert.equal(closed.length, 1, '시간이 지났는데 창이 안 닫혔다 — 기록이 안 남는다')
+  assert.equal(closed[0].rows, 1, '닫힌 창이 그 사실을 안 들었다')
+})
+
+test('★ 창 길이 전에는 안 닫는다 — 주기가 창을 잘게 쪼개면 안 된다', () => {
+  const ledger = newIngestLedger()
+  const closed: any[] = []
+  recordJournalWrite(ledger, 1, T0)
+
+  /* 주기(30초)가 창 길이(10분)보다 짧다 — 여러 번 와도 안 닫혀야 한다. */
+  for (let i = 1; i <= 10; i++) rollIngestWindow(ledger, T0 + i * 30_000, INGEST_WINDOW_MS, w => closed.push(w))
+
+  assert.equal(closed.length, 0, `주기가 창을 ${closed.length}개로 쪼갰다`)
+})
+
+test('★ 조용한 구간도 창으로 남는다 — expected-quiet 판정이 그 기록 위에 선다', () => {
+  /*
+   * 사실이 하나도 안 온 구간이 표에 남아야 「조용한 것이 정상인가」를 판정할 수 있다. 그 구간이
+   * 아예 기록되지 않으면 조용함과 기록 없음이 구별되지 않는다.
+   */
+  const ledger = newIngestLedger()
+  const closed: any[] = []
+  recordJournalWrite(ledger, 1, T0, w => closed.push(w))
+
+  /* 두 창을 통째로 건너뛴다 — 그 사이 아무 사실도 없었다. */
+  rollIngestWindow(ledger, T0 + INGEST_WINDOW_MS * 2 + 1, INGEST_WINDOW_MS, w => closed.push(w))
+
+  assert.ok(closed.length >= 1, '건너뛴 구간이 하나도 안 남았다')
+})
+
+test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
+  assert.ok(INGEST_WINDOW_MS > 0, `창 길이가 ${INGEST_WINDOW_MS} 다`)
+  const ledger = newIngestLedger()
+  recordJournalWrite(ledger, 3, T0)
+  assert.equal(ledger.window.rows, 3, '장부가 사실을 안 세고 있다 — 이 검사가 아무것도 안 잰다')
+})