@things-factory/headless-twin 10.1.277 → 10.1.279

package/test/sweep-dispatch.test.ts

@@ -1,191 +0,0 @@
-/*
- * ★ **그물이 실제로 줍는가** — 배선.
- *
- * 판단은 순수 함수가 지킨다(`retry-plan.test.ts`). 여기서 보는 것은 **그 답이 실제 경로에 서
- * 있는가**다: 표를 읽었나, 어댑터를 불렀나, 시도 횟수와 다음 시각을 적었나, 한 조치가 터져도
- * 다음을 보나.
- *
- * 이 저장소에서 가장 자주 나는 결함이 「자리는 있고 길이 없다」이고, 오늘 하루 그 부류를 여러 번
- * 고쳤다. 그물이 그 부류로 나면 **승인된 조치가 조용히 안 나간다.**
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { sweepPendingDispatch } from '../server/service/actuation/sweep-dispatch.js'
-import type { CommandStore, StoredCommand } from '../server/service/actuation/command-dispatcher.js'
-
-const DOMAIN = 'd-1'
-const AT = '2026-09-04T02:00:00.000Z'
-
-const cmd = (over: Partial<StoredCommand> = {}): StoredCommand =>
-  ({
-    id: 'cmd-1',
-    instanceId: 'twin-a',
-    kind: 'production.release',
-    origin: 'rule',
-    state: 'approved',
-    reversible: false,
-    /* 되돌릴 수 없는 조치는 **승인 기록**이 있어야 넘어간다(§`asApproved`) — 그 모양이 이것이다. */
-    approval: { by: 'lead', at: AT },
-    ...over
-  }) as StoredCommand
-
-/**
- * 표 하나와 가짜 커넥터 — `save` 가 무엇을 적었는지 본다.
- *
- * 의존을 인자로 받는 서명이라 여기서 다 흉내낼 수 있다. 직접 부르는 서명이었을 때는 이 시험이
- * DB·모듈 부팅을 끌어와 아예 뜨지 않았다 — 그것이 이 파일을 그 모양으로 바꾼 이유다.
- */
-function bench(rows: StoredCommand[], over: Record<string, unknown> = {}) {
-  const table = new Map(rows.map(r => [r.id, { ...r }]))
-  const saves: StoredCommand[] = []
-  const store: CommandStore = {
-    load: async (_d, id) => (table.has(id) ? { ...table.get(id)! } : null),
-    save: async (_d, c) => {
-      saves.push({ ...c })
-      table.set(c.id, { ...c })
-    },
-    pendingDispatch: async () => [...table.values()]
-  } as any
-
-  const calls: string[] = []
-  const deps = {
-    store,
-    /* 어댑터가 늘 받아 준다 — 「집었나」를 보는 시험이라 저쪽 사정은 다른 파일이 지킨다. */
-    actuate: async (c: any) => {
-      calls.push(c.id)
-      return { ok: true, ref: `WO-${c.id}` }
-    },
-    idempotent: async () => false,
-    ...over
-  } as any
-  return { store, table, saves, deps, calls }
-}
-
-/* ── 첫 시도를 줍는다 ─────────────────────────────────────────────────────── */
-
-test('★ 승인만 되고 안 나간 것을 줍는다 — 승인 직후 발신이 놓친 그 창이다', async () => {
-  const { table, deps, calls } = bench([cmd()])
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-  /* 어댑터가 없으므로 `routeActuation` 이 거절한다 — 그래도 **집었다**는 것이 이 시험의 주제다. */
-  assert.equal(report.seen, 1)
-  assert.equal(table.get('cmd-1')!.state !== 'approved', true, '집지 않아 상태가 그대로다')
-})
-
-test('★ 시도 횟수와 다음 시각을 적는다 — 메모리에 두면 재기동에 사라진다', async () => {
-  const { table, deps, calls } = bench([cmd()])
-
-  await sweepPendingDispatch(DOMAIN, deps)
-  const after = table.get('cmd-1')!
-
-  assert.equal(after.attempts, 1, '첫 시도가 1로 적혀야 한다')
-  assert.ok(after.nextAttemptAt, '다음 시각이 없으면 물러섬이 재기동에 사라진다')
-  assert.ok(Date.parse(after.nextAttemptAt!) > Date.now(), '다음 시각이 과거다')
-})
-
-/* ── 집지 않는 것들 ───────────────────────────────────────────────────────── */
-
-test('★ 종착은 집지 않는다', async () => {
-  const { saves, deps } = bench([cmd({ state: 'acked', attempts: 1 })])
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.equal(report.dispatched, 0)
-  assert.equal(report.skipped['not-dispatchable'], 1)
-  assert.deepEqual(saves, [], '집지 않았는데 표를 고쳤다')
-})
-
-test('★ 어댑터가 다시 될 일인지 말하지 않았으면 집지 않는다 — 목록에 「모름」으로 남는다', async () => {
-  const { deps, store } = bench([cmd({ state: 'failed', attempts: 1, error: '저쪽이 안 받았습니다' })])
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.equal(report.skipped['outlook-unknown'], 1)
-  assert.equal(report.dispatched, 0)
-})
-
-test('★ 멱등을 선언하지 않은 커넥터는 재시도하지 않는다', async () => {
-  const { deps, store } = bench([cmd({ state: 'failed', attempts: 1, retry: 'again' })])
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.equal(report.skipped['not-idempotent'], 1)
-})
-
-test('★ 영원히 안 될 것은 집지 않는다', async () => {
-  const { deps, store } = bench([cmd({ state: 'failed', attempts: 1, retry: 'never' })])
-
-  assert.equal((await sweepPendingDispatch(DOMAIN, deps)).skipped['never'], 1)
-})
-
-test('★ 물러섬이 안 끝났으면 기다린다', async () => {
-  const later = new Date(Date.now() + 300_000).toISOString()
-  const { saves, deps } = bench([cmd({ state: 'failed', attempts: 1, retry: 'again', nextAttemptAt: later })])
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  /* 멱등 선언이 없어 그쪽에서 먼저 걸린다 — 어느 이유든 **집지 않았고 표를 안 고쳤다**가 핵심이다. */
-  assert.equal(report.dispatched, 0)
-  assert.deepEqual(saves, [])
-})
-
-/* ── 저장소가 못 내면 아무것도 하지 않는다 ──────────────────────────────── */
-
-test('★ 대기 줄을 못 내는 저장소에서는 아무것도 하지 않는다 — 옛 거동이 깨지지 않게', async () => {
-  const deps = { store: { load: async () => null, save: async () => {} }, actuate: async () => ({ ok: true }), idempotent: async () => false } as any
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.deepEqual(report, { seen: 0, dispatched: 0, skipped: {} })
-})
-
-test('★ 표 읽기가 터져도 그물이 죽지 않는다', async () => {
-  const deps = {
-    store: {
-      load: async () => null,
-      save: async () => {},
-      pendingDispatch: async () => {
-        throw new Error('DB 가 없다')
-      }
-    },
-    actuate: async () => ({ ok: true }),
-    idempotent: async () => false
-  } as any
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-  assert.equal(report.seen, 0)
-})
-
-/* ── 한 조치가 터져도 다음을 본다 ───────────────────────────────────────── */
-
-test('★ 한 조치에서 터져도 다음 조치를 본다 — 그물이 한 건에 멈추면 뒤가 다 막힌다', async () => {
-  const { deps, store } = bench([cmd({ id: 'a' }), cmd({ id: 'b' })])
-  const original = store.save
-  let first = true
-  ;(store as any).save = async (d: string, c: StoredCommand) => {
-    if (first) {
-      first = false
-      throw new Error('첫 저장이 터졌다')
-    }
-    return original!(d, c)
-  }
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.equal(report.seen, 2, '둘 다 읽었다')
-  /* 하나가 터졌어도 바퀴가 끝났다 — 던지면 이 단정에 오지 못한다. */
-  assert.ok(report.dispatched + Object.values(report.skipped).reduce((a, b) => a + b, 0) >= 1)
-})
-
-/* ── 한 바퀴 상한 ─────────────────────────────────────────────────────────── */
-
-test('★ 대기 줄이 커도 한 주기를 독차지하지 않는다', async () => {
-  const many = Array.from({ length: 120 }, (_, i) => cmd({ id: `c-${i}`, state: 'acked', attempts: 1 }))
-  const { deps, store } = bench(many)
-
-  const report = await sweepPendingDispatch(DOMAIN, deps)
-
-  assert.equal(report.seen, 120, '표는 다 읽는다')
-  assert.equal(report.skipped['not-dispatchable'], 50, '한 바퀴에 보는 것은 상한까지다')
-})

