@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/ingest-history.test.ts

@@ -1,247 +0,0 @@
-/*
- * ★ 인제스트 이력 — **재기동 뒤에도 추이가 이어진다.**
- *
- * ── 무엇이 미완이었나 (2026-08-20) ──────────────────────────────────────────
- * 닫힌 창을 표로 남기기 시작했는데 **읽는 코드가 없었다.** 21행이 쌓여 있고 아무도 보지 않았다 —
- * 이 프로젝트가 결함으로 보는 상태다(「필드만 만들고 아무도 읽지 않는다」). 표를 만든 이유가
- * 「메모리 장부는 재기동에 사라지고 6시간까지인데 추이는 그보다 오래 봐야 한다」였으니 목적이
- * 절반만 서 있었다.
- *
- * ── 지키는 것 ───────────────────────────────────────────────────────────────
- * ① 표와 메모리를 이어 붙이되 **겹친 창을 두 번 내지 않는다** — 같은 구간이 두 번 그려지면 추이가
- *    거짓이 된다. 겹치면 메모리 쪽을 쓴다(같은 사실의 원본이다).
- * ② 어디서부터 메모리인지 밝힌다(`liveFrom`) — 화면이 근거를 말할 수 있게. 재기동 직후에는 `null`
- *    이고, 그때 보이는 것은 전부 표에서 온 것이다.
- * ③ **알리지 않고 자르지 않는다** — 상한에서 밀려난 창 수와, 물은 기간이 잘렸다는 사실을 함께 낸다.
- * ④ 남의 도메인·남의 트윈의 창을 집지 않는다.
- * ⑤ 제시가 0 인 창의 통과율은 `null` 이다 — 빈 창은 완벽한 창이 아니다.
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import type { DataSource } from 'typeorm'
-
-const req = createRequire(import.meta.url)
-const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
-const { entities: authEntities } = req('@things-factory/auth-base')
-const { entities: twinEntities } = req('../dist-server/service/index.js')
-const { TwinEngine } = req('../dist-server/engine/index.js')
-const { INGEST_WINDOW_MS } = req('../dist-server/engine/ingest-health.js')
-const { TwinIngestWindow } = req('../dist-server/service/twin-ingest-window/twin-ingest-window.js')
-const { TwinIngestWindowQuery, HISTORY_WINDOW_LIMIT, HISTORY_HOURS_MAX } = req(
-  '../dist-server/service/twin-ingest-window/twin-ingest-window-query.js'
-)
-const { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-let otherDomainId: string
-
-const TWIN = 'hist-twin'
-const HOUR = 3_600_000
-
-const resolver = new TwinIngestWindowQuery()
-const ask = (instanceId: string, hours?: number, domain = domainId) =>
-  resolver.twinIngestHistory(instanceId, hours, { state: { domain: { id: domain } } } as any)
-
-/** 표에 닫힌 창 하나 — 시각은 「몇 시간 전」으로 준다. */
-async function storedWindow(instanceId: string, hoursAgo: number, offered: number, rejected = 0, domain = domainId) {
-  const closed = new Date(Date.now() - hoursAgo * HOUR)
-  const opened = new Date(closed.getTime() - 600_000)
-  const repo = ds.getRepository(TwinIngestWindow)
-  await repo.save(
-    repo.create({
-      domain: { id: domain } as any,
-      instanceId,
-      openedAt: opened,
-      closedAt: closed,
-      offered,
-      rejected,
-      undelivered: 0,
-      journaledRows: 0,
-      journalFlushes: 0,
-      ...(offered > 0 ? { acceptedRatio: (offered - rejected) / offered } : {})
-    } as any)
-  )
-  return opened.toISOString()
-}
-
-async function instance(instanceId: string, domain = domainId) {
-  const repo = ds.getRepository(TwinInstance)
-  await repo.save(
-    repo.create({
-      domain: { id: domain } as any,
-      instanceId,
-      spaceId: 'hist-space',
-      kind: 'wms',
-      status: 'stopped',
-      restartPolicy: 'reset',
-      purpose: 'operational'
-    } as any)
-  )
-}
-
-before(async () => {
-  ds = new TypeOrmDataSource({
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    namingStrategy: new NamingStrategy(),
-    entities: [...shellEntities, ...authEntities, ...twinEntities],
-    logging: false
-  })
-  await ds.initialize()
-  addDataSource('default', ds)
-
-  domainId = (await ds.getRepository(Domain).save({ name: 'hist', subdomain: 'hist' } as any)).id
-  otherDomainId = (await ds.getRepository(Domain).save({ name: 'hist-other', subdomain: 'hist-other' } as any)).id
-  await instance(TWIN)
-})
-
-after(async () => {
-  await ds?.destroy()
-})
-
-test('표에 남은 창을 읽어 온다 — 재기동으로 메모리가 비어도 추이가 있다', async () => {
-  await storedWindow(TWIN, 5, 100, 4)
-  await storedWindow(TWIN, 3, 200, 0)
-
-  const r = await ask(TWIN)
-  assert.equal(r.windows.length, 2)
-  assert.equal(r.storedCount, 2)
-  assert.equal(r.liveCount, 0, '메모리에는 닫힌 창이 없다(이 트윈은 이 프로세스에서 받은 적이 없다)')
-  assert.equal(r.liveFrom, null, '그래서 「여기서부터 메모리」가 없다 — 0 이나 지금으로 채우지 않는다')
-})
-
-test('오래된 것이 앞, 최신이 뒤 — 추이는 시간순이어야 그림이 된다', async () => {
-  const r = await ask(TWIN)
-  const times = r.windows.map((w: any) => Date.parse(w.from))
-  assert.deepEqual(times, [...times].sort((a, b) => a - b), '오름차순')
-})
-
-test('통과는 트윈에 닿은 것만 — 표의 통과율을 그대로 쓴다', async () => {
-  const r = await ask(TWIN)
-  const w = r.windows.find((x: any) => x.offered === 100)
-  assert.equal(w.rejected, 4)
-  assert.equal(w.accepted, 96)
-  assert.equal(w.acceptedRatio, 0.96)
-})
-
-test('제시가 0 인 창의 통과율은 「없음」이다 — 빈 창은 완벽한 창이 아니다', async () => {
-  await storedWindow(TWIN, 2, 0, 0)
-
-  const r = await ask(TWIN)
-  const empty = r.windows.find((x: any) => x.offered === 0)
-  assert.equal(empty.acceptedRatio, null)
-})
-
-test('물은 기간 밖의 창은 오지 않는다', async () => {
-  await storedWindow(TWIN, 40, 999, 0) // 40시간 전
-
-  const r = await ask(TWIN, 24)
-  assert.ok(
-    !r.windows.some((w: any) => w.offered === 999),
-    '24시간을 물었으면 40시간 전 창은 안 온다'
-  )
-
-  const wide = await ask(TWIN, 48)
-  assert.ok(
-    wide.windows.some((w: any) => w.offered === 999),
-    '48시간을 물으면 온다'
-  )
-})
-
-test('기간 상한을 넘겨 물으면 자르고, 자른 사실을 낸다', async () => {
-  const r = await ask(TWIN, HISTORY_HOURS_MAX + 100)
-
-  assert.equal(r.hours, HISTORY_HOURS_MAX, '상한까지만 본다')
-  assert.equal(r.hoursClamped, HISTORY_HOURS_MAX + 100, '얼마를 물었는지 밝힌다 — 알리지 않고 자르지 않는다')
-})
-
-test('상한 안에서는 잘렸다고 말하지 않는다 — 없는 문제를 만들지 않는다', async () => {
-  const r = await ask(TWIN, 24)
-  assert.equal(r.hoursClamped, undefined)
-  assert.equal(r.storedDropped, 0)
-})
-
-test('창 수 상한에서 밀려난 수를 센다', async () => {
-  const many = 'hist-many'
-  await instance(many)
-  /* 상한 + 5개를 심는다. 10분 간격이므로 상한을 넘기려면 그만큼의 창이 필요하다. */
-  for (let i = 0; i < HISTORY_WINDOW_LIMIT + 5; i++) await storedWindow(many, 1 + i * 0.01, 10, 0)
-
-  const r = await ask(many, HISTORY_HOURS_MAX)
-  assert.equal(r.windows.length, HISTORY_WINDOW_LIMIT, '상한까지만 낸다')
-  assert.equal(r.storedDropped, 5, '밀려난 수를 말한다')
-})
-
-test('남의 도메인 창을 집지 않는다', async () => {
-  await instance('hist-shared', otherDomainId)
-  await storedWindow('hist-shared', 1, 777, 0, otherDomainId)
-
-  /* 같은 instanceId 를 내 도메인에서 물어도 남의 창이 오면 안 된다. */
-  await instance('hist-shared')
-  const mine = await ask('hist-shared')
-  assert.ok(
-    !mine.windows.some((w: any) => w.offered === 777),
-    '남의 도메인 창이 새지 않는다'
-  )
-})
-
-test('내 도메인에 없는 트윈은 「없음」이다 — 남의 것이라 말하지 않는다', async () => {
-  assert.equal(await ask('does-not-exist'), null)
-})
-
-test('겹친 창을 두 번 내지 않는다 — 같은 구간이 두 번 그려지면 추이가 거짓이 된다', async () => {
-  /*
-   * 프로세스가 살아 있는 동안 닫힌 창은 **표와 메모리에 둘 다** 있다(영속 훅이 창이 닫힐 때 쓴다).
-   * 정리하지 않으면 그 구간이 추이에 두 번 들어가 유입이 두 배로 보인다.
-   */
-  const twin = 'hist-overlap'
-  await instance(twin)
-
-  /* 메모리에 닫힌 창 하나를 만든다 — 창은 다음 유입이 있을 때 닫힌다. */
-  const t0 = Date.now() - Math.floor(INGEST_WINDOW_MS * 1.4)
-  TwinEngine.recordIngestResult(domainId, twin, 50, [], t0)
-  TwinEngine.recordIngestResult(domainId, twin, 1, [], t0 + INGEST_WINDOW_MS + 1)
-
-  const live = TwinEngine.ingestHealthOf(domainId, twin).trend
-  assert.equal(live.length, 1, '메모리에 닫힌 창 하나')
-
-  /* 같은 창을 표에도 심는다(영속 훅이 했을 일). 값은 일부러 다르게 두어 어느 쪽이 이겼는지 본다. */
-  const repo = ds.getRepository(TwinIngestWindow)
-  await repo.save(
-    repo.create({
-      domain: { id: domainId } as any,
-      instanceId: twin,
-      openedAt: new Date(Date.parse(live[0].from)),
-      closedAt: new Date(Date.parse(live[0].to)),
-      offered: 999,
-      rejected: 0,
-      undelivered: 0,
-      journaledRows: 0,
-      journalFlushes: 0,
-      acceptedRatio: 1
-    } as any)
-  )
-
-  const r = await ask(twin)
-  const sameStart = r.windows.filter((w: any) => Date.parse(w.from) === Date.parse(live[0].from))
-  assert.equal(sameStart.length, 1, '한 번만 낸다')
-  assert.equal(sameStart[0].source, 'live', '겹치면 메모리 쪽 — 같은 사실의 원본이다')
-  assert.equal(sameStart[0].offered, 50, '표의 999 가 아니라 메모리의 50')
-  assert.equal(r.liveFrom, live[0].from, '어디서부터 메모리인지 밝힌다')
-})
-
-test('겹치지 않는 표의 창은 메모리 앞에 이어 붙는다', async () => {
-  const twin = 'hist-overlap'
-  /* 메모리 창보다 오래된 것 — 이건 표에서만 온다. */
-  await storedWindow(twin, 6, 30, 1)
-
-  const r = await ask(twin)
-  assert.equal(r.windows.length, 2, '표 하나 + 메모리 하나')
-  assert.equal(r.windows[0].source, 'stored', '오래된 것이 앞')
-  assert.equal(r.windows[1].source, 'live')
-})

