@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/revision-axis.test.ts

@@ -1,110 +0,0 @@
-/*
- * ★ 리비전은 **두 셈**이고, 둘이 같은 것을 세지 않는다 — 그 사실을 코드가 지키는지 본다.
- *
- * ── 무엇이 어긋나 있었나 (2026-08-23 실측) ──────────────────────────────────
- * 포천 미러의 체크포인트가 뜻이 다른 두 수를 나란히 적었다.
- *
- *   바깥 revision   12,972   저널에 적힌 줄 번호
- *   state.revision   6,478   커널이 처리한 봉투 수
- *
- * 차이 6,494 는 그 트윈을 **다시 세운 시각**(09:11)에 저널이 이미 갖고 있던 줄 수와 정확히 같았다
- * (줄 6494 = 08:23:59 · 줄 6495 = 09:11:13). 산수가 맞았으니 결함은 「수가 틀렸다」가 아니다.
- *
- * 결함은 **비대칭**이었다. 재기동 경로(`start` → `resumeRevision`)는 커널에 저널 머리를 알려 주는데
- * 미러를 세우는 경로(`startLive`)는 알려 주지 않았다. 그래서 같은 저장물을 읽는 사람이 같은 이름의 두
- * 수를 같은 축으로 견주게 되고, 실제로 그렇게 읽혔다(반나절이 그 오독에서 나갔다).
- *
- * ── 왜 알려 주어야 하나 ─────────────────────────────────────────────────────
- * 커널의 계약이 그 이유를 적어 두었다(`resumeRevision`): 「저널이 비어 있지 않은데 0부터 다시 세면 같은
- * 트윈에 같은 리비전이 둘 생기고, 재생 순서가 뒤섞이며, 시간여행이 엉뚱한 시점을 답한다 — 오류는 안 난다.」
- * 알리지 않고 깨지는 종류이므로 시험이 지킨다.
- *
- * ── 이 시험이 무엇을 재는가 ─────────────────────────────────────────────────
- * DB 도 커널도 띄우지 않는다. 이 규율은 **어느 경로가 무엇을 부르나**에 있고 그것은 소스에서 확인된다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-const ENGINE = join(import.meta.dirname, '..', 'server', 'engine', 'twin-engine.ts')
-const src = readFileSync(ENGINE, 'utf8')
-
-/**
- * 그 함수 본문만 — 다른 경로의 호출이 섞여 판정이 흐려지지 않게.
- *
- * 끝은 **다음 멤버 선언**으로 자른다. 글자 수로 자르면 주석이 늘어난 날 알리지 않고 짧아져서, 있는 것을
- * 없다고 말한다(거짓 빨강을 내는 가드는 없는 것보다 나쁘다).
- */
-function bodyOf(signature: string): string {
-  const at = src.indexOf(signature)
-  assert.ok(at > 0, `${signature} 이 있어야 한다`)
-  const rest = src.slice(at + signature.length)
-  const end = rest.search(/\n  (?:static|private static|\/\*\*)/)
-  const body = end === -1 ? rest : rest.slice(0, end)
-  /* 잘라낸 본문이 비면 판정이 성립하지 않는다 — 그것을 통과로 읽지 않는다. */
-  assert.ok(body.length > 200, `${signature} 본문을 잘라내지 못했다(${body.length}자)`)
-  return body
-}
-
-test('미러를 세우는 경로도 커널에 저널 머리를 알려 준다', () => {
-  const body = bodyOf('static startLive(')
-  /*
-   * 저널 머리를 읽는다 — 이 조회는 예전부터 있었다(inst.revision 시드용).
-   *
-   * 2026-08-28: 모양을 `findOne(order: revision DESC)` 에서 `MAX(e.revision)` 으로 바꿨다. 앞의 것은
-   * 관계로 물어 두 단계 질의가 되고 안쪽에 상한이 없어 그 트윈의 저널을 전부 만든 뒤 한 줄을 고른다.
-   * **묻는 것은 같다** — 저널 머리다. 그래서 이 단정은 「머리를 읽는가」로 남고 모양만 따라간다.
-   */
-  assert.match(body, /select\('MAX\(e\.revision\)'/, '저널 머리를 읽어야 한다')
-  /* 그리고 **커널에도** 알려 준다 — 이 한 줄이 없어서 두 수가 갈렸다. */
-  assert.match(body, /resumeRevision\(head\)/, '커널에도 그 번호를 알려 준다')
-})
-
-test('재기동 경로는 예전부터 알려 주고 있었다 — 두 경로가 같아졌는지 본다', () => {
-  /*
-   * 이 단정은 「고쳤다」가 아니라 **두 경로가 대칭인지**를 지킨다. 한쪽만 남으면 같은 결함이 다른
-   * 문으로 되살아난다.
-   */
-  const body = bodyOf('static start(')
-  assert.match(body, /resumeRevision\(resumeFrom\)/, '재기동 경로도 알려 준다')
-})
-
-test('저널이 비어 있으면 알려 주지 않는다 — 새 트윈은 0 부터 세는 것이 맞다', () => {
-  const body = bodyOf('static startLive(')
-  assert.match(body, /if \(!head \|\| typeof/, '머리가 0 이면 아무 일도 하지 않는다')
-})
-
-test('뒤로 되돌리려는 거절을 삼키지 않는다', () => {
-  /*
-   * 조회가 비동기라 그 사이에 이벤트가 들어와 있을 수 있다. 그때 커널은 뒤로 가기를 거절한다(겹치는
-   * 번호를 막는 그 판정이다). 그 거절을 알리지 않고 버리면 「왜 두 수가 아직 다르지」를 답할 계기가 없다.
-   */
-  const body = bodyOf('static startLive(')
-  assert.match(body, /catch \(err[^)]*\)[\s\S]{0,200}twinWarn/, '거절을 로그에 남긴다')
-  assert.match(body, /is behind the kernel/, '무엇이 어긋났는지 말한다')
-})
-
-test('체크포인트는 두 수를 나란히 적는다 — 그 사실 자체는 옳다', () => {
-  /*
-   * 바깥은 저널 줄 번호(이어 쓸 자리), 안쪽은 커널이 계산한 봉투 수다. **둘을 하나로 합치지 않는다** —
-   * 합치면 「어디까지 적었나」와 「어디까지 반영했나」를 구별할 수 없고, 그 구별이 미러의 정직성이다.
-   * 두 경로가 대칭이면 값이 같아지지만, **자리는 둘이어야 한다.**
-   */
-  const at = src.indexOf('static async persistSnapshot')
-  assert.ok(at > 0, 'persistSnapshot 이 있어야 한다')
-  /*
-   * 창을 넓혀 왔다 — 이 함수 앞쪽에 「빈 상태로 좋은 스냅샷을 덮지 않는다」 가드가 들어오고(§
-   * `checkpoint-refuses-empty`), 뒤쪽에 「이어 계산할 씨앗을 함께 적는다」가 들어왔다(§
-   * `mirror-resumes-from-checkpoint`). 검사하는 **사실은 그대로**다.
-   *
-   * 그리고 **줄 모양이 아니라 두 자리를 검사한다**: 예전에는 `{ revision, state` 라는 한 줄 모양을
-   * 봤는데, 저장 인자가 여러 줄로 나뉘자 사실이 그대로인데도 빨강이 됐다. 서식이 검사를 깨면 다음
-   * 사람이 검사를 지우게 된다 — 그래서 이름 둘이 함께 실리는지만 본다.
-   */
-  const body = src.slice(at, at + 5000)
-  assert.match(body, /inst\.revision \?\? state\.revision/, '바깥은 저널 줄 번호를 먼저 쓴다')
-  const call = body.slice(body.indexOf('setInCache'))
-  assert.match(call, /revision/, '저널 줄 번호를 싣는다')
-  assert.match(call, /state/, '커널이 계산한 상태를 함께 싣는다 — 두 자리를 하나로 합치지 않는다')
-})

package/test/runtime-key.test.ts

@@ -1,66 +0,0 @@
-/*
- * 런타임 키 — **트윈의 정체성은 `(도메인, 인스턴스 id)`.**
- *
- * 계기(2026-08-06): 런타임 레지스트리가 `instanceId` 하나로 키를 잡고 있었다. 레퍼런스 경로가 소스
- * 이름을 그대로 id 로 쓰므로(`sap-ewm-1710`) 두 테넌트가 같은 벤더 시스템에 연결하면 같은 id 가 된다 —
- * 그때 남의 커널에 이벤트가 적용되거나, 웜스타트 씨앗이 남의 스냅샷이 됐다.
- *
- * 이 테스트가 지키는 것은 **키가 모호해지지 않는 것** 하나다. 모호한 키는 오류 없이 틀린 값을 낸다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { RUNTIME_KEY_SEP, isOfDomain, parseRuntimeKey, runtimeKey } from '../server/engine/runtime-key.ts'
-
-const D1 = '11111111-1111-1111-1111-111111111111'
-const D2 = '22222222-2222-2222-2222-222222222222'
-
-test('같은 인스턴스 id 라도 테넌트가 다르면 다른 키다 — 이 작업의 요점', () => {
-  assert.notEqual(runtimeKey(D1, 'sap-ewm-1710'), runtimeKey(D2, 'sap-ewm-1710'))
-})
-
-test('같은 테넌트·같은 id 는 같은 키다 — 재기동이 자기 자리를 찾는다', () => {
-  assert.equal(runtimeKey(D1, 'hatiolab-wms'), runtimeKey(D1, 'hatiolab-wms'))
-})
-
-test('되돌리면 원래 둘이 나온다', () => {
-  const { domainId, instanceId } = parseRuntimeKey(runtimeKey(D1, 'hatiolab-wms'))
-
-  assert.equal(domainId, D1)
-  assert.equal(instanceId, 'hatiolab-wms')
-})
-
-test('인스턴스 id 안의 구분자를 보존한다 — 첫 구분자에서만 자른다', () => {
-  /* 레퍼런스 소스 이름에 `:` 가 들어갈 수 있다. 마지막 구분자에서 자르면 id 가 잘려 다른 트윈이 된다. */
-  const weird = 'urn:epc:id:sgln:0614141.12345'
-  const { domainId, instanceId } = parseRuntimeKey(runtimeKey(D1, weird))
-
-  assert.equal(domainId, D1)
-  assert.equal(instanceId, weird)
-})
-
-test('도메인 id 에 구분자가 있으면 오류를 낸다 — 알리지 않고 모호한 키를 만들지 않는다', () => {
-  /* 알리지 않고 만들면 그게 곧 이 결함의 재발이다(어느 테넌트인지 알 수 없는 키). */
-  assert.throws(() => runtimeKey(`a${RUNTIME_KEY_SEP}b`, 'x'), /ambiguous/)
-})
-
-test('빈 값은 키가 될 수 없다 — 테넌트 없는 런타임은 없다', () => {
-  assert.throws(() => runtimeKey('', 'x'), /domainId is required/)
-  assert.throws(() => runtimeKey(D1, ''), /instanceId is required/)
-})
-
-test('키가 아닌 것을 되돌리려 하면 오류를 낸다', () => {
-  for (const bad of ['', 'no-separator', `${RUNTIME_KEY_SEP}leading`, `trailing${RUNTIME_KEY_SEP}`]) {
-    assert.throws(() => parseRuntimeKey(bad), /is not a runtime key/, `입력: "${bad}"`)
-  }
-})
-
-test('도메인으로 걸러낸다 — 접두사가 아니라 경계까지 본다', () => {
-  const key = runtimeKey(D1, 'wms')
-
-  assert.equal(isOfDomain(key, D1), true)
-  assert.equal(isOfDomain(key, D2), false)
-  /* 도메인 id 의 앞부분만 같은 것에 걸리지 않는다(구분자까지 붙여 본다). */
-  assert.equal(isOfDomain(key, D1.slice(0, 8)), false)
-  assert.equal(isOfDomain(key, ''), false)
-})

