@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/ingest-running-guard.test.ts

@@ -1,136 +0,0 @@
-/*
- * ★ 가동 중 인제스트 — **거절할 것이면 아무것도 쓰기 전에 거절한다.**
- *
- * 가동 중 재프로비저닝은 `provision` 이 막는다. 그런데 그 호출은 `ingestMaster` 의 **맨 끝**이었고,
- * 그때까지 공간·표현·구역(TwinArea)은 이미 저장된 뒤였다. 사용자 화면에는 "인제스트 실패" 가
- * 뜨는데 실제로는 절반이 적용된 상태다 — **실패라고 말하면서 데이터를 바꾸는 것**이 가장 나쁘다.
- *
- * 이 검사는 그 경계 하나를 지킨다: 거절된 인제스트는 **흔적을 남기지 않는다.**
- *
- * 순수 함수로는 확인되지 않는다. 부분 쓰기는 정의상 "여러 표에 걸쳐 무엇이 남았나" 이므로 실
- * DataSource 가 있어야 한다(멀티DB 규약상 sqlite 가 5개 드라이버 공통의 최소선이다).
- *
- * 이 제약 자체는 최종형이 아니다 — 커널에는 가동 중 구조 교체(`adoptStructure`)가 이미 있고
- * 재생은 리비전 경계마다 그것을 쓴다. 라이브에 배선되면 이 거절은 사라지고 이 검사도 함께 간다.
- */
-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 { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { TwinStructure } = req('../dist-server/service/twin-structure/twin-structure.js')
-const { TwinArea } = req('../dist-server/service/twin-space/twin-area.js')
-const { TwinSpace } = req('../dist-server/service/twin-space/twin-space.js')
-const { TwinLocation } = req('../dist-server/service/twin-model/twin-location.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const INSTANCE = 'guard-probe'
-
-/** WMS 마스터 — `bins` 로 규모를, `siteName`·구역 이름으로 "무엇이 바뀌려 했나" 를 다이얼한다. */
-const master = (bins: number, siteName: string, areaName: string): any => ({
-  source: INSTANCE,
-  system: 'wms',
-  siteName,
-  space: { width: 60, depth: 30, unit: 'm' },
-  locations: [
-    { id: 'a-dc', type: 'warehouse', role: 'area', name: areaName },
-    { id: 'dock-recv', type: 'dock', role: 'location', name: '입고 도크', capacity: 100 },
-    ...Array.from({ length: bins }, (_, i) => ({
-      id: `bin-${i + 1}`,
-      type: 'storage',
-      role: 'location',
-      name: `빈${i + 1}`,
-      parentId: 'a-dc',
-      capacity: 20
-    }))
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv' }]
-})
-
-/** 지금 DB 에 남아 있는 모든 흔적 — 인제스트가 건드리는 표를 한 줌으로 뜬다. */
-async function trace() {
-  const inst = await ds.getRepository(TwinInstance).findOne({ where: { instanceId: INSTANCE } })
-  const space = await ds.getRepository(TwinSpace).findOne({ where: { spaceId: `${INSTANCE}-site` } })
-  const areas = await ds.getRepository(TwinArea).find({ order: { areaId: 'ASC' } })
-  const revs = await ds.getRepository(TwinStructure).find({ order: { rev: 'ASC' } })
-  return {
-    boardLocations: (inst?.model?.locations ?? []).length,
-    spaceName: space?.name,
-    areaNames: areas.map((a: any) => a.name),
-    revs: revs.map((r: any) => r.rev),
-    rows: await ds.getRepository(TwinLocation).count()
-  }
-}
-
-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: 'guard-test', subdomain: 'guard-test' } as any)
-  domainId = d.id
-
-  await TwinEngine.ingestMaster(domainId, master(3, '서울 창고', '보관 구역'), 'reset')
-})
-
-after(async () => {
-  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('멈춰 있으면 재인제스트가 통한다 — 막는 것은 가동 중일 때뿐이다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(5, '서울 창고', '보관 구역'), 'reset')
-  const t = await trace()
-  assert.equal(t.boardLocations, 6, '자리 6개(도크 1 + 빈 5)로 갱신된다')
-  assert.deepEqual(t.revs, [1, 2], '구조가 달라졌으니 리비전이 하나 늘어난다')
-  assert.equal(t.rows, 6, '표도 함께 다시 그려진다')
-})
-
-test('가동 중이면 거절하고 — **아무것도 바꾸지 않는다**', async () => {
-  await TwinEngine.startFromRegistry(domainId, INSTANCE, 'reset')
-  const before = await trace()
-
-  /*
-   * 바뀔 것을 **일부러 전부** 흔든다. 구조(빈 5→9)뿐 아니라 공간 이름·구역 이름까지 —
-   * 부분 쓰기는 앞쪽(공간·구역)에서 일어났으므로, 구조만 확인하면 예전 결함을 못 잡는다.
-   */
-  await assert.rejects(
-    () => TwinEngine.ingestMaster(domainId, master(9, '부산 창고', '다른 구역'), 'reset'),
-    /is running/,
-    '가동 중에는 거절해야 한다'
-  )
-
-  assert.deepEqual(await trace(), before, '거절된 인제스트는 어느 표에도 흔적을 남기지 않는다')
-})
-
-test('멈추면 다시 통한다 — 거절은 잠금이 아니라 순서다', async () => {
-  await TwinEngine.stop(domainId, INSTANCE)
-  await TwinEngine.ingestMaster(domainId, master(9, '부산 창고', '다른 구역'), 'reset')
-
-  const t = await trace()
-  assert.equal(t.boardLocations, 10, '아까 거절당한 그 구조가 이제 들어간다')
-  assert.deepEqual(t.revs, [1, 2, 3])
-  assert.equal(t.rows, 10)
-  /*
-   * 공간 이름은 **안 바뀐다** — 이미 있는 공간의 이름은 인제스트가 덮지 않는다(공유 공간에서
-   * 먼저 쓴 값이 이긴다). 거절 검사가 "안 바뀌었다" 를 확인할 때 이 성질에 기대지 않도록,
-   * 여기서 그것이 별개의 규칙임을 못 박아 둔다.
-   */
-  assert.equal(t.spaceName, '서울 창고', '기존 공간 이름은 재인제스트가 덮지 않는다(별개 규칙)')
-})

package/test/ingest-space.test.ts

@@ -1,78 +0,0 @@
-/*
- * 인제스트 공간 판정 — "이 현장에 더한다" 가 알리지 않고 빗나가지 않게.
- *
- * 엔진 본체는 DB·TypeORM 을 물고 있어 단위테스트로 부를 수 없다. 그래서 **결정만** 순수 모듈로
- * 떼어 놓고 여기서 본다(엔진은 공간 존재 여부를 조회해 넘기는 일만 한다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { resolveIngestSpace, refuseImportSpace, collidingIds, INGEST_SPACE_NOT_FOUND } from '../server/service/reference/ingest-space.ts'
-
-test('고르지 않으면 마스터가 파생한 공간으로 — 지금까지의 거동을 바꾸지 않는다', () => {
-  for (const req of [undefined, null, '', '   ']) {
-    const c = resolveIngestSpace('hatiolab-wms-site', req as any, false)
-    assert.deepEqual(c, { spaceId: 'hatiolab-wms-site', joined: false }, `요청=${JSON.stringify(req)}`)
-  }
-})
-
-test('기존 현장을 고르면 그 공간으로 들어가고 합치기로 표시된다', () => {
-  const c = resolveIngestSpace('trailer-yard-new-site', 'rosarito-site', true)
-  assert.deepEqual(c, { spaceId: 'rosarito-site', joined: true })
-})
-
-test('마스터가 이미 그 공간이면 합치기가 아니다 — 같은 공간의 재인제스트다', () => {
-  const c = resolveIngestSpace('rosarito-site', 'rosarito-site', true)
-  assert.deepEqual(c, { spaceId: 'rosarito-site', joined: false })
-})
-
-test('없는 현장은 거절한다 — 알리지 않고 새 공간을 만들지 않는다', () => {
-  /* 여기서 새 공간을 만들어 주면 사용자는 합쳤다고 믿고 화면은 따로 논다. 그때는 이미 양쪽에
-     이벤트가 쌓여 있어 손으로 합치는 것이 훨씬 비싸다. */
-  assert.throws(
-    () => resolveIngestSpace('a-site', 'typo-site', false),
-    (e: any) => e.code === INGEST_SPACE_NOT_FOUND && /typo-site/.test(e.message)
-  )
-})
-
-test('앞뒤 공백은 다듬는다 — 사용자가 붙여 넣은 id 로 거절당하지 않게', () => {
-  const c = resolveIngestSpace('a-site', '  rosarito-site  ', true)
-  assert.equal(c.spaceId, 'rosarito-site')
-})
-
-test('같은 id 를 쓰는 것들을 찾아낸다 — 합쳐지는 것을 모르고 지나가지 않게', () => {
-  const existing = [{ id: 'a-yard' }, { id: 'a-dock' }]
-  const incoming = [{ id: 'a-yard' }, { id: 'a-line' }, { id: 'a-dock' }]
-  assert.deepEqual(collidingIds(existing, incoming), ['a-dock', 'a-yard'], '정렬된 교집합')
-  assert.deepEqual(collidingIds(existing, [{ id: 'a-line' }]), [], '겹치지 않으면 빈 배열')
-  assert.deepEqual(collidingIds(undefined, undefined), [], '없는 쪽은 빈 것으로 본다')
-  assert.deepEqual(collidingIds([{}, { id: '' }], [{ id: '' }]), [], 'id 없는 항목은 세지 않는다')
-})
-
-/* ── 실 시스템 import 의 현장 선택 (2026-08-13) ───────────────────────────── */
-
-test('현장을 고르지 않으면 사이트가 몇이든 진행한다 — 지금까지의 거동', () => {
-  for (const n of [0, 1, 5, 40]) {
-    assert.equal(refuseImportSpace(n, undefined), undefined)
-    assert.equal(refuseImportSpace(n, ''), undefined)
-  }
-})
-
-test('사이트 하나면 그 현장에 넣는다 — 렌즈를 더하는 정상 경로', () => {
-  assert.equal(refuseImportSpace(1, 'rosarito-site'), undefined)
-})
-
-test('사이트 여럿을 한 현장에 넣는 것은 거절한다 — 서로 다른 현장이 알리지 않고 합쳐진다', () => {
-  const r = refuseImportSpace(3, 'rosarito-site')
-  assert.ok(r, '거절해야 한다')
-  assert.equal(r.code, 'space-with-multiple-sites')
-  assert.equal(r.params?.count, 3)
-  assert.equal(r.params?.spaceId, 'rosarito-site')
-  assert.match(r.message, /pick one site/)
-})
-
-test('거절 사유는 코드로 낸다 — 화면이 다섯 언어로 번역할 수 있게', () => {
-  const r = refuseImportSpace(2, '  rosarito-site  ')
-  assert.equal(r?.code, 'space-with-multiple-sites')
-  assert.equal(r?.params?.spaceId, 'rosarito-site', '앞뒤 공백은 다듬어 낸다')
-})

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

