@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/reference-fill.test.ts

@@ -1,235 +0,0 @@
-/*
- * **놓친 구간을 backfill 해 채운다** — 그 길이 없었다.
- *
- * ── 무엇이 있었나 (2026-08-31, 인티그레이션 레인 지적) ────────────────────
- * 번호로 「빠졌다」를 알아채게 만들었는데, 알아챈 뒤 **그 사이를 채우는 길이 없었다.** 설계가 적어 둔
- * 길이고 양쪽이 다 읽었는데 만들지 않았다.
- *
- * ── 되풀이해 요청하는 경로에서 무너지는 것 ─────────────────────────────────────
- * 행복한 길은 짧다. 무너지는 것은 **끝나지 않는 것**이다.
- *
- *   빈 답에 물어본 번호를 그대로 돌려주는 원본  → 무한히 요청한다
- *   구멍 뒤를 이어 받는다                      → 커서가 그 번호를 지나쳐 적히고 빠진 사실은 안 온다
- *   상한에 닿았는데 조용히 끝낸다               → 사람은 다 받은 줄로 읽는다
- *
- * 셋 다 오류가 나지 않는다. 그래서 시험이 셋을 만든다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { fillSince } from '../server/service/reference/reference-fill.js'
-import { pushCursorKey, seqOf } from '../server/service/reference/hook-contract.js'
-import type { InboundBatch } from '../server/service/reference/reference-adapter.js'
-
-const CFG = { baseUrl: 'x' }
-const SITE = { siteId: 's-1' }
-const SCOPE = 'EVENTS'
-const KEY = pushCursorKey('twin-a', SCOPE)
-
-/** 번호가 붙은 봉투 한 쪽. */
-const page = (seqs: number[], scope: string = SCOPE): InboundBatch => ({
-  scope,
-  items: seqs.map(seq => ({ seq, record: { moverId: `eq-${seq}`, kind: 'press', status: 'idle' } }))
-})
-
-/** 저장본 하나 — 프로세스가 아니라 여기 산다. */
-function harness(initial?: unknown) {
-  const state = { cursor: initial as unknown, saves: 0, ingested: [] as unknown[][] }
-  return {
-    state,
-    saveCursor: async (c: Record<string, unknown>) => {
-      state.saves++
-      state.cursor = JSON.parse(JSON.stringify(c))
-    },
-    ingest: (records: unknown[]) => {
-      state.ingested.push(records)
-      return { applied: records.length, duplicates: 0, rejected: [] }
-    }
-  }
-}
-
-const run = (h: ReturnType<typeof harness>, fetch: any, maxPages?: number) =>
-  fillSince({
-    cfg: CFG,
-    site: SITE,
-    scope: SCOPE,
-    cursorKey: KEY,
-    cursor: h.state.cursor,
-    fetch,
-    ingest: h.ingest,
-    saveCursor: h.saveCursor,
-    ...(maxPages ? { maxPages } : {})
-  })
-
-/* ── 채운다 ───────────────────────────────────────────────────────────────── */
-
-test('★ 커서 다음부터 요청하고 받은 데까지 커서를 올린다', async () => {
-  const h = harness({ streams: { [KEY]: { seq: 4 } } })
-  const asked: number[] = []
-  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
-    asked.push(since)
-    return since === 4 ? page([5, 6]) : page([])
-  })
-
-  assert.deepEqual(asked, [4, 6], '받은 데부터 다시 요청한다')
-  assert.equal(out.applied, 2)
-  assert.equal(out.stopped, 'done')
-  assert.equal(seqOf(h.state.cursor, KEY), 6)
-})
-
-test('★ 커서가 없으면 0부터 요청한다. 처음 채우는 것이다', async () => {
-  const h = harness()
-  const asked: number[] = []
-  await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
-    asked.push(since)
-    return since === 0 ? page([1, 2, 3]) : page([])
-  })
-  assert.equal(asked[0], 0)
-  assert.equal(seqOf(h.state.cursor, KEY), 3)
-})
-
-test('여러 쪽을 이어 받는다', async () => {
-  const h = harness()
-  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
-    if (since === 0) return page([1, 2])
-    if (since === 2) return page([3, 4])
-    return page([])
-  })
-  assert.equal(out.applied, 4)
-  assert.equal(out.pages >= 2, true)
-  assert.equal(seqOf(h.state.cursor, KEY), 4)
-})
-
-/* ── 끝나지 않는 것을 막는다 ──────────────────────────────────────────────── */
-
-test('★ 번호가 나아가지 않으면 멈춘다 — 같은 것을 다시 주는 원본에 무한히 요청하지 않는다', async () => {
-  /*
-   * 아웃박스 계약이 「빈 묶음에는 물어본 번호를 그대로 돌려준다」이므로, 나아감을 보지 않고 요청하면
-   * 영원히 돈다. 실제로 그 계약을 쓰는 상대가 있다.
-   */
-  const h = harness({ streams: { [KEY]: { seq: 4 } } })
-  let calls = 0
-  const out = await run(h, async () => {
-    calls++
-    /* 이미 받은 번호만 돌려준다 — 커서가 나아가지 않는다. */
-    return page([3, 4])
-  })
-
-  assert.equal(out.stopped, 'no-progress')
-  assert.ok(calls <= 2, `무한히 요청했다 — ${calls}번`)
-  assert.match(String(out.detail), /나아가지 않았다/)
-})
-
-test('★ 빈 답은 끝이고 오류가 아니다', async () => {
-  const h = harness({ streams: { [KEY]: { seq: 9 } } })
-  const out = await run(h, async () => page([]))
-  assert.equal(out.stopped, 'done')
-  assert.equal(out.applied, 0)
-  assert.equal(out.detail, undefined)
-})
-
-/* ── 구멍 ─────────────────────────────────────────────────────────────────── */
-
-test('★ 구멍이 있으면 그 앞까지만 넣고 멈춘다 — 이어 받으면 빠진 사실이 다시 오지 않는다', async () => {
-  const h = harness({ streams: { [KEY]: { seq: 4 } } })
-  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) =>
-    since === 4 ? page([5, 6, 9, 10]) : page([])
-  )
-
-  assert.equal(out.stopped, 'gap')
-  assert.equal(out.applied, 2, '5·6 만 넣는다')
-  assert.equal(seqOf(h.state.cursor, KEY), 6, '커서가 구멍을 지나치지 않는다')
-  assert.match(String(out.detail), /6 다음이 7/)
-})
-
-test('★ 첫 봉투부터 구멍이면 아무것도 넣지 않고 커서도 그대로다', async () => {
-  const h = harness({ streams: { [KEY]: { seq: 4 } } })
-  const out = await run(h, async () => page([9, 10]))
-
-  assert.equal(out.stopped, 'gap')
-  assert.equal(out.applied, 0)
-  assert.equal(seqOf(h.state.cursor, KEY), 4)
-  assert.equal(h.state.ingested.length, 0, '넣을 것이 없는데 유입을 불렀다')
-})
-
-/* ── 상한 ─────────────────────────────────────────────────────────────────── */
-
-test('★ 쪽 상한에 닿으면 말한다 — 조용히 자르면 사람은 다 받은 줄로 읽는다', async () => {
-  const h = harness()
-  let n = 0
-  const out = await run(h, async () => page([++n]), 3)
-
-  assert.equal(out.stopped, 'page-limit')
-  assert.equal(out.pages, 3)
-  assert.match(String(out.detail), /남은 것이 있을 수 있다/)
-})
-
-/* ── 거절 ─────────────────────────────────────────────────────────────────── */
-
-test('★ backfill 이 실패하면 이유를 남기고 멈춘다 — 커서는 받은 데까지다', async () => {
-  const h = harness({ streams: { [KEY]: { seq: 4 } } })
-  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
-    if (since === 4) return page([5])
-    throw new Error('MES 가 응답하지 않는다')
-  })
-
-  assert.equal(out.stopped, 'refused')
-  assert.match(String(out.detail), /응답하지 않는다/)
-  assert.equal(seqOf(h.state.cursor, KEY), 5, '받은 것은 지킨다')
-})
-
-test('★ 번호가 섞인 쪽은 받지 않는다 — 밀어 받는 길과 같은 검사를 지난다', async () => {
-  const h = harness()
-  const out = await run(h, async () => ({
-    scope: SCOPE,
-    items: [{ seq: 1, record: {} }, { record: {} }]
-  }))
-
-  assert.equal(out.stopped, 'refused')
-  assert.match(String(out.detail), /mixed batch/)
-  assert.equal(h.state.ingested.length, 0)
-})
-
-test('★ 커서 열쇠에 트윈이 들어간다 — 한 연결의 두 공장이 계수기를 함께 쓰지 않는다', async () => {
-  const other = pushCursorKey('twin-b', SCOPE)
-  const h = harness({ streams: { [KEY]: { seq: 4 }, [other]: { seq: 100 } } })
-  await run(h, async (_c: any, _s: any, _sc: string, since: number) => (since === 4 ? page([5]) : page([])))
-
-  assert.equal(seqOf(h.state.cursor, KEY), 5)
-  assert.equal(seqOf(h.state.cursor, other), 100, '다른 공장의 번호를 건드렸다')
-})
-
-/* ── 원본이 가진 번호 범위 ──────────────────────────────────────────────────── */
-
-test('★ 원본이 말한 번호 범위를 그대로 낸다 — 커서와 견주려면 이 값이 있어야 한다', async () => {
-  const got = await fillSince({
-    cfg: {},
-    site: { siteId: 's' },
-    scope: 'EVENTS',
-    cursorKey: 'i::EVENTS',
-    cursor: {},
-    fetch: async () => ({ items: [{ seq: 1, record: {} }], scope: 'EVENTS', sourceRange: { first: 1, last: 20 } }),
-    ingest: () => ({ applied: 1, duplicates: 0, rejected: [] }),
-    saveCursor: async () => {}
-  })
-  assert.deepEqual(got.sourceRange, { first: 1, last: 20 })
-})
-
-test('★ 원본이 안 말하면 그 칸을 안 낸다 — 0 으로 채우면 「다 받았다」가 된다', async () => {
-  /*
-   * 0 을 넣으면 「원본이 1번부터 다 갖고 있다」로 읽히고, 그것이 거짓이면 「우리가 다 받았다」는
-   * 잘못된 결론이 나온다. 견주는 쪽은 「맞다」가 아니라 「모른다」로 답해야 한다.
-   */
-  const got = await fillSince({
-    cfg: {},
-    site: { siteId: 's' },
-    scope: 'EVENTS',
-    cursorKey: 'i::EVENTS',
-    cursor: {},
-    fetch: async () => ({ items: [{ seq: 1, record: {} }], scope: 'EVENTS' }),
-    ingest: () => ({ applied: 1, duplicates: 0, rejected: [] }),
-    saveCursor: async () => {}
-  })
-  assert.equal(got.sourceRange, undefined)
-  assert.equal('sourceRange' in got, false, '없는 것을 undefined 로 실으면 화면이 칸을 그린다')
-})