package/test/save-intake-collision.test.ts

@@ -1,91 +0,0 @@
-/*
- * ★ **화면 저장도 받는 사이트 충돌을 거부한다** (ADR-0046 ②-1, 2026-09-16)
- *
- * 들여오기에는 충돌 거부가 있는데 화면 저장(`saveTwinReference`)에는 없었다. `intakeEndpoint::intakeSiteId`
- * 가 같은 연결 둘을 만들면 받는 문은 둘 다 200 으로 받고 경고가 0 이다 — 잘못된 공장이 실제로 만든다.
- * 이 검사는 저장의 문이 쓰는 판정(`refuseIntakeCollision`)을 값으로 못 박는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { intakeCollisions, refuseIntakeCollision } from '../server/service/reference/connection-portability.js'
-
-const intake = { intakeEndpoint: 'https://plant.example/intake/', intakeSiteId: 'system' }
-const existing = [
-  { source: 'mes-line-a', siteName: 'Line A', connectionConfig: { baseUrl: 'https://plant.example', ...intake } }
-]
-
-test('★ 같은 받는 사이트를 가리키는 둘째 연결은 거부되고, 부딪힌 연결의 이름을 말한다', () => {
-  const r = refuseIntakeCollision('mes-line-b', { baseUrl: 'https://plant.example', ...intake }, existing)
-  assert.ok(r, '베낀 연결이 그대로 저장된다')
-  assert.equal(r.code, 'intake-site-taken')
-  assert.equal(r.params.site, 'system')
-  assert.equal(r.params.connection, 'Line A', '무엇과 부딪혔는지 말하지 않는다')
-})
-
-test('주소 끝의 / 하나로 비껴가지 않는다', () => {
-  const r = refuseIntakeCollision('mes-line-b', { intakeEndpoint: 'https://plant.example/intake', intakeSiteId: 'system' }, existing)
-  assert.ok(r)
-})
-
-test('자기 자신을 다시 저장하는 것은 충돌이 아니다', () => {
-  assert.equal(refuseIntakeCollision('mes-line-a', existing[0].connectionConfig, existing), null)
-})
-
-test('사이트를 고치면 저장된다 — 한 글자 고친 사람은 그 자리에서 지난다', () => {
-  assert.equal(refuseIntakeCollision('mes-line-b', { ...intake, intakeSiteId: 'line-b' }, existing), null)
-})
-
-test('조치 주소가 없는 연결은 부딪힐 것이 없다', () => {
-  assert.equal(refuseIntakeCollision('wms-x', { baseUrl: 'https://plant.example', siteId: 'system' }, existing), null)
-})
-
-test('★ 저장의 문이 그 판정을 부르고, 거부하면 쓰기 전에 돌아간다', () => {
-  const src = readFileSync(new URL('../server/service/reference/reference-resolver.ts', import.meta.url), 'utf8')
-  const body = src.slice(src.indexOf('async saveTwinReference('), src.indexOf('async deleteTwinReference('))
-  const check = body.indexOf('refuseIntakeCollision(')
-  const write = body.indexOf('repo.save(')
-  assert.ok(check > 0, 'saveTwinReference 가 충돌 판정을 부르지 않는다')
-  assert.ok(check < write, '판정이 쓰기 뒤에 있다 — 이미 저장된 뒤의 거부는 거부가 아니다')
-  assert.match(body, /errorCode: taken\.code/)
-})
-
-/*
- * ★ **같은 충돌을 두 모양으로 건다** (ADR-0053 ②, 2026-09-16).
- *
- * 패키지는 `config`, `TwinReference` 행은 `connectionConfig` 다. 전에는 `config` 만 읽어서 행을 그대로
- * 넘기면 `[]` 였다 — 오류도 경고도 없이 저장이 통과했다. 부르는 둘이 마침 옮겨서 부른 덕에 멀쩡했는데,
- * 그건 계약이 아니라 우연이다(이 함수는 화면이 쓰라고 리졸버에서 다시 내보내진다).
- *
- * 옮기기가 다시 갈리는 날 **빨개지는 자리가 여기 하나**다. 그래서 「두 모양이 같은 답을 낸다」를
- * 값으로 센다 — 결정의 내용이 그것이므로.
- */
-const pair = [
-  { source: 'mes-line-a', ...intake },
-  { source: 'mes-line-b', ...intake }
-]
-
-test('★ DB 행 모양(connectionConfig)으로 걸어도 같은 충돌이 나온다 — 「없다」가 편한 답인 자리다', () => {
-  const rows = intakeCollisions(pair.map(({ source, ...cfg }) => ({ source, connectionConfig: cfg })))
-
-  assert.equal(rows.length, 1, '행 모양을 못 알아보고 조용히 넘어갔다')
-  assert.deepEqual(rows[0].sources, ['mes-line-a', 'mes-line-b'])
-})
-
-test('★ 두 모양이 같은 답을 낸다 — 옮기기가 갈리면 여기가 빨개진다', () => {
-  const asConfig = intakeCollisions(pair.map(({ source, ...cfg }) => ({ source, config: cfg })))
-  const asRow = intakeCollisions(pair.map(({ source, ...cfg }) => ({ source, connectionConfig: cfg })))
-
-  assert.deepEqual(asRow, asConfig)
-})
-
-test('섞여 들어와도 한 충돌로 본다 — 들여오기는 실제로 행과 패키지를 함께 넘긴다', () => {
-  const mixed = intakeCollisions([
-    { source: 'mes-line-a', connectionConfig: { ...intake } },
-    { source: 'mes-line-b', config: { ...intake } }
-  ])
-
-  assert.equal(mixed.length, 1, '섞인 목록에서 한쪽만 세었다')
-  assert.deepEqual(mixed[0].sources, ['mes-line-a', 'mes-line-b'])
-})