package/test/tenant-registry-db.test.ts

@@ -1,149 +0,0 @@
-/*
- * ★ 두 테넌트가 **같은 인스턴스 id** 로 각자 돈다 — 실 DB로 경계를 넘어 본다.
- *
- * ── 계기 (2026-08-06 테넌트 격리 전수 확인) ──────────────────────────────────
- * 런타임 레지스트리가 `instanceId` 하나로 키를 잡고 있었다. 그런데 DB 유일성은 `[domain, instanceId]`
- * 이고 트윈의 정체성도 그쪽이다. **충돌은 이론이 아니다** — 레퍼런스 경로가 `instanceId` 로 레퍼런스
- * 소스 이름(`sap-ewm-1710`)을 쓰고, 벤더 시스템 이름은 테넌트가 공유하는 어휘다.
- *
- * 그때 무엇이 틀렸나: `start`/`startFromRegistry` 가 **남의 런타임을 돌려주고**, `ingestLive` 는 도메인을
- * 확인하지 않아 남의 커널에 이벤트를 적용할 수 있었고, 목록의 `running` 이 남의 런타임을 봤다.
- *
- * 이 결함은 **유닛으로는 안 잡힌다** — 두 테넌트가 실제로 등록되고 각자 기동해야 드러난다. 그래서
- * 실 엔티티 sqlite 스키마 + 빌드 산출물로 경계를 넘는다(`structure-revision-db.test.ts` 와 같은 하네스).
- * **소스를 고친 뒤에는 `npm run build:server` 를 먼저 돌려야 반영된다.**
- */
-import { test, before, after, afterEach } 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 { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let alpha: string
-let beta: string
-
-/** 두 테넌트가 같은 벤더 시스템을 연결했을 때 실제로 생기는 id. */
-const SHARED_ID = 'sap-ewm-1710'
-
-const model = (): any => ({
-  spaceId: 'shared-space',
-  utcOffsetMinutes: 0,
-  locations: [
-    { id: 'dock-recv', type: 'dock', capacity: 100 },
-    { id: 'bin-1', type: 'storage', capacity: 20 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocation: 'dock-recv' }]
-})
-
-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)
-
-  const a = await ds.getRepository(Domain).save({ name: 'tenant-alpha', subdomain: 'tenant-alpha' } as any)
-  const b = await ds.getRepository(Domain).save({ name: 'tenant-beta', subdomain: 'tenant-beta' } as any)
-  alpha = a.id
-  beta = b.id
-
-  /* 두 테넌트가 **같은 id** 로 각자 프로비저닝한다 — DB 유일성이 `[domain, instanceId]` 라 허용된다. */
-  await TwinEngine.provision(alpha, SHARED_ID, 'wms', model(), 'reset')
-  await TwinEngine.provision(beta, SHARED_ID, 'wms', model(), 'reset')
-})
-
-/**
- * **스펙마다 반드시 멈춘다.** 남기면 두 가지가 따라온다: 틱 타이머 때문에 러너가 끝나지 않고, 틱이
- * 뒤늦게 오류를 내는 DB 쓰기가 teardown 이후에 도착해 `SQLITE_MISUSE` 로 스위트를 오염시킨다.
- */
-afterEach(async () => {
-  await TwinEngine.stop(alpha, SHARED_ID).catch(() => {})
-  await TwinEngine.stop(beta, SHARED_ID).catch(() => {})
-})
-
-after(async () => {
-  /* 정지 직후에도 진행 중인 쓰기가 있을 수 있다 — 커넥션을 닫기 전에 가라앉힌다. */
-  await new Promise(resolve => setTimeout(resolve, 120))
-  await ds?.destroy()
-})
-
-test('두 테넌트가 같은 id 로 프로비저닝된다 — 서로를 막지 않는다', async () => {
-  /* 예전에는 한쪽이 **떠 있으면** 다른 쪽 재프로비전이 "instance is running" 으로 막혔다(존재 노출). */
-  const listA = await TwinEngine.list(alpha)
-  const listB = await TwinEngine.list(beta)
-
-  assert.equal(listA.filter((x: any) => x.instanceId === SHARED_ID).length, 1)
-  assert.equal(listB.filter((x: any) => x.instanceId === SHARED_ID).length, 1)
-})
-
-test('한쪽만 기동하면 다른 쪽은 **정지한 것으로** 보인다 — 이 회귀가 핵심', async () => {
-  await TwinEngine.startFromRegistry(alpha, SHARED_ID)
-
-  assert.equal(TwinEngine.owns(alpha, SHARED_ID), true, 'alpha 는 자기 트윈을 갖는다')
-  assert.equal(TwinEngine.owns(beta, SHARED_ID), false, 'beta 는 기동하지 않았다')
-
-  /* 목록의 running 이 남의 런타임을 보면 안 된다 — 예전에는 beta 도 running: true 였다. */
-  const rowA = (await TwinEngine.list(alpha)).find((x: any) => x.instanceId === SHARED_ID)
-  const rowB = (await TwinEngine.list(beta)).find((x: any) => x.instanceId === SHARED_ID)
-  assert.equal(rowA.running, true)
-  assert.equal(rowB.running, false)
-})
-
-test('둘 다 기동하면 **서로 다른 런타임**이다 — 남의 것을 돌려받지 않는다', async () => {
-  const rtA = await TwinEngine.startFromRegistry(alpha, SHARED_ID)
-  const rtB = await TwinEngine.startFromRegistry(beta, SHARED_ID)
-
-  /* 예전에는 두 번째 호출이 첫 번째의 런타임을 그대로 돌려줬다(조기 반환이 id 로만 찾았다). */
-  assert.notEqual(rtA, rtB, '같은 객체를 돌려주면 두 테넌트가 한 커널을 공유한다')
-  assert.notEqual(TwinEngine.kernel(alpha, SHARED_ID), TwinEngine.kernel(beta, SHARED_ID))
-  assert.equal(rtA.domainId, alpha)
-  assert.equal(rtB.domainId, beta)
-})
-
-test('접근자가 테넌트별로 답한다 — 커널·스냅샷·런타임', async () => {
-  await TwinEngine.startFromRegistry(alpha, SHARED_ID)
-  await TwinEngine.startFromRegistry(beta, SHARED_ID)
-
-  for (const [who, other] of [
-    [alpha, beta],
-    [beta, alpha]
-  ]) {
-    assert.ok(TwinEngine.kernel(who, SHARED_ID), '자기 커널은 있다')
-    assert.notEqual(TwinEngine.kernel(who, SHARED_ID), TwinEngine.kernel(other, SHARED_ID))
-    assert.notEqual(TwinEngine.runtime(who, SHARED_ID), TwinEngine.runtime(other, SHARED_ID))
-  }
-})
-
-test('한쪽을 정지해도 다른 쪽은 계속 동작한다 — 남의 런타임을 지우지 않는다', async () => {
-  await TwinEngine.startFromRegistry(alpha, SHARED_ID)
-  await TwinEngine.startFromRegistry(beta, SHARED_ID)
-
-  await TwinEngine.stop(alpha, SHARED_ID)
-
-  assert.equal(TwinEngine.owns(alpha, SHARED_ID), false, '정지한 쪽은 사라진다')
-  assert.equal(TwinEngine.owns(beta, SHARED_ID), true, '남의 트윈은 그대로다')
-  assert.ok(TwinEngine.kernel(beta, SHARED_ID), 'beta 커널이 살아 있다')
-})
-
-test('없는 테넌트로 물으면 아무것도 주지 않는다 — 추측한 id 로 새지 않는다', async () => {
-  await TwinEngine.startFromRegistry(alpha, SHARED_ID)
-  const stranger = '99999999-9999-9999-9999-999999999999'
-
-  assert.equal(TwinEngine.owns(stranger, SHARED_ID), false)
-  assert.equal(TwinEngine.kernel(stranger, SHARED_ID), undefined)
-  assert.equal(TwinEngine.runtime(stranger, SHARED_ID), undefined)
-  assert.equal(TwinEngine.metrics(stranger, SHARED_ID), null)
-})