package/test/reference-grounding.test.ts

@@ -1,70 +0,0 @@
-/*
- * ★ 커넥터의 **근거 수준** — 목으로 확인한 것을 확인으로 부르지 않는다.
- *
- * ── 왜 이 축이 생겼나 (2026-08-23, 토대 릴리즈 준비) ────────────────────────
- * 등록된 커넥터 열넷 중 실 시스템에 붙어 본 것은 **하나**다(첫 실 연동). 나머지는 목에 대고 만들었다.
- * 그런데 화면의 커넥터 목록에 그 구분이 없어서 **목으로 확인한 것이 확인으로 보인다.**
- *
- * 이 저장소는 같은 모양을 능력 축에서 이미 거절했다 — 「선언만 있는 능력은 사용자에게 거짓말이 된다」
- * (§`capabilitiesOf`). 그 규율을 근거에도 세운다.
- *
- * ── 무엇을 검증할 수 있고 무엇을 못 하나 ────────────────────────────────────
- * 능력은 구현이 있는지 보아 선언을 검증할 수 있다. **근거는 볼 수 없다** — 사람이 아는 사실이다.
- * 그래서 검증할 수 있는 하나만 검증한다: **실 시스템을 주장하면 무엇에 대고인지 말해야 한다.**
- * 가리키는 대상이 없는 주장은 주장이 아니고, 그런 주장은 낡아도 아무도 알 수 없다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { groundingOf, type ReferenceAdapter } from '../server/service/reference/reference-adapter.ts'
-
-const adapter = (grounding?: any) => ({ type: 't', grounding } as unknown as ReferenceAdapter)
-
-test('선언이 없으면 「모른다」다 — 「목이다」가 아니다', () => {
-  /*
-   * 둘을 같게 두면 아직 선언하지 않은 새 커넥터가 목으로 낙인찍힌다 — 그것도 없는 사실이다.
-   * 화면은 `unknown` 을 「아직 밝히지 않았다」로 말해야 한다.
-   */
-  assert.deepEqual(groundingOf(adapter()), { level: 'unknown' })
-  assert.deepEqual(groundingOf(undefined), { level: 'unknown' })
-})
-
-test('실 시스템을 주장하면 무엇에 대고인지 말해야 한다 — 아니면 주장이 내려간다', () => {
-  /* ★ 이 가드의 핵심. 대상 없는 주장은 낡아도 아무도 모른다. */
-  for (const level of ['instance', 'product'] as const) {
-    const g = groundingOf(adapter({ level }))
-    assert.equal(g.level, 'unknown', `${level} 주장이 대상 없이 통과하면 안 된다`)
-    assert.match(g.downgraded ?? '', /does not say what it was verified against/)
-    assert.match(g.downgraded ?? '', new RegExp(level), '무엇을 주장했는지 함께 말한다')
-  }
-  /* 여백만 있는 것도 비어 있는 것이다 — 형식을 채워 통과하지 못하게. */
-  assert.equal(groundingOf(adapter({ level: 'instance', verifiedAgainst: '   ' })).level, 'unknown')
-})
-
-test('대상을 말하면 그 주장이 선다', () => {
-  const g = groundingOf(adapter({ level: 'instance', verifiedAgainst: 'chef v1 · jejoup / pocheon' }))
-  assert.equal(g.level, 'instance')
-  assert.equal(g.verifiedAgainst, 'chef v1 · jejoup / pocheon')
-  assert.equal(g.downgraded, undefined)
-})
-
-test('목과 가상은 대상 없이도 선다 — 그 자체가 사실이다', () => {
-  /*
-   * `mock` 은 「실 시스템에 붙어 본 적이 없다」는 사실이고 그것을 말하는 데 대상이 필요하지 않다.
-   * `synthetic` 은 한계가 아니라 **성질**이다 — 가상 원본은 스스로 만들어 낸다.
-   */
-  assert.equal(groundingOf(adapter({ level: 'mock' })).level, 'mock')
-  assert.equal(groundingOf(adapter({ level: 'synthetic' })).level, 'synthetic')
-})
-
-test('instance 와 product 를 가른다 — 그 구분이 이 어휘의 요점이다', () => {
-  /*
-   * 첫 실 연동에서 그 배포만의 성질이 넷 드러났는데(관계 리솔버가 다른 테넌트의 행을 답한다 · 모르는
-   * 필터를 알리지 않고 무시한다 · 지워진 품목의 BOM 이 남아 있다 · 사실상 무한을 뜻하는 표식) **그것이
-   * 제품의 성질인지 그 인스턴스의 성질인지 아무도 모른다.** 두 번째 배포가 붙는 날 갈린다.
-   *
-   * 그래서 하나로 확인한 것을 `product` 라 부르면 안 되고, 어휘가 그 구분을 담는다.
-   */
-  const one = groundingOf(adapter({ level: 'instance', verifiedAgainst: '한 배포' }))
-  const many = groundingOf(adapter({ level: 'product', verifiedAgainst: '세 배포' }))
-  assert.notEqual(one.level, many.level, '두 수준이 같은 값으로 뭉개지지 않는다')
-})