package/test/scale-twin-bench.test.ts

@@ -1,103 +0,0 @@
-/*
- * 스케일 테스트 트윈 벤치 — 미국 공장(WMS+MES+YMS) 형태를 대규모로 스케일업, 5종 동기 엔티티 전부 부하.
- * 동기 엔티티 = locations·items(재고)·equipment·tasks·orders (노드/무버뿐이 아님). area 는 계층(건물>층>존).
- * 측정(가정 아닌 실측): masterToTwin(구조 생성)·apply(혼합 이벤트 처리량)·snapshot(전체 투영)·buildEntityDeltas(브로드캐스팅, 't1')·heap.
- * 순수 커널+호스트 매핑(shell·DB 무관) → node:test. area 는 공간층(projector State 밖)이라 처리량엔 무영향 — 구조 생성 비용에만.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { StateProjector } from '@operato/twin-kernel'
-import { objectEvent, BIZSTEP, DISP, OP_EVENT } from '@operato/ops-contract'
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-import { buildEntityDeltas } from '../shared/entity-delta.ts'
-
-const T0 = '2026-07-20T00:00:00.000Z'
-const MB = (b: number) => Math.round(b / 1048576)
-
-/** 미국 공장형 대규모 master 생성: 건물>층>존 area 계층 + 노드(storage/dock/station) + 무버(forklift/cutter/welder/hostler). */
-function bigMaster(tier: { buildings: number; floorsPer: number; zonesPer: number; nodesPerZone: number; equipment: number }) {
-  const locations: any[] = []
-  let nodeN = 0
-  for (let b = 0; b < tier.buildings; b++) {
-    locations.push({ id: `bld-${b}`, type: 'building', role: 'area', name: `건물 ${b}` })
-    for (let f = 0; f < tier.floorsPer; f++) {
-      locations.push({ id: `bld-${b}-flr-${f}`, type: 'floor', role: 'area', name: `층 ${b}-${f}`, parentId: `bld-${b}` })
-      for (let z = 0; z < tier.zonesPer; z++) {
-        const zid = `bld-${b}-flr-${f}-zn-${z}`
-        locations.push({ id: zid, type: 'zone', role: 'area', name: `존 ${b}-${f}-${z}`, parentId: `bld-${b}-flr-${f}` })
-        for (let n = 0; n < tier.nodesPerZone; n++) {
-          const t = n % 4 === 0 ? 'dock' : n % 4 === 1 ? 'staging' : 'storage'
-          locations.push({ id: `nd-${nodeN}`, type: t, role: 'location', name: `노드 ${nodeN}`, parentId: zid, capacity: 500, footprint: { x: nodeN % 100, y: (nodeN / 100) | 0, w: 1, h: 1 } })
-          nodeN++
-        }
-      }
-    }
-  }
-  const KINDS = ['forklift', 'cutter', 'welder', 'hostler']
-  const equipment = Array.from({ length: tier.equipment }, (_, i) => ({ id: `mv-${i}`, kind: KINDS[i % 4], homeLocationId: `nd-${i % nodeN}` }))
-  return {
-    master: { source: 'scale-us', system: 'wms' as const, siteName: 'US 공장(스케일)', space: { width: 500, depth: 300, unit: 'm', geo: { lat: 32.7, lon: -117.1 } }, locations, equipment },
-    locationCount: nodeN,
-    areaCount: locations.filter(l => l.role === 'area').length
-  }
-}
-
-function itemEnv(i: number, location: string): any {
-  const ev = objectEvent({ eventTime: T0, action: 'OBSERVE' as any, bizStep: BIZSTEP.storing, disposition: DISP.sellable, epcList: [`urn:epc:id:sscc:0614141.${i}`], readPoint: location })
-  return { eventId: `i${i}`, eventType: `epcis.${ev.type}`, eventTime: T0, tenantId: 't', data: ev }
-}
-const equipmentEnv = (id: string, kind: string, loc: string): any => ({ eventId: id, eventType: OP_EVENT.equipment, eventTime: T0, tenantId: 't', data: { moverId: id, kind, status: 'running', location: loc } })
-const taskEnv = (id: string, to: string): any => ({ eventId: id, eventType: OP_EVENT.task, eventTime: T0, tenantId: 't', data: { taskId: id, kind: 'move', status: 'in-progress', toNode: to } })
-const orderEnv = (id: string): any => ({ eventId: id, eventType: OP_EVENT.order, eventTime: T0, tenantId: 't', data: { orderId: id, kind: 'inbound', status: 'in-progress', requested: 100, fulfilled: 50 } })
-
-const TIERS = {
-  medium: { buildings: 3, floorsPer: 3, zonesPer: 4, nodesPerZone: 8, equipment: 80, items: 30000, tasks: 2000, orders: 500 },
-  large: { buildings: 6, floorsPer: 4, zonesPer: 6, nodesPerZone: 12, equipment: 300, items: 120000, tasks: 10000, orders: 2000 }
-}
-
-for (const [name, tier] of Object.entries(TIERS)) {
-  test(`스케일 트윈 [${name}] — 구조 생성 + 5종 엔티티 부하 실측`, () => {
-    // 1) 구조 생성(masterToTwin) — 노드·무버·area 계층
-    const { master, locationCount, areaCount } = bigMaster(tier)
-    let t = performance.now()
-    const { model, spaceContent } = masterToTwin(master)
-    const tMaster = performance.now() - t
-    console.log(`\n  [${name}] 구조: 노드 ${locationCount.toLocaleString()} · 무버 ${tier.equipment} · area ${areaCount}(계층) · masterToTwin ${tMaster.toFixed(0)}ms`)
-    assert.equal(model.locations.length, locationCount)
-    assert.equal((spaceContent.areas ?? []).length, areaCount, 'area 계층 생성')
-
-    const proj = new StateProjector(model)
-    const equipment = model.equipment as any[]
-
-    // 2) apply 처리량 — 5종 혼합(items·equipment·tasks·orders)
-    t = performance.now()
-    for (let i = 0; i < tier.items; i++) proj.apply(itemEnv(i, `nd-${i % locationCount}`))
-    for (let i = 0; i < tier.equipment; i++) proj.apply(equipmentEnv(equipment[i].id, equipment[i].kind, `nd-${i % locationCount}`))
-    for (let i = 0; i < tier.tasks; i++) proj.apply(taskEnv(`tk-${i}`, `nd-${i % locationCount}`))
-    for (let i = 0; i < tier.orders; i++) proj.apply(orderEnv(`or-${i}`))
-    const total = tier.items + tier.equipment + tier.tasks + tier.orders
-    const tApply = performance.now() - t
-    console.log(`  [${name}] apply: ${total.toLocaleString()} 이벤트(items+equipment+tasks+orders) ${tApply.toFixed(0)}ms = ${Math.round((total / tApply) * 1000).toLocaleString()} ev/s`)
-
-    // 3) snapshot(전체 투영) — 5종 전부
-    let s: any
-    const iters = 30
-    t = performance.now()
-    for (let k = 0; k < iters; k++) s = proj.snapshot()
-    const tSnap = (performance.now() - t) / iters
-    console.log(`  [${name}] snapshot: ${tSnap.toFixed(2)}ms/call (items ${s.items.length.toLocaleString()}·locations ${s.locations.length.toLocaleString()}·equipment ${s.equipment.length}·tasks ${s.tasks.length}·orders ${s.orders.length}) → 최대 ${Math.round(1000 / tSnap).toLocaleString()} snap/s`)
-
-    // 4) 브로드캐스팅 payload(buildEntityDeltas)
-    t = performance.now()
-    for (let k = 0; k < iters; k++) buildEntityDeltas(s, 't1')
-    const tDelta = (performance.now() - t) / iters
-    console.log(`  [${name}] buildEntityDeltas: ${tDelta.toFixed(2)}ms/call`)
-    console.log(`  [${name}] heap: ${MB(process.memoryUsage().heapUsed)}MB`)
-
-    // 정합 sanity
-    assert.equal(s.equipment.length, tier.equipment)
-    assert.equal(s.orders.length, tier.orders)
-    assert.ok(s.items.length > 0)
-  })
-}