package/test/ingest-idempotent.test.ts

@@ -1,211 +0,0 @@
-/*
- * ★ 같은 사실을 두 번 받으면 한 번만 반영한다.
- *
- * ── 왜 이것이 핵심인가 (2026-08-26 · 사용자) ─────────────────────────────────
- * 「웹훅 이벤트이건 폴링 데이터이건 아이뎀포턴트를 유지할 수 있도록 로직을 세우는 것」이 핵심이다.
- * 그것이 서면 가져오는 방식이 무엇이든 트윈이 안전하고, 커넥터마다 각자 조심하지 않아도 된다.
- *
- * ── 무엇이 났나 ─────────────────────────────────────────────────────────────
- * 지금까지 중복은 커넥터마다 각자 막았다. 태양광 커넥터가 10초마다 물으면서 10분마다 바뀌는 값을 매번
- * 다시 보냈고, 한 주기에 76건이 되풀이됐다(커넥터를 고쳐 2건이 됐다). 다음 커넥터가 잊으면 또 난다.
- * 밀어 주는 방식으로 받으면 더 자주 난다 — 재전송이 정상이다.
- *
- * ── 정체를 무엇으로 보나 ────────────────────────────────────────────────────
- * 봉투의 `eventId` 로는 판단할 수 없다. 보낸 쪽이 매번 새로 만드는 순번이고, 호출마다 1부터 다시
- * 시작한다. 그래서 사실 자체로 판단한다 — 대상 · 사건 종류 · 연결된 시스템이 준 시각.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { factIdentity, FactDeduper } from '../server/engine/ingest-dedupe.js'
-
-const at = '2026-08-26T00:00:00.000Z'
-
-const energy = (equipmentId: string, kWh: number, when = at, eventId = 'x') => ({
-  eventId,
-  eventType: 'energy.generated',
-  eventTime: when,
-  tenantId: 't',
-  data: { equipmentId, kWh, at: when }
-})
-
-const status = (moverId: string, s: string, when = at) => ({
-  eventId: `s-${moverId}`,
-  eventType: 'equipment.status',
-  eventTime: when,
-  tenantId: 't',
-  data: { moverId, kind: 'pv-array', status: s, at: when }
-})
-
-test('★ 같은 사실이 두 번 오면 한 번만 지난다 — 보낸 쪽이 되풀이 보내도 트윈이 틀리지 않는다', () => {
-  const d = new FactDeduper()
-  const { fresh, duplicates } = d.filter([energy('inv-1', 574.8), energy('inv-1', 574.8)])
-  assert.equal(fresh.length, 1)
-  assert.equal(duplicates, 1)
-})
-
-test('★ 봉투의 순번이 달라도 같은 사실이면 한 번이다 — eventId 로는 판단할 수 없다', () => {
-  /* 같은 측정을 두 번 보내면 보낸 쪽이 새 순번을 붙인다. 그것으로 판단하면 중복을 못 잡는다. */
-  const d = new FactDeduper()
-  const { fresh, duplicates } = d.filter([energy('inv-1', 574.8, at, 't-energy-1'), energy('inv-1', 574.8, at, 't-energy-2')])
-  assert.equal(fresh.length, 1)
-  assert.equal(duplicates, 1)
-})
-
-test('★ 다른 사실은 지난다 — 대상이 다르면 다른 사실이다', () => {
-  const d = new FactDeduper()
-  const { fresh, duplicates } = d.filter([energy('inv-1', 574.8), energy('inv-2', 577.2)])
-  assert.equal(fresh.length, 2)
-  assert.equal(duplicates, 0)
-})
-
-test('★ 잰 시각이 나아가면 다른 사실이다 — 그것이 새 측정이다', () => {
-  const d = new FactDeduper()
-  const { fresh } = d.filter([energy('inv-1', 574.8, at), energy('inv-1', 580.1, '2026-08-26T00:10:00.000Z')])
-  assert.equal(fresh.length, 2)
-})
-
-test('★ 사건 종류가 다르면 다른 사실이다 — 같은 설비의 같은 시각이어도', () => {
-  const d = new FactDeduper()
-  const { fresh } = d.filter([energy('inv-1', 574.8), status('inv-1', 'busy')])
-  assert.equal(fresh.length, 2)
-})
-
-test('★ 정체를 알 수 없으면 거르지 않는다 — 모르는 것을 같다고 하면 다른 사실이 하나로 합쳐진다', () => {
-  const d = new FactDeduper()
-  const noTarget = { eventId: 'a', eventType: 'energy.demand.window', eventTime: at, tenantId: 't', data: { maxKW: 3 } }
-  const noTime = { eventId: 'b', eventType: 'equipment.status', tenantId: 't', data: { moverId: 'inv-9', status: 'idle' } }
-  assert.equal(factIdentity(noTarget), undefined)
-  assert.equal(factIdentity(noTime), undefined)
-  const { fresh, duplicates } = d.filter([noTarget, noTarget, noTime, noTime])
-  assert.equal(fresh.length, 4, '거르지 않고 통과시킨다')
-  assert.equal(duplicates, 0)
-})
-
-test('★ 늦게 도착한 옛 사실은 버리지 않는다 — 그것이 왔다는 것도 사실이다', () => {
-  /*
-   * 상태에 반영하지 않는 판단은 커널이 한다(시각 비교). 여기서 버리면 지난 기록에서 사라지고,
-   * 「늦게 왔다」는 사실 자체를 아무도 알 수 없게 된다.
-   */
-  const d = new FactDeduper()
-  const { fresh, duplicates } = d.filter([
-    energy('inv-1', 580.1, '2026-08-26T00:10:00.000Z'),
-    energy('inv-1', 574.8, at)
-  ])
-  assert.equal(fresh.length, 2)
-  assert.equal(duplicates, 0)
-})
-
-test('★ 창을 넘으면 잊는다 — 전부 기억할 수는 없다', () => {
-  const window = FactDeduper.WINDOW
-  try {
-    FactDeduper.WINDOW = 3
-    const d = new FactDeduper()
-    d.filter([energy('inv-1', 1, '2026-08-26T00:00:00.000Z')])
-    d.filter([
-      energy('inv-1', 2, '2026-08-26T00:01:00.000Z'),
-      energy('inv-1', 3, '2026-08-26T00:02:00.000Z'),
-      energy('inv-1', 4, '2026-08-26T00:03:00.000Z')
-    ])
-    /* 첫 사실은 창 밖으로 밀려났으므로 다시 오면 통과한다 — 그 사실을 시험으로 못 박는다. */
-    const { duplicates } = d.filter([energy('inv-1', 1, '2026-08-26T00:00:00.000Z')])
-    assert.equal(duplicates, 0)
-    assert.ok(d.size() <= 3)
-  } finally {
-    FactDeduper.WINDOW = window
-  }
-})
-
-test('버린 수를 함께 낸다 — 알리지 않고 버리지 않는다', () => {
-  const d = new FactDeduper()
-  const same = [energy('inv-1', 1), energy('inv-1', 1), energy('inv-1', 1), energy('inv-2', 2)]
-  const { fresh, duplicates } = d.filter(same)
-  assert.equal(fresh.length, 2)
-  assert.equal(duplicates, 2)
-})
-
-test('트윈마다 따로 센다 — 한 트윈의 되풀이가 다른 트윈을 막지 않는다', () => {
-  const a = new FactDeduper()
-  const b = new FactDeduper()
-  a.filter([energy('inv-1', 1)])
-  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

@@ -1,97 +0,0 @@
-/*
- * ★ **셈이 닫혀야 한다** — 두 갈래로는 큰 수가 「사라졌다」로 떠 있게 된다.
- *
- * ── 실측 (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

@@ -1,100 +0,0 @@
-/*
- * 트윈의 고정 유입 규칙이 **표준 헤더 필드를 세 갈래 모두에서** 통과시키나.
- *
- * ── 왜 필요한가 (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)
-})