package/test/reference-hook.test.ts

@@ -1,177 +0,0 @@
-/*
- * ★ 연결된 시스템이 밀어 주는 사실을 받는 자리 — 규약을 시험이 지킨다.
- *
- * ── 왜 만들었나 (2026-08-26 · 사용자 지시) ──────────────────────────────────
- * 지금 모든 커넥터가 주기적으로 물어봅니다. 그러면 연결된 시스템이 값을 갱신하는 주기보다 자주 묻게
- * 되고, 그쪽 서버에 그만큼 부담을 줍니다. 태양광 발전소에 10초마다 물으면서 10분마다 바뀌는 값을
- * 받아 왔고, 그날 그쪽 서버가 부하로 멈췄습니다.
- *
- * ── 무엇을 지키나 ───────────────────────────────────────────────────────────
- * 응답 코드가 규약입니다. 밀어 주는 쪽은 그 코드로 재시도를 정하므로, 우리가 아무렇게나 주면 고칠 수
- * 없는 것을 영원히 다시 보내거나, 잠깐의 문제로 사라진 사실을 아무도 모릅니다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { WEBHOOK_STATUS, webhookSenderAction } from '@operato/ops-contract'
-import { signWebhook, WEBHOOK_HEADER } from '@operato/ops-contract/webhook'
-
-import {
-  authorizeHook,
-  producedInstance,
-  secretFromHeaders,
-  secretMatches,
-  seqOf,
-  withSeq
-} from '../server/service/reference/hook-contract.js'
-
-test('★ 비밀값을 두 가지 방식으로 받는다 — 밀어 주는 쪽의 관습이 갈린다', () => {
-  assert.equal(secretFromHeaders({ 'x-twin-hook-secret': 'abc' }), 'abc')
-  assert.equal(secretFromHeaders({ authorization: 'Bearer abc' }), 'abc')
-  assert.equal(secretFromHeaders({ authorization: 'bearer  abc ' }), 'abc')
-  assert.equal(secretFromHeaders({}), '')
-  assert.equal(secretFromHeaders(undefined), '')
-})
-
-test('★ 전용 헤더가 먼저다 — 둘 다 오면 헷갈리지 않는다', () => {
-  assert.equal(secretFromHeaders({ 'x-twin-hook-secret': 'first', authorization: 'Bearer second' }), 'first')
-})
-
-test('★ 빈 비밀값은 어떤 것과도 맞지 않는다 — 선언하지 않은 연결은 훅을 받지 않는다', () => {
-  assert.equal(secretMatches('', ''), false)
-  assert.equal(secretMatches('anything', ''), false)
-  assert.equal(secretMatches('', 'expected'), false)
-})
-
-test('★ 비밀값 비교는 길이가 같으면 전부를 본다 — 응답 시간으로 알아내지 못하게', () => {
-  assert.equal(secretMatches('secret-value', 'secret-value'), true)
-  assert.equal(secretMatches('secret-valuX', 'secret-value'), false)
-  assert.equal(secretMatches('Xecret-value', 'secret-value'), false)
-  assert.equal(secretMatches('short', 'secret-value'), false)
-})
-
-test('★ 그 연결이 만든 트윈만 받는다 — 남의 트윈에 밀어 넣지 못한다', () => {
-  const ref = {
-    scopeSpec: {
-      produced: [
-        { siteId: 'site-a', instanceId: 'twin-a' },
-        { siteId: 'site-b', instanceId: 'twin-b' }
-      ]
-    }
-  }
-  assert.deepEqual(producedInstance(ref, 'twin-b'), { siteId: 'site-b' })
-  assert.equal(producedInstance(ref, 'twin-c'), undefined)
-  assert.equal(producedInstance(null, 'twin-a'), undefined)
-  assert.equal(producedInstance({}, 'twin-a'), undefined)
-})
-
-test('★ 응답 코드 표가 계약에 있다 — 여기에 두 번째 벌을 만들지 않는다', () => {
-  /*
-   * 예전에는 이 표가 훅 규약 파일에 있었고 보내는 쪽(operato-plant)에도 있었다. 그래서 같은 409 를 양쪽이
-   * 다른 뜻으로 썼다 — 여기서는 「트윈이 안 돈다」, 저쪽에서는 「번호가 비었다」였다.
-   *
-   * 값을 여기서 다시 단정하지 않는다. 계약이 정본이고 그 시험은 계약 쪽에 있다. 여기서 지키는 것은
-   * **이 파일이 계약을 쓰고 있는가**다.
-   */
-  assert.equal(WEBHOOK_STATUS.sequenceGap, 409, '409 는 번호가 비었다는 뜻이다')
-  assert.equal(WEBHOOK_STATUS.notLive, 503, '트윈이 안 도는 것은 503 이다')
-})
-
-test('★ 트윈이 돌지 않으면 200 을 주지 않는다 — 그쪽이 그 사실을 버린다', () => {
-  /*
-   * 200 은 「받아서 반영했다」는 뜻이다. 트윈이 실시간으로 돌지 않아 한 건도 반영되지 않았는데 200 을
-   * 주면, 밀어 주는 쪽은 전달된 줄 알고 그 사실을 버린다.
-   *
-   * 그렇다고 4xx 를 주면 「보낸 요청이 잘못됐다」는 뜻이라 그쪽이 포기할 근거가 된다. 트윈은 누가
-   * 띄우면 다시 도므로 들고 기다리는 것이 맞다.
-   */
-  assert.notEqual(WEBHOOK_STATUS.notLive, WEBHOOK_STATUS.ok)
-  assert.equal(webhookSenderAction(WEBHOOK_STATUS.notLive), 'wait')
-})
-
-/* ── 인증 — 비밀값과 서명 ─────────────────────────────────────────────────── */
-
-const SECRET = 'shared-secret'
-const NOW = Date.parse('2026-08-31T02:00:00.000Z')
-const TS = '2026-08-31T02:00:00.000Z'
-const BODY = '{"batch":[{"seq":1,"scope":"EVENTS","record":{}}]}'
-
-test('★ 서명이 오면 서명을 본다', () => {
-  const headers = {
-    [WEBHOOK_HEADER.timestamp]: TS,
-    [WEBHOOK_HEADER.signature]: signWebhook(SECRET, TS, BODY)
-  }
-  assert.deepEqual(authorizeHook({ headers, rawBody: BODY, secret: SECRET, nowMs: NOW }), {
-    ok: true,
-    method: 'signature'
-  })
-})
-
-test('★ 서명이 없으면 비밀값을 본다 — 이미 붙어 있는 커넥터가 그 방식이다', () => {
-  const got = authorizeHook({ headers: { 'x-twin-hook-secret': SECRET }, rawBody: BODY, secret: SECRET, nowMs: NOW })
-  assert.deepEqual(got, { ok: true, method: 'secret' })
-})
-
-test('★ 서명이 왔는데 받은 바이트가 없으면 거절한다 — 확인할 수 없는 것을 통과시키지 않는다', () => {
-  /*
-   * 파싱한 객체를 다시 문자열로 만들어 확인하고 싶어지는데, 키 순서와 공백이 달라져 어차피 맞지 않는다.
-   * 맞지 않는 것을 통과시키면 서명이 있으나 마나 한 것이 된다.
-   */
-  const headers = {
-    [WEBHOOK_HEADER.timestamp]: TS,
-    [WEBHOOK_HEADER.signature]: signWebhook(SECRET, TS, BODY)
-  }
-  const got = authorizeHook({ headers, rawBody: undefined, secret: SECRET, nowMs: NOW })
-  assert.equal(got.ok, false)
-  assert.match((got as any).reason, /raw body/)
-})
-
-test('★ 서명이 왔으면 비밀값 헤더로 넘어가지 않는다 — 맞는 비밀값을 함께 실어도 서명이 틀리면 거절이다', () => {
-  const headers = {
-    'x-twin-hook-secret': SECRET,
-    [WEBHOOK_HEADER.timestamp]: TS,
-    [WEBHOOK_HEADER.signature]: 'deadbeef'
-  }
-  const got = authorizeHook({ headers, rawBody: BODY, secret: SECRET, nowMs: NOW })
-  assert.equal(got.ok, false)
-})
-
-test('거절 사유가 무엇을 고칠지 말한다', () => {
-  const stale = new Date(NOW - 10 * 60_000).toISOString()
-  const headers = {
-    [WEBHOOK_HEADER.timestamp]: stale,
-    [WEBHOOK_HEADER.signature]: signWebhook(SECRET, stale, BODY)
-  }
-  const got = authorizeHook({ headers, rawBody: BODY, secret: SECRET, nowMs: NOW })
-  assert.deepEqual(got, { ok: false, reason: 'signature expired' })
-})
-
-/* ── 커서에 번호를 적는 자리 ──────────────────────────────────────────────── */
-
-test('★ 번호는 폴링이 쓰는 커서와 같은 자리에 산다 — 진행 위치를 두 벌로 두지 않는다', () => {
-  const before = { streams: { EVENTS: { since: '2026-08-30T00:00:00.000Z', seen: ['a'] } }, firstAttachedAt: 'x' }
-  const after = withSeq(before, 'EVENTS', 918342)
-
-  assert.equal(seqOf(after, 'EVENTS'), 918342)
-  assert.equal((after as any).streams.EVENTS.since, before.streams.EVENTS.since, 'since 를 지우지 않는다')
-  assert.deepEqual((after as any).streams.EVENTS.seen, ['a'], 'seen 을 지우지 않는다')
-  assert.equal((after as any).firstAttachedAt, 'x', '커서의 다른 항목을 지우지 않는다')
-})
-
-test('★ 다른 흐름의 번호를 건드리지 않는다 — 한 단위를 올리면서 다른 단위를 되돌리면 그 구간이 다시 온다', () => {
-  const before = { streams: { EVENTS: { seq: 10 }, MASTER: { seq: 4 } } }
-  const after = withSeq(before, 'EVENTS', 11)
-  assert.equal(seqOf(after, 'EVENTS'), 11)
-  assert.equal(seqOf(after, 'MASTER'), 4)
-})
-
-test('번호가 없는 흐름은 「모른다」다 — 0 으로 메우지 않는다', () => {
-  assert.equal(seqOf(undefined, 'EVENTS'), undefined)
-  assert.equal(seqOf({}, 'EVENTS'), undefined)
-  assert.equal(seqOf({ streams: {} }, 'EVENTS'), undefined)
-  assert.equal(seqOf({ streams: { EVENTS: { since: 'x' } } }, 'EVENTS'), undefined)
-})
-
-test('커서가 없던 연결에도 번호를 적을 수 있다', () => {
-  assert.equal(seqOf(withSeq(undefined, 'EVENTS', 1), 'EVENTS'), 1)
-})