package/test/time-range.test.ts

@@ -1,152 +0,0 @@
-/*
- * ★ 시각축은 **두 수만 묻는다** — 저널을 다 읽어 오지 않는다.
- *
- * ── 무엇을 겪었나 (2026-08-20 실측) ─────────────────────────────────────────
- * `TwinEngine.timeRange` 는 공간의 인스턴스마다 `find()` 로 **행을 전부 엔티티로 하이드레이션**한 뒤
- * JS 에서 min/max 를 골랐다. 그런데 이 함수는 화면 상단의 컨텍스트 띠가 **4초마다** 부른다. 개발
- * 서버에서 `order-check` 한 트윈이 275,882행 · `payload` 131MB 였다 — 4초마다 그 JSON 을 전부 파싱했다.
- *
- * 결과: 프로세스 CPU 81~152%, 아무 일도 하지 않는 질의가 8~14초. JS 프로파일 상위가 TypeORM 의
- * `RelationIdLoader`·`RawSqlResultsToEntityTransformer`·`stringToSimpleJson` 이고 GC 가 16.7% 였다.
- * 트윈 틱(계기가 16%)도 저널 쓰기도 아니라 **이 읽기**였다.
- *
- * ── 이 시험이 지키는 것 ─────────────────────────────────────────────────────
- * ① 답이 맞다(공간의 모든 트윈에 걸친 min/max, 남의 공간은 안 섞인다)
- * ② 「없음」을 0 으로 떨어뜨리지 않는다(시각축이 1970년에서 시작하면 스크러버가 못 쓰게 된다)
- * ③ **행을 실어 오지 않는다** — 고친 방식이 되돌아가면(다시 `find()`) 답은 그대로 맞고 느려지기만
- *    하므로, 결과만 보는 시험으로는 회귀를 잡을 수 없다. 그래서 소스를 함께 본다.
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import { readFileSync } from 'node:fs'
-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 { TwinEvent } = req('../dist-server/service/twin-event/twin-event.js')
-const { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const SPACE = 'space-yard'
-const OTHER_SPACE = 'space-elsewhere'
-
-/** 저널 행 하나 — 시각축이 보는 것은 `eventTime` 뿐이다. */
-async function event(instanceId: string, eventTime: string | null, revision: number): Promise<void> {
-  await ds.getRepository(TwinEvent).save(
-    ds.getRepository(TwinEvent).create({
-      domain: { id: domainId } as any,
-      instanceId,
-      eventType: 'test.event',
-      revision,
-      eventTime: eventTime === null ? null : new Date(eventTime),
-      payload: { note: 'x' }
-    } as any)
-  )
-}
-
-async function instance(instanceId: string, spaceId: string): Promise<void> {
-  await ds.getRepository(TwinInstance).save(
-    ds.getRepository(TwinInstance).create({
-      domain: { id: domainId } as any,
-      instanceId,
-      spaceId,
-      kind: 'yms',
-      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)
-
-  const d = await ds.getRepository(Domain).save({ name: 'range-test', subdomain: 'range-test' } as any)
-  domainId = d.id
-})
-
-after(async () => {
-  await ds?.destroy()
-})
-
-test('공간의 여러 트윈에 걸쳐 가장 이른 것과 가장 늦은 것을 낸다', async () => {
-  await instance('yard-a', SPACE)
-  await instance('yard-b', SPACE)
-
-  /* 가장 이른 것은 b 에, 가장 늦은 것은 a 에 있다 — 한 트윈만 보면 답이 틀린다. */
-  await event('yard-a', '2026-03-01T00:00:00.000Z', 1)
-  await event('yard-a', '2026-06-30T12:00:00.000Z', 2)
-  await event('yard-b', '2026-01-15T09:00:00.000Z', 1)
-
-  const r = await TwinEngine.timeRange(domainId, SPACE)
-  assert.equal(r.minTime, '2026-01-15T09:00:00.000Z')
-  assert.equal(r.maxTime, '2026-06-30T12:00:00.000Z')
-})
-
-test('다른 공간의 저널은 섞이지 않는다 — 시각축은 그 현장의 것이다', async () => {
-  await instance('far-c', OTHER_SPACE)
-  await event('far-c', '2020-01-01T00:00:00.000Z', 1)
-  await event('far-c', '2030-01-01T00:00:00.000Z', 2)
-
-  const r = await TwinEngine.timeRange(domainId, SPACE)
-  assert.equal(r.minTime, '2026-01-15T09:00:00.000Z', '2020년이 새어 들어오지 않는다')
-  assert.equal(r.maxTime, '2026-06-30T12:00:00.000Z', '2030년도 그렇다')
-})
-
-test('시각이 빈 행이 시각축을 1970년으로 끌어내리지 않는다', async () => {
-  /* 옛 행에는 `eventTime` 이 없을 수 있다. 그것을 0 으로 읽으면 스크러버가 56년을 그린다. */
-  await event('yard-a', null, 3)
-
-  const r = await TwinEngine.timeRange(domainId, SPACE)
-  assert.equal(r.minTime, '2026-01-15T09:00:00.000Z', '빈 시각은 「없음」이고 0 이 아니다')
-})
-
-test('이벤트가 없으면 「없음」이다 — 0 이나 지금이 아니다', async () => {
-  await instance('empty-d', 'space-empty')
-
-  const r = await TwinEngine.timeRange(domainId, 'space-empty')
-  assert.equal(r.minTime, null)
-  assert.equal(r.maxTime, null)
-})
-
-test('그 공간에 트윈이 없으면 「없음」이다', async () => {
-  const r = await TwinEngine.timeRange(domainId, 'space-nobody')
-  assert.equal(r.minTime, null)
-  assert.equal(r.maxTime, null)
-})
-
-test('두 수를 구하려고 행을 실어 오지 않는다 — 되돌아가면 답은 맞고 느려지기만 한다', () => {
-  /*
-   * 결과만 보는 시험으로는 이 회귀를 잡을 수 없다(`find()` 로 돌려도 min/max 는 맞다). 그래서 함수의
-   * 소스를 본다: 집계(MIN/MAX)를 쓰고, 저널을 `find()` 로 긁지 않는다.
-   */
-  const src = readFileSync(new URL('../server/engine/twin-engine.ts', import.meta.url).pathname, 'utf-8')
-  const at = src.indexOf('static async timeRange(')
-  assert.ok(at > 0, 'timeRange 를 찾지 못했다 — 이름이 바뀌면 이 검사도 함께 옮긴다')
-
-  /* 함수 본문만 떼어 본다 — 다음 멤버 선언까지. */
-  const body = src.slice(at, src.indexOf('\n  /** 정지 훅', at) > 0 ? src.indexOf('\n  /** 정지 훅', at) : at + 4000)
-
-  assert.ok(body.includes("MIN(e.eventTime)") && body.includes("MAX(e.eventTime)"), '집계는 DB 가 한다')
-  assert.ok(
-    !/getRepository\(TwinEvent\)\s*\.?\s*\n?\s*\.find\(/.test(body),
-    '저널을 행 단위로 실어 오면 안 된다 — 275,882행 · payload 131MB 를 4초마다 파싱했던 자리다'
-  )
-})

package/test/touched-items.test.ts

@@ -1,61 +0,0 @@
-/*
- * 사건이 **어느 물품을 건드렸나** — 브로드캐스팅이 바뀐 것만 만들 수 있게 (2026-08-21).
- *
- * 이 판정이 틀리면 **화면이 낡는다.** 그래서 지키는 것을 값으로 못 박는다:
- *  ① 개체를 말한 자리를 전부 읽는다 — 관측·집약(부모/자식)·변환(입력/출력).
- *  ② 부류 수량만 말한 사건은 「모른다」다 — 그 부류의 어느 개체인지 말하지 않았다.
- *  ③ 물품을 만지지 않는다고 **선언된** 사건은 빈 범위다(작업·설비·인원·자산·오더·품질·확인·에너지).
- *  ④ 낯선 낱말은 「모른다」다 — 커널이 사건을 늘렸을 때 알리지 않고 빠뜨리지 않는다.
- *
- * 「모른다」(`null`)와 「하나도 없다」(빈 집합)는 **다른 사실**이다. 앞은 전부 다시 만들게 하고 뒤는
- * 물품을 건너뛰게 한다 — 둘을 같게 두면 둘 중 하나가 반드시 틀린다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { touchedItemKeys } from '../shared/touched-items.ts'
-
-const epcis = (data: any) => ({ eventType: 'epcis.object', data })
-
-test('관측 사건은 말한 개체를 모두 낸다', () => {
-  const got = touchedItemKeys(epcis({ epcList: ['urn:epc:id:sgtin:952.1.A', 'urn:epc:id:sgtin:952.1.B'] }))
-  assert.deepEqual([...got!].sort(), ['urn:epc:id:sgtin:952.1.A', 'urn:epc:id:sgtin:952.1.B'])
-})
-
-test('집약은 부모와 자식을 함께 낸다 — 부모만 내면 팔레트에 담긴 것이 낡는다', () => {
-  const got = touchedItemKeys({
-    eventType: 'epcis.aggregation',
-    data: { parentID: 'urn:epc:id:sscc:952.P1', childEPCs: ['urn:epc:id:sgtin:952.1.A'] }
-  })
-  assert.deepEqual([...got!].sort(), ['urn:epc:id:sgtin:952.1.A', 'urn:epc:id:sscc:952.P1'])
-})
-
-test('변환은 입력과 출력을 함께 낸다 — 소비된 것도 값이 바뀐다', () => {
-  const got = touchedItemKeys({
-    eventType: 'epcis.transformation',
-    data: { inputEPCList: ['in-1', 'in-2'], outputEPCList: ['out-1'] }
-  })
-  assert.deepEqual([...got!].sort(), ['in-1', 'in-2', 'out-1'])
-})
-
-test('부류 수량만 말한 사건은 「모른다」다 — 그 부류의 어느 개체인지 말하지 않았다', () => {
-  const got = touchedItemKeys(epcis({ quantityList: [{ epcClass: 'urn:epc:idpat:sgtin:952.1.*', quantity: 3 }] }))
-  assert.equal(got, null, '개체를 특정하지 못하면 전부 다시 만들어야 한다')
-})
-
-test('물품을 만지지 않는다고 선언된 사건은 빈 범위다 — 전부 다시 만들 이유가 없다', () => {
-  for (const eventType of ['task.status', 'equipment.status', 'person.status', 'asset.status', 'order.status', 'quality.output', 'attention.acked']) {
-    const got = touchedItemKeys({ eventType, data: { taskId: 't1', moverId: 'fk-1' } })
-    assert.ok(got, `${eventType} 은 「모른다」가 아니다`)
-    assert.equal(got!.size, 0, `${eventType} 은 물품을 건드리지 않는다`)
-  }
-  const energy = touchedItemKeys({ eventType: 'energy.measured', data: { id: 'm-1', kW: 12 } })
-  assert.equal(energy!.size, 0)
-})
-
-test('낯선 낱말은 「모른다」다 — 커널이 사건을 늘렸을 때 알리지 않고 빠뜨리지 않는다', () => {
-  assert.equal(touchedItemKeys({ eventType: 'something.new', data: { epcList: ['x'] } }), null)
-  assert.equal(touchedItemKeys({ data: { epcList: ['x'] } }), null, '낱말이 없으면 판정할 수 없다')
-  assert.equal(touchedItemKeys(undefined), null)
-  assert.equal(touchedItemKeys({ eventType: 'epcis.object' }), null, '내용이 없으면 판정할 수 없다')
-})

package/test/twin-audit.test.ts

@@ -1,83 +0,0 @@
-/*
- * 커맨드 감사 기록 — 이 검사가 지키는 것은 **기록이 증명력을 갖는가** 다.
- *
- * 감사 기록의 가치는 "남아 있다" 가 아니라 "믿을 수 있다" 에 있다. 클라이언트가 보낸 신원을 그대로
- * 적으면 위조가 자유로워 아무것도 증명하지 못하고, 거절된 시도를 안 남기면 "무엇을 하려 했는가" 가
- * 사라진다. 그 둘이 이 파일의 핵심 검사다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { buildCommandAudit, normalizeOrigin } from '../server/service/twin-audit/command-audit.ts'
-
-const AT = new Date('2026-08-06T12:00:00.000Z')
-
-test('명령 종류를 그대로 싣는다 — 무엇을 하려 했는지가 감사의 시작이다', () => {
-  const row = buildCommandAudit({ command: { commandId: 'c1', type: 'order.hold' }, ack: { accepted: true }, at: AT })
-  assert.equal(row.commandType, 'order.hold')
-  assert.equal(row.commandId, 'c1')
-})
-
-test('신원은 서버가 준 것만 적는다 — 커맨드에 실려 온 신원 주장은 무시한다', () => {
-  const row = buildCommandAudit({
-    /* 위조 시도: 클라이언트가 자기를 관리자라고 주장한다. */
-    command: { type: 'order.hold', actorId: 'admin', actorEmail: 'admin@corp', actorName: '관리자' },
-    ack: { accepted: true },
-    actor: { id: 'u-7', email: 'kim@corp', name: '김현장' },
-    at: AT
-  })
-  assert.equal(row.actorId, 'u-7')
-  assert.equal(row.actorEmail, 'kim@corp')
-  assert.equal(row.actorName, '김현장')
-})
-
-test('세션에 사용자가 없으면 비운다 — 모르는 것을 지어내지 않는다', () => {
-  const row = buildCommandAudit({ command: { type: 'order.hold' }, ack: { accepted: true }, at: AT })
-  assert.equal(row.actorId, undefined)
-  assert.equal(row.actorEmail, undefined)
-})
-
-test('커널이 거절한 시도도 남는다 — 무엇을 하려 했는지가 감사의 절반이다', () => {
-  const row = buildCommandAudit({
-    command: { type: 'equipment.repair', args: { id: 'cutter-1' } },
-    ack: { accepted: false, errorCode: 'not-broken' },
-    at: AT
-  })
-  assert.equal(row.accepted, false)
-  assert.equal(row.errorCode, 'not-broken')
-  assert.deepEqual(row.args, { id: 'cutter-1' })
-})
-
-test('출처는 아는 값만 — 모르면 unknown 이지 사람이 한 것으로 치지 않는다', () => {
-  assert.equal(normalizeOrigin('ai'), 'ai')
-  assert.equal(normalizeOrigin('user'), 'user')
-  assert.equal(normalizeOrigin('automation'), 'automation')
-  assert.equal(normalizeOrigin(undefined), 'unknown')
-  assert.equal(normalizeOrigin('관리자승인'), 'unknown')
-})
-
-test('근거는 문자열일 때만 싣는다 — 객체를 그대로 넣어 화면이 [object Object] 를 띄우지 않게', () => {
-  const ok = buildCommandAudit({ command: { type: 't', reason: '대기 15분 절감' }, ack: {}, at: AT })
-  assert.equal(ok.reason, '대기 15분 절감')
-  const bad = buildCommandAudit({ command: { type: 't', reason: { why: 'x' } }, ack: {}, at: AT })
-  assert.equal(bad.reason, undefined)
-})
-
-test('args 가 지나치게 크면 자르되 잘랐다고 알린다 — 알리지 않고 버리지 않는다', () => {
-  const huge = { blob: 'x'.repeat(9000) }
-  const row = buildCommandAudit({ command: { type: 't', args: huge }, ack: {}, at: AT })
-  assert.equal(row.argsTruncated, true)
-  assert.equal(typeof row.args, 'string')
-  assert.ok((row.args as string).length <= 4000)
-})
-
-test('작은 args 는 자르지 않고 원형 그대로 — 나중에 따질 수 있어야 한다', () => {
-  const row = buildCommandAudit({ command: { type: 't', args: { id: 'a', qty: 3 } }, ack: {}, at: AT })
-  assert.equal(row.argsTruncated, false)
-  assert.deepEqual(row.args, { id: 'a', qty: 3 })
-})
-
-test('시각은 호출부가 준 서버 시각을 그대로 쓴다 — 클라이언트 시계를 믿지 않는다', () => {
-  const row = buildCommandAudit({ command: { type: 't', eventTime: '1999-01-01T00:00:00.000Z' }, ack: {}, at: AT })
-  assert.equal(row.eventTime.toISOString(), AT.toISOString())
-})