package/test/secrets-at-rest.test.ts

@@ -1,135 +0,0 @@
-/*
- * A column that can hold a credential has to be encrypted at rest.
- *
- * ── What this catches, and what it cost to find by hand (2026-09-09) ──────
- * `TwinReference.connectionConfig` was a plain `simple-json` column holding a signing secret
- * and a live access token. Two shell commands read both:
- *
- *     sqlite3 -readonly db.sqlite "select connection_config from twin_references"
- *     {"endpoint":"…","hookSecret":"dev-only-localhost-hook-2026","token":"eyJhbGciOi…"}
- *
- * The read path was already guarded — the detail resolver masks fields an adapter declares
- * `secret: true`. So the leak was not on the way out, it was the stored bytes: the database
- * file, its backups, its replicas. **Two different protections, and having one reads exactly
- * like having both.**
- *
- * ── Why a guard and not a review habit ────────────────────────────────────
- * The framework has had the pieces for a while — `encryptJsonTransformer` and
- * `longTextColumn` — and nothing used them together. Two packages imported the transformer and
- * left it commented out. A rule that depends on someone remembering two exports is a rule that
- * holds until the next new column.
- *
- * So the rule is measured instead: any column whose name says it can carry a credential must
- * carry an encrypting transformer. New entities are covered the day they are written.
- *
- * ── What this does not claim ──────────────────────────────────────────────
- * Encryption at rest does not protect a value from anyone who can run this process — that
- * person holds the key. It protects the stored copy, which is a different set of people.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
-
-const SERVER = fileURLToPath(new URL('../server', import.meta.url))
-
-/**
- * 이름이 「자격 증명이 들 수 있다」고 말하는 칸.
- *
- * 이름으로 판정하는 것의 한계를 적어 둔다 — `connectionConfig` 처럼 **이름이 비밀을 말하지 않는**
- * 칸이 실제로 비밀을 담고 있었다. 그래서 그 이름을 목록에 넣는다. 새 칸이 같은 부류이면 여기 더한다.
- */
-const CREDENTIAL_NAMES = /^(secret|token|password|passwd|apiKey|credential|credentials|privateKey|connectionConfig)\??$/i
-
-/** 암호화를 붙이는 방법 — 둘 중 하나면 된다(shell 이 내놓는 것). */
-const ENCRYPTED = /encryptedJsonColumn\(\)|encryptTransformer|encryptJsonTransformer/
-
-function entityFiles(dir: string, out: string[] = []): string[] {
-  for (const name of readdirSync(dir)) {
-    const full = join(dir, name)
-    if (statSync(full).isDirectory()) {
-      entityFiles(full, out)
-      continue
-    }
-    if (!full.endsWith('.ts') || full.endsWith('.d.ts')) continue
-    const src = readFileSync(full, 'utf-8')
-    if (src.includes('@Entity(')) out.push(full)
-  }
-  return out
-}
-
-/** 한 파일에서 `@Column` 선언과 그것이 붙은 속성 이름의 짝. */
-function columnsOf(src: string): { property: string; declaration: string; line: number }[] {
-  const lines = src.split('\n')
-  const out: { property: string; declaration: string; line: number }[] = []
-
-  for (let i = 0; i < lines.length; i++) {
-    if (!/^\s*@Column\(/.test(lines[i])) continue
-
-    /* 선언이 여러 줄일 수 있다 — 괄호가 닫힐 때까지 모은다. */
-    let declaration = ''
-    let depth = 0
-    let j = i
-    do {
-      declaration += lines[j]
-      for (const ch of lines[j]) {
-        if (ch === '(') depth++
-        else if (ch === ')') depth--
-      }
-      j++
-    } while (depth > 0 && j < lines.length && j - i < 12)
-
-    /* 데코레이터 다음의 첫 속성 줄 — 사이에 @Field 등이 끼어든다. */
-    for (let k = j; k < Math.min(j + 6, lines.length); k++) {
-      const m = /^\s{2}(?:readonly\s+)?([A-Za-z_][A-Za-z0-9_]*)\??\s*[:!]/.exec(lines[k])
-      if (m) {
-        out.push({ property: m[1], declaration, line: i + 1 })
-        break
-      }
-    }
-  }
-  return out
-}
-
-test('★ a column that can hold a credential is encrypted at rest', () => {
-  const offenders: string[] = []
-  let examined = 0
-
-  for (const file of entityFiles(SERVER)) {
-    const src = readFileSync(file, 'utf-8')
-    for (const column of columnsOf(src)) {
-      examined++
-      if (!CREDENTIAL_NAMES.test(column.property)) continue
-      if (ENCRYPTED.test(column.declaration)) continue
-      offenders.push(`${file.slice(SERVER.length + 1)}:${column.line}  ${column.property}`)
-    }
-  }
-
-  assert.ok(examined > 40, `본 칸이 ${examined}개다 — 찾는 방법이 깨졌다`)
-  assert.deepEqual(
-    offenders,
-    [],
-    'these columns can hold a credential and are stored in the clear:\n  ' +
-      offenders.join('\n  ') +
-      '\nAdd ...encryptedJsonColumn() (json) or transformer: encryptTransformer (string) from @things-factory/shell.\n' +
-      'Note the column type has to change with it — encryptedJsonColumn() carries both, which is why it exists.'
-  )
-})
-
-test('this guard reads real entities, so a broken scan is red and not green', () => {
-  /*
-   * 위 검사는 위반이 없으면 통과한다. **아무것도 못 읽어도** 통과하므로, 읽었다는 사실을 따로 잰다 —
-   * 오늘 이 저장소의 다른 검사가 견준 것이 0인데 초록이던 부류가 넷이었다.
-   */
-  const files = entityFiles(SERVER)
-  assert.ok(files.length > 10, `엔티티 파일이 ${files.length}개다 — 순회가 깨졌다`)
-
-  const reference = files.find(f => f.endsWith('twin-reference.ts'))
-  assert.ok(reference, 'twin-reference.ts 를 못 찾았다 — 이 검사가 생긴 이유가 그 파일이다')
-
-  const found = columnsOf(readFileSync(reference!, 'utf-8'))
-  const config = found.find(c => c.property === 'connectionConfig')
-  assert.ok(config, 'connectionConfig 칸을 못 읽었다 — 짝짓기가 깨졌다')
-  assert.match(config!.declaration, ENCRYPTED, 'connectionConfig 가 암호화되어 있지 않다')
-})

package/test/snapshot-freshness.test.ts

@@ -1,60 +0,0 @@
-/*
- * 영속 스냅샷이 **사실을 이기지 않는다** — 쓸 수 있는 조건을 못 박는다.
- *
- * 멈춘 트윈을 조회할 때마다 저널을 전량 계산하고 있었다(23,731건짜리 트윈에서 4.6초). 스냅샷은 같은
- * 폴드의 결과이므로 그 뒤로 아무 일도 없었다면 다시 계산해 봐야 같은 값이다 — 그래서 쓴다.
- *
- * 위험은 하나다: **낡은 스냅샷을 "지금" 이라고 내는 것.** 그래서 쓰는 조건을 좁게 잡았고, 그 조건을
- * 여기서 고정한다. 엔진 본체는 DB 를 물고 있어 부를 수 없으므로 판정식만 떼어 시험한다 —
- * 엔진이 쓰는 식과 **같은 식**이어야 의미가 있으므로, 식이 바뀌면 이 시험이 먼저 깨진다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-/** 엔진의 조건과 같은 식(twin-engine.recover 의 스냅샷 사용 조건). */
-const usable = (
-  cached: { revision?: number; structureRev?: number | null; state?: any } | null,
-  tip: { revision: number; structureRev: number | null },
-  asOfNow: boolean
-): boolean =>
-  !!(asOfNow && cached?.state && (cached.revision ?? 0) === tip.revision && (cached.structureRev ?? null) === tip.structureRev)
-
-const TIP = { revision: 23731, structureRev: 2 }
-const FRESH = { revision: 23731, structureRev: 2, state: { locations: [] } }
-
-test('끝에 있고 구조도 같으면 쓴다 — 다시 계산해도 같은 값이다', () => {
-  assert.equal(usable(FRESH, TIP, true), true)
-})
-
-test('이벤트가 더 있으면 쓰지 않는다 — 그 사이의 사실이 빠진다', () => {
-  assert.equal(usable({ ...FRESH, revision: 23730 }, TIP, true), false)
-})
-
-test('구조가 바뀌었으면 쓰지 않는다 — 이벤트가 안 늘어도 공장이 달라졌다', () => {
-  /* 재프로비저닝이 정확히 이 모양이다: 부스를 넷 늘렸는데 새 이벤트는 아직 없다.
-     리비전만 보면 "끝" 이라 새 설비가 없는 옛 상태를 지금으로 내게 된다. */
-  assert.equal(usable({ ...FRESH, structureRev: 1 }, TIP, true), false)
-})
-
-test('구조 이력이 없던 시절의 스냅샷은 쓰지 않는다 — 모르는 것을 같다고 하지 않는다', () => {
-  const legacy = { revision: 23731, state: { locations: [] } } // structureRev 없음
-  assert.equal(usable(legacy, TIP, true), false)
-})
-
-test('구조가 양쪽 다 없으면 그것은 같은 것이다 — 없는 것끼리는 어긋나지 않는다', () => {
-  assert.equal(usable({ revision: 5, structureRev: null, state: {} }, { revision: 5, structureRev: null }, true), true)
-  assert.equal(usable({ revision: 5, state: {} }, { revision: 5, structureRev: null }, true), true)
-})
-
-test('시간여행에는 쓰지 않는다 — 그 시점까지 계산해야 한다', () => {
-  assert.equal(usable(FRESH, TIP, false), false)
-})
-
-test('상태가 비어 있는 스냅샷은 쓰지 않는다 — 빈 공장을 지금으로 내지 않는다', () => {
-  assert.equal(usable({ revision: 23731, structureRev: 2, state: null }, TIP, true), false)
-  assert.equal(usable(null, TIP, true), false)
-})
-
-test('이벤트가 하나도 없는 트윈도 성립한다 — 0 과 0 은 같다', () => {
-  assert.equal(usable({ revision: 0, structureRev: null, state: { locations: [] } }, { revision: 0, structureRev: null }, true), true)
-})