package/test/reference-links.test.ts

@@ -1,56 +0,0 @@
-/*
- * 원본에만 있는 관계를 화면에 낼 수 있는지 판정하는 부분.
- *
- * 조회 자체는 DB 와 어댑터를 물어야 돌아가므로 테스트가 다루지 않는다. 여기서 확인하는 것은
- * 원본이 준 값을 그대로 믿지 않는다는 것이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { usableLinkGroups } from '../server/service/reference/reference-link-groups.js'
-
-test('정상 그룹은 그대로 남는다', () => {
-  const got = usableLinkGroups([
-    { via: 'mes.rel.report', from: 'productionReports', tense: 'past', ids: ['PR-1'], total: 2 }
-  ])
-  assert.equal(got.length, 1)
-  assert.equal(got[0].tense, 'past')
-})
-
-test('★ 전체 수가 없는 그룹은 버린다 — 화면이 목록 길이를 전체 수로 쓰게 된다', () => {
-  /*
-   * 원본이 20개만 보내고 전체 수를 빼면, 실제 200건이 화면에 20건으로 표시된다. 오류가 나지
-   * 않으므로 아무도 알아채지 못한다.
-   */
-  const got = usableLinkGroups([{ via: 'mes.rel.report', from: 'x', ids: ['a', 'b'] } as any])
-  assert.equal(got.length, 0)
-})
-
-test('전체 수가 0 인 그룹은 버린다 — 원본이 그 축을 취급하지 않는다는 뜻이다', () => {
-  assert.equal(usableLinkGroups([{ via: 'v', from: 'f', ids: [], total: 0 }]).length, 0)
-})
-
-test('이름이 없는 그룹은 버린다 — 화면에 이름 없는 줄이 된다', () => {
-  const got = usableLinkGroups([
-    { via: '', from: 'f', ids: ['a'], total: 1 },
-    { via: '   ', from: 'f', ids: ['a'], total: 1 },
-    { from: 'f', ids: ['a'], total: 1 } as any
-  ])
-  assert.equal(got.length, 0)
-})
-
-test('원본이 아무것도 안 주거나 목록에 빈 값이 섞여도 견딘다', () => {
-  assert.deepEqual(usableLinkGroups(undefined), [])
-  assert.deepEqual(usableLinkGroups(null), [])
-  assert.equal(usableLinkGroups([null as any, undefined as any]).length, 0)
-})
-
-test('★ 이 테스트가 실제로 무언가를 확인한다 — 통과와 탈락이 둘 다 있어야 한다', () => {
-  const got = usableLinkGroups([
-    { via: 'ok', from: 'f', ids: ['a'], total: 1 },
-    { via: 'no-total', from: 'f', ids: ['a'] } as any,
-    { via: '', from: 'f', ids: ['a'], total: 5 }
-  ])
-  assert.equal(got.length, 1, '통과한 것이 하나여야 한다')
-  assert.equal(got[0].via, 'ok')
-})