@@ -1,72 +0,0 @@
-/*
- * ★ **보는 사람이 없어도 창이 닫힌다** — 아무도 안 보는 트윈일수록 기록이 없었다.
- *
- * ── 실측 (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, '장부가 사실을 안 세고 있다 — 이 검사가 아무것도 안 잰다')
-})

package/test/ingest-wiring-guard.test.ts

@@ -1,197 +0,0 @@
-/*
- * 유입 배선 감시 — **커널이 문을 열었는데 그 문으로 가는 길이 없는 것**을 잡는다.
- *
- * ── 왜 있나 (2026-08-30) ────────────────────────────────────────────────────
- * 2026-08-29 하루에 이 부류가 다섯 번 났다. 커널에 새 어휘의 문을 만들고, 정규 유입의 갈림에
- * 그 길을 내지 않은 것이다. 그때마다 레코드는 **거부되지도 않고 아무 문에도 들어가지 못한 채**
- * 사라졌다 — 커넥터는 보냈다고 믿고, 화면은 값이 없다고 말한다. 사람이 하나씩 찾아냈다.
- *
- * 다음 날 같은 부류의 **두 번째 얼굴**이 드러났다. EPCIS 갈래는 「나머지 전부」라, 새 어휘를 그
- * 목록에서 빼 주지 않으면 레코드가 제 문으로 가면서 **EPCIS 문으로도 들어가 거부된다.** 받아들여
- * 지기도 하고 거부되기도 하는 상태가 되어, 유입 장부의 거부 수가 늘고 사람이 그것을 진짜 결함으로
- * 읽는다.
- *
- * ── 무엇을 지키나 ──────────────────────────────────────────────────────────
- *   ① 커널의 유입 함수마다 부르는 곳이 있다
- *   ② 어휘마다 **정확히 한 문**으로 간다 — 어느 문에도 못 가거나 두 문에 걸치지 않는다
- *
- * ── 목록을 손으로 적지 않는다 ──────────────────────────────────────────────
- * 커널이 내보내는 이름에서 읽는다. 커널이 문을 늘리면 이 시험이 먼저 빨갛게 난다. 손 목록을 두면
- * 늘어난 것을 모른다 — 이 저장소가 이미 그 실패를 겪었다(`vocabulary-labels` 의 주석).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-/* 유입 문과 판별 함수는 계약에 있다 — 커널은 엔진만 내보낸다(2026-08-30 층 분리). */
-import * as kernel from '@operato/ops-contract'
-import { ingestCanonicalRecords } from '../server/engine/canonical-ingest.ts'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const routerSource = readFileSync(join(here, '..', 'server', 'engine', 'canonical-ingest.ts'), 'utf-8')
-
-/**
- * 정규 유입이 부르지 **않아도 되는** 것 — 각각 이유가 있다.
- *
- * 이 목록에 올릴 때는 이유를 함께 적는다. 이유 없이 올리면 이 시험은 아무것도 지키지 않는다.
- */
-const NOT_ROUTED: Record<string, string> = {
-  /* 물류 어휘의 진입점 자체다 — 갈림이 이것을 부른다(이름이 `ingest` 하나뿐이라 규칙에 안 걸린다). */
-  ingest: 'EPCIS 어휘의 진입점. 갈림이 직접 부른다',
-  /* 마스터 데이터는 사건이 아니라 어휘 갱신이라 다른 경로로 간다. */
-  ingestMasterData: '사건이 아니라 어휘 갱신 — 참조 계층이 부른다'
-}
-
-test('★ 커널의 유입 함수마다 부르는 곳이 있다', () => {
-  const ingests = Object.keys(kernel).filter(n => /^ingest/.test(n))
-  assert.ok(ingests.length >= 8, `유입 함수를 못 읽었다(${ingests.length}개) — 커널을 다시 읽어야 한다`)
-
-  const unrouted = ingests.filter(n => !NOT_ROUTED[n] && !routerSource.includes(n))
-  assert.deepEqual(
-    unrouted,
-    [],
-    `커널이 문을 열었는데 정규 유입에 길이 없다:\n${unrouted.join('\n')}\n` +
-      '그 문으로 보내는 레코드는 거부되지도 않고 사라진다.\n' +
-      '갈림에 길을 내거나, 부르지 않아도 되는 이유를 NOT_ROUTED 에 적어라.'
-  )
-})
-
-test('부르지 않아도 되는 목록에 이유가 적혀 있다', () => {
-  for (const [name, why] of Object.entries(NOT_ROUTED)) {
-    assert.ok(why.trim().length > 5, `${name} 에 이유가 없다`)
-  }
-})
-
-/**
- * 어휘마다 대표 레코드 하나 — **그 문으로만 가야 한다.**
- *
- * 값은 실제로 오는 모양에서 가져왔다(2026-08-29 실측). 지어낸 모양으로 검사하면 실제 레코드가
- * 다른 문으로 가는 것을 놓친다.
- */
-const NOW = '2026-08-30T00:00:00.000Z'
-const SAMPLES: { vocabulary: string; eventType: string; record: Record<string, unknown> }[] = [
-  {
-    vocabulary: '물품 관측(EPCIS)',
-    eventType: 'epcis.ObjectEvent',
-    record: {
-      epc: 'urn:epc:id:sgtin:0614141.107346.2017',
-      action: 'OBSERVE',
-      bizStep: 'urn:epcglobal:cbv:bizstep:storing',
-      readPoint: 'rack-1'
-    }
-  },
-  { vocabulary: '계량 표본', eventType: 'energy.measured', record: { meterId: 'incoming', kW: 100, at: NOW } },
-  {
-    vocabulary: '설비 상태',
-    eventType: 'energy.equipment',
-    record: { equipmentId: 'inv-1', generatedKW: 24.6, dcVoltage: 469.13, at: NOW }
-  },
-  { vocabulary: '발전 적산', eventType: 'energy.generated', record: { equipmentId: 'inv-1', kWh: 174, at: NOW } },
-  {
-    vocabulary: '마감된 사용 구간',
-    eventType: 'energy.usage.period',
-    record: {
-      meterId: 'incoming',
-      from: '2026-08-29T15:00:00.000Z',
-      to: '2026-08-29T16:00:00.000Z',
-      kWh: 474.48,
-      maxKW: 478.08,
-      unitPrice: 87.3,
-      currency: 'KRW',
-      basis: 'provider'
-    }
-  },
-  {
-    vocabulary: '요금 기준',
-    eventType: 'energy.tariff.basis',
-    record: {
-      /* 기준 선언은 **끝나지 않은 달**이 정상이다 — 사건 시각이 기간의 시작이라 미래에 적히지 않는다. */
-      from: '2026-07-31T15:00:00.000Z',
-      to: '2026-08-31T15:00:00.000Z',
-      billingDemandKW: 1650,
-      demandChargePerKW: 8320,
-      currency: 'KRW'
-    }
-  },
-  {
-    vocabulary: '청구서',
-    eventType: 'energy.bill',
-    record: {
-      /*
-       * 청구서는 **마감된 달**이다. 처음 이 표본은 끝나지 않은 8월을 담고 있었는데, 그것은 실제로
-       * 들어와 있던 잘못된 데이터를 그대로 베낀 것이었다(2026-08-30). 그 데이터 때문에 한 현장의
-       * 성과 구간이 미래로 밀려 화면이 비어 있었다. 표본이 결함을 베끼면 시험이 결함을 지킨다.
-       */
-      from: '2026-06-30T15:00:00.000Z',
-      to: '2026-07-31T15:00:00.000Z',
-      demandCharge: 13_728_000,
-      currency: 'KRW',
-      billingDemandKW: 1650
-    }
-  },
-  {
-    vocabulary: '발전 단가',
-    eventType: 'energy.generation.price',
-    record: { from: '2026-08-29T15:00:00.000Z', to: '2026-08-30T15:00:00.000Z', unitPrice: 148.61, currency: 'KRW' }
-  },
-  {
-    /*
-     * 라이브에서는 커널이 스스로 마감해 내지만, **지난 기록을 채울 때**는 밖에서 들어온다.
-     * 구간이 있으므로 적산의 문(`energy.generated`)이 아니라 이쪽으로 가야 한다 — 겹치면 지난
-     * 기록이 「지금 적산」으로도 읽혀 트윈의 시계가 과거로 끌린다.
-     */
-    vocabulary: '마감된 발전 기간',
-    eventType: 'energy.generation.period',
-    record: {
-      equipmentId: '001',
-      from: '2026-08-28T15:00:00.000Z',
-      to: '2026-08-29T15:00:00.000Z',
-      kWh: 394.3,
-      accumulation: 'daily'
-    }
-  }
-]
-
-test('★ 어휘마다 정확히 한 문으로 간다 — 사라지지도, 두 문에 걸치지도 않는다', () => {
-  const wrong: string[] = []
-  for (const s of SAMPLES) {
-    const r = ingestCanonicalRecords([s.record] as any, 't', NOW)
-    const accepted = (r.accepted as any[]).map(e => e.eventType)
-    if (r.rejected.length) {
-      wrong.push(`${s.vocabulary}: 거부됐다 — ${JSON.stringify(r.rejected[0]?.errors)}`)
-      continue
-    }
-    if (accepted.length !== 1) {
-      wrong.push(`${s.vocabulary}: 봉투가 ${accepted.length}개다(${accepted.join(', ')}) — 한 문으로만 가야 한다`)
-      continue
-    }
-    if (accepted[0] !== s.eventType) wrong.push(`${s.vocabulary}: ${s.eventType} 이어야 하는데 ${accepted[0]} 로 갔다`)
-  }
-  assert.deepEqual(wrong, [], `\n${wrong.join('\n')}`)
-})
-
-test('★ 한 배치에 모든 어휘가 섞여 와도 각자의 문으로 간다', () => {
-  const r = ingestCanonicalRecords(SAMPLES.map(s => s.record) as any, 't', NOW)
-  assert.deepEqual(r.rejected, [], `거부가 없어야 한다: ${JSON.stringify(r.rejected)}`)
-  assert.deepEqual(
-    (r.accepted as any[]).map(e => e.eventType).sort(),
-    SAMPLES.map(s => s.eventType).sort()
-  )
-})
-
-test('커널이 어휘를 늘리면 이 시험이 먼저 안다', () => {
-  /*
-   * 판별 함수의 수와 위 표본의 수가 어긋나면, 커널에 어휘가 늘었는데 여기 표본이 없다는 뜻이다.
-   * (EPCIS 안의 갈림 둘(담김·변환)은 한 어휘로 센다 — 같은 문으로 간다.)
-   */
-  const gates = Object.keys(kernel).filter(n => /^is.*Record$/.test(n))
-  const counted = gates.filter(n => !['isAggregationRecord', 'isTransformationRecord', 'isMasterDataRecord'].includes(n))
-  assert.equal(
-    counted.length,
-    SAMPLES.length,
-    `커널의 어휘는 ${counted.length}개인데 표본은 ${SAMPLES.length}개다:\n${counted.join(' ')}\n` +
-      '늘어난 어휘의 표본을 SAMPLES 에 더하라 — 그래야 그 어휘도 한 문으로 가는지 검사된다.'
-  )
-})