package/test/reference-reconciliation.test.ts

@@ -1,39 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { reconcileReferenceSequence } from '../server/service/reference/reference-reconciliation.ts'
-
-test('reports work waiting after the Twin cursor', () => {
-  const got = reconcileReferenceSequence({ source: { first: 1, last: 48 }, cursorSeq: 30, firstSeqSeen: 1 })
-  assert.equal(got.status, 'gap')
-  assert.equal(got.behind, 18)
-  assert.equal(got.headMissing, undefined)
-})
-
-test('reports the leading range only when the first received sequence proves it', () => {
-  const got = reconcileReferenceSequence({ source: { first: 1, last: 48 }, cursorSeq: 48, firstSeqSeen: 21 })
-  assert.equal(got.status, 'gap')
-  assert.equal(got.headMissing, 20)
-})
-
-test('does not claim alignment when the source range or first received sequence is unknown', () => {
-  assert.equal(reconcileReferenceSequence({ source: { first: 1 }, cursorSeq: 1, firstSeqSeen: 1 }).status, 'unknown')
-  assert.equal(reconcileReferenceSequence({ source: { first: 1, last: 1 }, cursorSeq: 1 }).status, 'unknown')
-})
-
-test('reports alignment only with both source bounds and a recorded first sequence', () => {
-  const got = reconcileReferenceSequence({ source: { first: 1, last: 48 }, cursorSeq: 48, firstSeqSeen: 1 })
-  assert.equal(got.status, 'aligned')
-})
-
-test('registers the durable reconciliation table and its migration', () => {
-  const root = join(import.meta.dirname, '..', 'server')
-  const migration = readFileSync(join(root, 'migrations', '1786800000000-CreateTwinReferenceReconciliations.ts'), 'utf8')
-  const list = readFileSync(join(root, 'migrations', 'index.ts'), 'utf8')
-  const referenceIndex = readFileSync(join(root, 'service', 'reference', 'index.ts'), 'utf8')
-  assert.match(migration, /twin_reference_reconciliations/)
-  assert.match(migration, /uq_twin_reference_reconciliation_0/)
-  assert.match(list, /CreateTwinReferenceReconciliations1786800000000/)
-  assert.match(referenceIndex, /TwinReferenceReconciliation/)
-})

package/test/registry-key-guard.test.ts

@@ -1,80 +0,0 @@
-/*
- * 런타임 레지스트리 색인 가드 — **엔진 밖에서 맵을 직접 만지지 않는다.**
- *
- * 계기(2026-08-06): `TwinEngine.instances` 가 `instanceId` 하나로 키를 잡던 시절, 엔진 밖 네 곳이 그 맵을
- * **직접 색인**했다(`TwinEngine.instances[instanceId]`, 심지어 `(TwinEngine as any).instances?.[…]`).
- * 그래서 도메인 확인이 자리마다 제각각이었고 한 곳은 아예 없었다.
- *
- * 키를 `(domainId, instanceId)` 로 고쳤지만, **직접 색인이 남아 있으면 같은 부류가 다시 자란다** — 밖에서
- * `instances[id]` 를 쓰면 이제는 항상 `undefined` 가 나와 알리지 않고 "안 돌고 있다" 로 읽힌다(더 나쁘다:
- * 오류가 아니라 거짓 사실이 된다). 그래서 접근자(`owns`·`runtime`·`kernel`·`metrics`·`snapshot`)만 쓴다.
- *
- * 이 부류는 이미 한 번 물었다 — `twin-lifecycle-mutation.ts` 주석이 증언한다("과거엔
- * `Object.keys(TwinEngine.instances)` 로 전역 반환 → 다른 도메인 트윈이 새던 버그"). 그때는 그 자리만
- * 고쳤다. 이번에는 기계가 지킨다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-const SERVER = new URL('../server', import.meta.url).pathname
-
-/** 맵을 소유한 자리 — 여기서는 색인해야 한다. */
-const OWNERS = ['engine/twin-engine.ts', 'engine/runtime-key.ts']
-
-function walk(dir: string, out: string[] = []): string[] {
-  for (const entry of readdirSync(dir)) {
-    const p = join(dir, entry)
-    if (statSync(p).isDirectory()) walk(p, out)
-    else if (p.endsWith('.ts') && !p.endsWith('.d.ts')) out.push(p)
-  }
-  return out
-}
-
-/** 주석 줄은 뺀다 — 이 결함을 설명하는 주석이 여러 곳에 있고, 그것을 위반으로 셀 수 없다. */
-const isComment = (line: string) => /^\s*(\/\/|\/\*|\*)/.test(line)
-
-test('엔진 밖에서 런타임 레지스트리를 직접 색인하지 않는다', () => {
-  const offenders: string[] = []
-
-  for (const file of walk(SERVER)) {
-    const rel = file.slice(SERVER.length + 1)
-    if (OWNERS.includes(rel)) continue
-
-    readFileSync(file, 'utf-8')
-      .split('\n')
-      .forEach((line, i) => {
-        if (isComment(line)) return
-        /*
-         * **엔진 참조가 같은 줄에 있을 때만** 위반이다(`as any` 우회 포함). `.instances[` 만 보면
-         * 무관한 배열(응답·지역 변수)까지 잡아 정당한 코드를 막는다.
-         */
-        if (/TwinEngine\s*(as\s+any\s*)?\)?\s*\.\s*(instances|recovered)/.test(line)) {
-          offenders.push(`${rel}:${i + 1}  ${line.trim().slice(0, 100)}`)
-        }
-      })
-  }
-
-  assert.deepEqual(
-    offenders,
-    [],
-    `레지스트리를 직접 색인하는 곳 ${offenders.length}곳 — 접근자(owns·runtime·kernel·metrics·snapshot)를 쓴다:\n` +
-      offenders.join('\n')
-  )
-})
-
-test('엔진이 맵을 만질 때는 항상 키 함수를 거친다', () => {
-  const src = readFileSync(join(SERVER, 'engine/twin-engine.ts'), 'utf-8')
-  const bad: string[] = []
-
-  src.split('\n').forEach((line, i) => {
-    if (isComment(line)) return
-    /* 색인하는 줄에는 `runtimeKey(` 또는 미리 만들어 둔 `key` 변수가 있어야 한다. */
-    if (!/this\.(instances|recovered)\s*\[/.test(line)) return
-    if (/runtimeKey\(/.test(line) || /\[key\]/.test(line)) return
-    bad.push(`engine/twin-engine.ts:${i + 1}  ${line.trim().slice(0, 100)}`)
-  })
-
-  assert.deepEqual(bad, [], `키 함수를 거치지 않고 색인하는 곳 ${bad.length}곳:\n${bad.join('\n')}`)
-})