package/test/instance-cache-lifecycle.test.ts

@@ -1,110 +0,0 @@
-/*
- * ★ 인스턴스별 캐시는 **트윈과 함께 사라진다.**
- *
- * ── 왜 이 검사가 필요한가 ─────────────────────────────────────────────────────
- * 엔진은 트윈마다 메모리에 몇 가지를 들고 있다(실측 추정기·구조 리비전·복구 표식). 지움은 저널과
- * 등록부까지 갔는데 **캐시는 남았다** — 삭제된 트윈의 항목이 서버 재기동까지 살아 있었다. 항목 하나가
- * 하루치 KPI 그룹을 물고 있으므로, 트윈을 만들고 지우는 일이 반복되는 현장에서는 그것이 곧 누수다.
- *
- * TTL 은 이것을 막지 못한다: TTL 은 **값이 낡는 것**을 막을 뿐 **없어진 주인**을 지우지 않는다.
- *
- * 그래서 규율은 둘이다.
- *  ① 트윈이 사라지면 그 트윈에 대한 메모리를 **전부** 잊는다(정확한 쪽).
- *  ② 우리 API 를 지나지 않고 사라지는 길(도메인째 삭제·DB 직접 조작)에는 **상한**이 막는다(방어).
- *
- * 사설(private) 필드를 들여다보는 검사인 것을 안다. 그런데 여기서 지켜야 하는 것은 겉으로 드러나는
- * 값이 아니라 **메모리가 자라지 않는다**는 사실이고, 그것은 안을 봐야 볼 수 있다.
- */
-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 { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const INSTANCE = 'cache-probe'
-
-const master = (): any => ({
-  source: INSTANCE,
-  system: 'wms',
-  siteName: '캐시 창고',
-  space: { spaceId: 'cache-site', width: 40, depth: 30, unit: 'm' },
-  locations: [
-    { id: 'dock', type: 'dock', role: 'location', name: '도크', capacity: 50 },
-    { id: 'bin-1', type: 'storage', role: 'location', name: '빈1', capacity: 20 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock' }]
-})
-
-/** 캐시 안을 본다 — 겉으로는 안 보이는 사실을 지키는 검사이므로. */
-const caches = () => ({
-  measured: (TwinEngine as any).measuredCache as Map<string, unknown>,
-  structureRev: (TwinEngine as any).structureRevCache as Record<string, number>,
-  recovered: (TwinEngine as any).recovered as Record<string, unknown>
-})
-const keyOf = (id: string) => `${domainId}:${id}`
-
-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: 'cache-test', subdomain: 'cache-test' } as any)
-  domainId = d.id
-})
-
-after(async () => {
-  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('지운 트윈의 캐시는 남지 않는다 — TTL 은 없어진 주인을 지우지 않는다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-  /* 캐시를 실제로 채운다 — 손으로 넣으면 "채우는 경로" 가 바뀌어도 검사가 통과한다. */
-  await TwinEngine.structureRevOf(domainId, INSTANCE)
-  const { measured, structureRev } = caches()
-  assert.ok(keyOf(INSTANCE) in structureRev, '구조 리비전이 캐시에 올라와야 이 검사가 뜻이 있다')
-
-  await TwinEngine.remove(domainId, INSTANCE)
-
-  const after = caches()
-  assert.equal(keyOf(INSTANCE) in after.structureRev, false, '지운 트윈의 구조 리비전이 남았다')
-  assert.equal(after.measured.has(keyOf(INSTANCE)), false, '지운 트윈의 실측 캐시가 남았다')
-  assert.equal(keyOf(INSTANCE) in after.recovered, false, '지운 트윈의 복구 표식이 남았다')
-  assert.equal(measured, after.measured, '캐시 객체를 갈아치우는 것이 아니라 항목을 지운다')
-})
-
-test('상한을 넘으면 가장 오래 손대지 않은 것부터 버린다 — 주인 없이 사라진 트윈까지 막는다', async () => {
-  const { measured } = caches()
-  measured.clear()
-  const MAX = (TwinEngine as any).MEASURED_MAX as number
-  assert.ok(MAX > 0, '상한이 선언되어 있어야 방어가 성립한다')
-
-  /*
-   * 상한 + 2 개를 넣고, 넣는 경로(`measuredEstimator`)를 그대로 쓴다. 트윈이 등록되어 있지 않으면
-   * KPI 조회가 빈 값을 내고 캐시에는 `undefined` 가 들어간다 — **그 자체도 캐시할 값이다**(없다는
-   * 사실을 알고 있는 것과 매번 다시 묻는 것은 다르다).
-   */
-  const call = (TwinEngine as any).measuredEstimator.bind(TwinEngine)
-  for (let i = 0; i < MAX + 2; i++) await call(domainId, `ghost-${i}`)
-
-  assert.ok(measured.size <= MAX, `상한을 넘어 자랐다(${measured.size} > ${MAX})`)
-  assert.equal(measured.has(`${domainId}:ghost-0`), false, '가장 오래된 항목이 남아 있다 — 버릴 순서가 어긋났다')
-  assert.ok(measured.has(`${domainId}:ghost-${MAX + 1}`), '가장 최근 항목은 남아야 한다')
-  measured.clear()
-})