@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/live-cursor-wiring.test.ts

@@ -1,87 +0,0 @@
-/*
- * ★ 읽기 커서는 **부르는 쪽이 자리를 가리켜야** 이어진다 — 커넥터는 그 이름을 알 수 없다.
- *
- * ── 무엇이 알리지 않고 끊겨 있었나 (2026-08-23) ──────────────────────────────────
- * 커서를 저장할 컬럼과 계약을 만들고 배선까지 했는데, **한 번도 저장되지 않았다.** 저장할 자리를
- * `cfg`·`site` 에서 찾으려 했기 때문이다.
- *
- *   cfg    사람이 화면에서 입력한 접속 설정 — endpoint · token · subdomain · liveLookbackDays
- *   site   커넥터가 원본에서 발견한 것 — { siteId, name }
- *
- * **둘 다 그 값을 가질 수 없다.** 레퍼런스의 이름(`TwinReference.source`)은 **호스트가 붙이는 것**이고
- * 원본은 그것을 모른다. 커넥터가 채울 수 없는 값을 커넥터에서 읽으려 한 것이 잘못이었다.
- *
- * 그리고 그 실패는 **로그로는 말했다** — 「this feed does not say which reference it reads from」.
- * 그 한 줄로 다른 레인이 바로 짚었다(알리지 않고 넘기지 않은 것이 값을 했다). 그러나 로그는 사람이 볼 때만
- * 값이 있다. 배선이 다시 끊기면 이 시험이 먼저 말한다.
- *
- * ── 왜 「늘었나」로 확인하면 안 되나 ────────────────────────────────────────
- * 재기동 뒤 수가 늘어도 그것은 커서가 이어진 증거가 아니다 — 실제로 같은 버전에 다른 변경(공정별 전이)이
- * 들어가 작업 수가 배로 늘었고, 그 사이 커서는 여전히 매번 새로 만들어졌다. 확인할 것은 **배선**이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-const DIR = join(import.meta.dirname, '..', 'server', 'service', 'reference')
-const LIVE = readFileSync(join(DIR, 'reference-live.ts'), 'utf8')
-const RESOLVER = readFileSync(join(DIR, 'reference-resolver.ts'), 'utf8')
-
-/** 주석을 걷어낸 코드만 — 「쓰지 않는다」를 적어 둔 근거가 가드를 뒤집지 않게. */
-function codeOf(src: string): string {
-  return src.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(^|[^:])\/\/.*$/gm, '$1')
-}
-
-test('커서를 저장할 자리는 부르는 쪽이 가리킨다 — cfg·site 에서 짐작하지 않는다', () => {
-  const code = codeOf(LIVE)
-  /* 커넥터가 채울 수 없는 값을 커넥터의 인자에서 읽지 않는다. */
-  assert.doesNotMatch(code, /cfg as any\)\?\.source/, 'cfg 에서 레퍼런스 이름을 찾지 않는다')
-  assert.doesNotMatch(code, /site as any\)\?\.source/, 'site 에서 레퍼런스 이름을 찾지 않는다')
-  /* 대신 인자로 받는다. */
-  assert.match(code, /loadLiveCursor\(domainId, instanceId, source\)/, '받은 이름으로 커서를 찾는다')
-  /* 가드가 스스로를 증명한다 — 주석을 걷어낸 코드가 비어 버리지 않았다. */
-  assert.match(code, /startReferenceLiveFeed/, '대상 함수가 남아 있다')
-})
-
-test('모든 호출처가 그 이름을 넘긴다 — 한 곳만 빠져도 그 경로는 알리지 않고 창이 미끄러진다', () => {
-  /*
-   * 호출처가 둘이고 **둘 다** `TwinReference` 를 들고 있다(부팅 재개 · 인제스트 직후 기동).
-   * 하나만 넘기면 그 경로로 세워진 트윈만 커서를 잃고, 그 차이는 오류 없이 들어온 것이 없다.
-   */
-  const calls = [...codeOf(LIVE).matchAll(/startReferenceLiveFeed\(([^)]*)\)/g)].map(m => m[1])
-  const resolverCalls = [...codeOf(RESOLVER).matchAll(/startReferenceLiveFeed\([\s\S]{0,200}?\)/g)].map(m => m[0])
-  const all = [...calls.filter(a => !a.includes('domainId: string')), ...resolverCalls]
-  assert.ok(all.length >= 2, `호출처를 찾지 못했다 (${all.length}) — 이 가드가 아무것도 지키지 않는다`)
-  for (const call of all) {
-    assert.match(call, /ref\.source/, `이 호출처가 레퍼런스 이름을 넘기지 않는다: ${call.replace(/\s+/g, ' ')}`)
-  }
-})
-
-test('이름이 없으면 알리지 않고 돌지 않는다 — 말한다', () => {
-  /*
-   * 커서 없이 도는 것은 「창이 매번 미끄러진다」는 뜻이고, 그 손실은 오류 없이 사라진다. 그래서 그
-   * 사실을 로그로 말한다 — 실제로 그 한 줄이 이 결함을 찾아냈다.
-   */
-  const code = codeOf(LIVE)
-  assert.match(code, /if \(!source\)[\s\S]{0,200}twinWarn/, '이름이 없으면 경고한다')
-  assert.match(code, /did not say which reference/, '무엇이 없어서 못 이었는지 말한다')
-  /* 행을 못 찾은 경우도 따로 말한다 — 이름은 왔는데 그 레퍼런스가 없는 것은 다른 사실이다. */
-  assert.match(code, /no reference row for source/, '레퍼런스 행이 없는 경우를 가려 말한다')
-})
-
-test('커서는 레퍼런스의 것이다 — 인스턴스마다 두지 않는다', () => {
-  /*
-   * 한 레퍼런스가 여러 인스턴스를 낳고(`scopeSpec.produced`) 원본을 읽는 것은 한 번이다.
-   * 인스턴스마다 커서를 두면 같은 표를 여러 번 읽는다.
-   */
-  const code = codeOf(LIVE)
-  assert.match(code, /getRepository\(TwinReference\)/, '레퍼런스 행에 저장한다')
-  assert.match(code, /liveCursor: next/, '어댑터가 준 모양을 그대로 적는다')
-  assert.doesNotMatch(code, /liveCursor[\s\S]{0,40}instanceId/, '인스턴스로 커서를 가르지 않는다')
-})
-
-test('저장 실패를 삼키지 않는다', () => {
-  /* 오류 없이 실패하면 다음 재기동에서 창이 다시 미끄러지고, 이 컬럼을 만든 이유가 사라진다. */
-  assert.match(codeOf(LIVE), /live cursor not saved/, '저장 실패를 말한다')
-})

package/test/live-feed-lease.test.ts

@@ -1,63 +0,0 @@
-/*
- * The name a live feed takes its lease under.
- *
- * This is worth a test because the failure it prevents is silent: two feeds
- * sharing one name means one of them stops, and it stops looking like
- * "someone else holds it" — the ordinary case on every instance but one, so
- * nothing gets logged and nothing looks wrong.
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { liveFeedLeaseName } from '../server/service/reference/live-feed-lease.js'
-
-test('the domain is part of the name, so two tenants do not block each other', () => {
-  /*
-   * This is the whole reason the reference layer composes the name instead of
-   * the adapter: an adapter is handed cfg and site, and neither carries a
-   * domain, so a name built there would collide across tenants.
-   */
-  const a = liveFeedLeaseName('domain-a', 'mes-line-a', 'mes')
-  const b = liveFeedLeaseName('domain-b', 'mes-line-a', 'mes')
-
-  assert.notEqual(a, b)
-  assert.ok(a.includes('domain-a'))
-})
-
-test('the instance is part of the name, so two twins on one source do not block each other', () => {
-  const a = liveFeedLeaseName('d', 'mes-line-a', 'mes')
-  const b = liveFeedLeaseName('d', 'mes-miratek', 'mes')
-
-  assert.notEqual(a, b)
-})
-
-test('the same feed always gets the same name, so a second instance sees it as taken', () => {
-  assert.equal(liveFeedLeaseName('d', 'i', 's'), liveFeedLeaseName('d', 'i', 's'))
-})
-
-test('the name says it is a live feed, so a lease table read tells you the kind of task', () => {
-  assert.ok(liveFeedLeaseName('d', 'i', 's').startsWith('twin-live::'))
-})
-
-test('a missing source still names the feed — an instance has one feed', () => {
-  const named = liveFeedLeaseName('d', 'i')
-
-  assert.equal(named, 'twin-live::d::i')
-  assert.notEqual(named, liveFeedLeaseName('d', 'other'))
-})
-
-test('a blank source is the same as none rather than an empty segment', () => {
-  assert.equal(liveFeedLeaseName('d', 'i', '   '), liveFeedLeaseName('d', 'i'))
-})
-
-test('a missing domain or instance is refused, not filled in', () => {
-  /*
-   * Composing a name from a blank would put two feeds on one row. Throwing
-   * here surfaces it at startup; filling it in would surface it as a channel
-   * that quietly stopped weeks later.
-   */
-  assert.throws(() => liveFeedLeaseName('', 'i', 's'), /domainId/)
-  assert.throws(() => liveFeedLeaseName('   ', 'i', 's'), /domainId/)
-  assert.throws(() => liveFeedLeaseName('d', '', 's'), /instanceId/)
-  assert.throws(() => liveFeedLeaseName('d', undefined as any, 's'), /instanceId/)
-})

package/test/live-feed-registry.test.ts

@@ -1,75 +0,0 @@
-/*
- * 「계측이 들어오고 있나」 — **도는 것과 받는 것을 가른다.**
- *
- * ── 무엇이 보이지 않았나 (2026-08-14) ───────────────────────────────────────
- * 미러 트윈은 커널이 돌기만 하면 「도는 중」이었다. 피드가 떨어져 있으면 그 트윈은 아무것도 받지
- * 않으면서 도는 중인데, 화면에서 두 상태가 똑같이 보였다 — 재기동 뒤 실제로 그랬고 사람은
- * 「값이 안 변하네」로 뒤늦게 알았다.
- *
- * 이 모듈은 DB 를 물지 않는다 — 그래서 배선의 모양이 아니라 **거동**을 시험한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-/*
- * **빌드 산출물을 부른다** — 이 모듈은 로그 문(`engine/log.js`)을 값으로 참조하고, 타입만 지우고 소스를
- * 실행하는 방식은 그 `.js` 경로를 `.ts` 로 바꿔 주지 않는다. 소스를 부르면 「모듈을 찾을 수 없다」로 선다.
- * **소스를 고친 뒤에는 `npm run build:server` 를 먼저 돌린다.**
- */
-import { createRequire } from 'node:module'
-
-const req = createRequire(import.meta.url)
-const { registerLiveFeedProbe, liveFeedAttached, liveFeedStateOf } = req('../dist-server/engine/live-feed-registry.js')
-
-/* 두 계층의 장부를 흉내낸다 — 커넥터 기반과 프리셋 기반. */
-const connectorFeeds = new Set<string>()
-const presetFeeds = new Set<string>()
-registerLiveFeedProbe(() => [...connectorFeeds])
-registerLiveFeedProbe(() => [...presetFeeds])
-
-test('어느 장부든 붙어 있다고 하면 붙어 있다 — 한쪽만 보면 흐르는 트윈을 끊겼다고 부른다', () => {
-  connectorFeeds.add('ems-plant-1')
-  presetFeeds.add('sap-wh-1')
-
-  assert.equal(liveFeedAttached('ems-plant-1'), true, '커넥터 기반 피드')
-  assert.equal(liveFeedAttached('sap-wh-1'), true, '프리셋 기반 피드 — 이걸 놓치면 거짓 경보가 된다')
-  assert.equal(liveFeedAttached('nobody'), false)
-})
-
-test('답하지 못하는 장부가 다른 계층의 사실을 죽이지 않는다', () => {
-  registerLiveFeedProbe(() => {
-    throw new Error('registry down')
-  })
-  /* 터진 장부 뒤에 등록된 장부의 사실도 그대로 읽혀야 한다. */
-  const late = new Set<string>(['late-twin'])
-  registerLiveFeedProbe(() => [...late])
-  assert.equal(liveFeedAttached('late-twin'), true)
-  assert.equal(liveFeedAttached('ems-plant-1'), true)
-})
-
-test('「없음」과 「해당 없음」을 섞지 않는다', () => {
-  /* 도는 미러 — 이 둘이 우리가 보이려던 구별이다. */
-  assert.equal(liveFeedStateOf({ restartPolicy: 'resync', running: true, instanceId: 'ems-plant-1' }), 'attached')
-  assert.equal(liveFeedStateOf({ restartPolicy: 'resync', running: true, instanceId: 'ems-plant-2' }), 'detached')
-
-  /* 시뮬 트윈에는 나를 피드가 **없어야 한다** — 결함이 아니라 그 트윈의 성질이다. */
-  assert.equal(liveFeedStateOf({ restartPolicy: 'resume', running: true, instanceId: 'hatio-us' }), 'not-applicable')
-  assert.equal(liveFeedStateOf({ restartPolicy: 'reset', running: true, instanceId: 'trailer-new' }), 'not-applicable')
-
-  /* 사람이 멈춰 둔 트윈에게 피드를 묻는 것은 뜻이 없다. */
-  assert.equal(liveFeedStateOf({ restartPolicy: 'resync', running: false, instanceId: 'ems-plant-1' }), 'not-applicable')
-
-  /* 선언이 없으면 미러라고 짐작하지 않는다(짐작으로 경보를 울리지 않는다). */
-  assert.equal(liveFeedStateOf({ running: true, instanceId: 'ems-plant-1' }), 'not-applicable')
-})
-
-test('목록이 그 사실을 함께 낸다 — 화면이 따로 물어야 하면 언젠가 묻지 않는다', async () => {
-  const src = await import('node:fs').then(fs =>
-    fs.readFileSync(new URL('../server/engine/twin-engine.ts', import.meta.url), 'utf-8')
-  )
-  const at = src.indexOf('static async list(')
-  assert.ok(at >= 0, 'list() 가 없다 — 이름이 바뀌었으면 이 검사도 함께 고친다')
-  const body = src.slice(at, src.indexOf('\n  /** 운영 공간 목록', at))
-  assert.match(body, /liveFeed: liveFeedStateOf\(/, '관리 목록 행에 피드 사실이 실려야 한다')
-  assert.match(body, /restartPolicy: r\.restartPolicy/, '선언된 모드를 넘겨야 한다(짐작하지 않는다)')
-})

package/test/live-kernel-facts.test.ts

@@ -1,161 +0,0 @@
-/*
- * 라이브에서 **커널이 낸 사실**이 사라지지 않는다 — 저널에 남고, 인입은 두 번 적히지 않는다.
- *
- * ── 실측 (2026-08-14) ───────────────────────────────────────────────────────
- * 에너지 트윈에 커넥터를 붙여 표본을 흘렸다. 저널에 `energy.measured` 48건이 쌓였는데 **구간 마감은
- * 0건**이었다. 커널은 15분 경계에서 마감 사실을 내고 있었지만(`emitOp`) 라이브 경로에 그것을 구독하는
- * 곳이 없어서 **커널 안에서 사라졌다.** 저널을 읽는 성과 화면의 전력 타일은 영원히 나오지 않는다.
- *
- * sim 은 `runtime.subscribe` 로 같은 일을 한다 — 라이브에만 그 배선이 없었다.
- *
- * 이 시험이 지키는 것 둘:
- *  ① 라이브 기동은 커널 사건을 구독한다(그 사실이 저널로 간다)
- *  ② 인입 봉투는 **한 번만** 적힌다 — `apply()` 가 그것을 구독자에게 되흘리기 때문이다
- *
- * 엔진은 DB·shell 을 물고 있어 단위 시험이 불러올 수 없다. 그래서 **배선의 모양**을 소스로 지킨다 —
- * 실제 거동은 실서버에서 확인했고(그때 이 결함이 드러났다), 여기서는 그 배선이 사라지지 않게 한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-
-/** 그 정적 메서드의 본문만 — 다음 메서드 선언까지. `async` 도 찾는다(빠뜨리면 있는 메서드를 없다고 한다). */
-function methodOf(name: string): string {
-  const at = [`static ${name}(`, `static async ${name}(`].map(sig => src.indexOf(sig)).find(i => i >= 0) ?? -1
-  assert.ok(at >= 0, `${name} 가 없다 — 이름이 바뀌었으면 이 검사도 함께 고친다`)
-  const next = src.indexOf('\n  static ', at + 10)
-  return src.slice(at, next < 0 ? undefined : next)
-}
-
-test('라이브 기동이 커널 사건을 구독한다 — 판정이 저널로 가는 유일한 길', () => {
-  const body = methodOf('startLive')
-  assert.match(body, /kernel\.onEvent\?\.\(/, '구독이 없으면 커널의 마감·피크·제안이 사라진다')
-  assert.match(body, /pendingJournal/, '구독한 사실은 저널 배치로 가야 한다')
-  /* 예전에는 `unsub: () => {}` 로 아무것도 구독하지 않았다 — 그 모양으로 되돌아가지 않게 못 박는다. */
-  assert.equal(
-    /unsub: \(\) => \{\}[\s\S]{0,80}$/.test(body.trim()),
-    false,
-    'startLive 가 아무것도 구독하지 않는 모양으로 되돌아갔다'
-  )
-})
-
-test('인입 봉투는 저널에 한 번만 적힌다 — apply 가 그것을 되흘린다', () => {
-  const start = methodOf('startLive')
-  const ingest = methodOf('ingestLive')
-  /* 표시하고(ingest) 걸러낸다(구독). 둘 중 하나만 있으면 인입이 두 번 적히거나 표시가 무의미해진다. */
-  assert.match(ingest, /applying\?\.add\(/, '인입 봉투를 표시해야 한다')
-  assert.match(start, /applying\.has\(/, '표시된 봉투는 구독에서 건너뛰어야 한다')
-})
-
-test('식별자가 아니라 **객체 동일성**으로 가른다 — 어댑터의 id 규칙에 기대지 않게', () => {
-  const start = methodOf('startLive')
-  assert.match(start, /WeakSet<object>/, '약한 참조로 표시한다(따로 비울 것이 없다)')
-  /* eventId 비교는 어댑터가 id 를 어떻게 만드는지에 기대게 되어 약하다 — 그 방식으로 되돌아가지 않게. */
-  assert.equal(/applying\.has\(e\.eventId\)/.test(start), false, 'id 비교로 되돌아갔다')
-})
-
-test('커널이 낸 사실도 브로드캐스팅을 예약한다 — 피크·마감은 상태를 바꾼다', () => {
-  const body = methodOf('startLive')
-  assert.match(body, /inst\.dirty = true/, '상태가 바뀌었으므로 다음 주기에 브로드캐스팅해야 한다')
-  assert.match(body, /ensureBroadcastCoalescer\(\)/, '브로드캐스팅은 주기로 합친다(사건마다 브로드캐스팅하면 폭발한다)')
-})
-
-/*
- * ── 구조 전환도 브로드캐스팅한다 (2026-08-18) ───────────────────────────────────────
- * 화면이 보는 것 상당수가 구조에서 파생된다(계약 대비 판정·주목 신호·자리 색). 구조 전환이 알리지 않고
- * 끝나면 지도 레일은 다음 계측 표본이 올 때까지 옛 화면을 들고 있고, 헤더 배지는 폴링으로 먼저 알아
- * 「배지엔 있고 목록엔 없는」 어긋난 화면이 된다(실화면에서 봤다).
- */
-test('구조 전환은 상태 브로드캐스팅을 예약한다 — 다음 표본까지 화면이 옛것을 들고 있지 않게', () => {
-  const body = methodOf('adoptStructure')
-  assert.match(body, /inst\.dirty = true/, '구조가 바뀐 순간이 상태가 바뀐 순간이다')
-  assert.match(body, /ensureBroadcastCoalescer\(\)/, '새 경로가 아니라 있는 병합 규율에 얹는다')
-  /* 커널 전환보다 먼저 브로드캐스팅하면 구독자가 옛 스냅샷을 되물어 간다 — 순서가 규율이다. */
-  assert.ok(
-    body.indexOf('inst.kernel.adoptStructure(model)') < body.indexOf('inst.dirty = true'),
-    '커널을 갈고 나서 브로드캐스팅한다'
-  )
-})
-
-/*
- * ── 자를 것을 알면서 다 읽어 오지 않는다 (2026-08-18 실측) ───────────────────
- * 저널을 전량 읽어 온 뒤 JS 에서 걸렀다. 27만 건짜리 트윈에서 한 시간 전 상태를 물으면 7.4초가 걸렸고,
- * 그 대부분이 「필요 없는 행을 읽어 오는 시간」이었다. 시각·리비전 상한은 SQL 이 아는 조건이다.
- *
- * 시간 측정은 도는 서버에서 크게 흔들리므로(같은 질의 596~1547ms) **배선**을 지킨다.
- */
-test('저널 상한은 SQL 에서 자른다 — 읽고 나서 버리지 않는다', () => {
-  const body = methodOf('recover')
-  assert.match(body, /eventTime: LessThanOrEqual\(new Date\(cutoffMs\)\)/, '시각 상한은 질의 조건이다')
-  assert.match(body, /revision: LessThanOrEqual\(untilRevision\)/, '리비전 상한도 질의 조건이다')
-  /* 시각이 비어 있는 옛 행은 함께 가져온다 — SQL 로 자르면 그 행들이 빠져 예전과 다른 결과가 된다. */
-  assert.match(body, /eventTime: IsNull\(\)/, '시각 없는 레거시 행을 잃지 않는다')
-  /* 읽어 온 뒤 다시 거르지 않는다 — 두 벌이 되면 어느 쪽이 진짜 조건인지 흐려진다. */
-  assert.equal(/rows\.filter\(/.test(body), false, '읽고 나서 또 거르지 않는다')
-})
-
-test('과거 화면의 「지금」은 잘라 낸 뒤의 마지막 사실이다 — 미래 이벤트를 쓰지 않는다', () => {
-  const body = methodOf('recover')
-  /* 예전에는 전량(rows)의 마지막 시각을 썼다 — 물어본 시점보다 뒤의 이벤트라 과거 화면이 미래를
-     기준으로 「늦었다」를 판정할 수 있었다. 이제 rows 는 이미 잘린 것이다. */
-  assert.match(body, /const wanted = rows/, '자른 것과 계산하는 것이 같아야 한다')
-})
-
-/*
- * ── 재개점에서 이어서 계산한다 (2026-08-18) ──────────────────────────────────────
- * 계산한 결과는 이미 남기고 있었지만, 그 지점의 **재개점**(리듀서 내부 상태 전부 + 가동 누적기)이 없어서
- * 이벤트가 하나만 늘어도 0부터 다시 계산해야 했다. 동치는 커널 시험이 증명한다(0부터 == 재개점 + 꼬리).
- * 여기서는 **호스트가 그 씨앗을 실제로 쓰는지**를 지킨다 — 배선이 사라지면 지름길은 오류 없이 사라진다.
- */
-test('폴드가 재개점을 쓰고, 새 재개점을 함께 남긴다', () => {
-  const body = methodOf('recover')
-  assert.match(body, /replayFrom\(model, resume\.fold\.reducer/, '씨앗이 있으면 꼬리만 계산한다')
-  assert.match(body, /revision: MoreThan\(from\)/, '읽는 것도 그 뒤만')
-  assert.match(body, /oee\.restore\(resume\.fold\.oee\)/, '가동 누적기도 이어받는다(없으면 가용률이 작아진다)')
-  assert.match(body, /replayWithCheckpoint\(/, '씨앗이 없을 때도 새 재개점을 만든다')
-  assert.match(body, /keep\(withNow\(out\.state\), \{ reducer: out\.checkpoint, oee: oee\.serialize\(\) \}\)/, '재개점을 함께 저장한다')
-})
-
-test('씨앗을 좁게 쓴다 — 캐시가 사실을 이기지 않는다', () => {
-  const body = methodOf('recover')
-  /* 지금을 물었을 때만·구조가 그대로일 때만. 시간여행은 목표 이전 재개점이 필요하고(사슬은 다음 단계),
-     구조가 바뀌면 그 경계에서 갈라 계산해야 한다. */
-  assert.match(body, /asOfNowRead && tip && cachedForResume && cachedForResume\.fold/, '지금 읽기에만 쓴다')
-  assert.match(body, /\(cachedForResume\.structureRev \?\? null\) === tip\.structureRev/, '구조가 같을 때만 쓴다')
-  assert.match(body, /segments\.length <= 1/, '구조가 갈린 폴드에는 쓰지 않는다')
-})
-
-/*
- * ── 재개점 **사슬** (2026-08-18) ─────────────────────────────────────────────
- * 최신 재개점 하나로는 과거를 도울 수 없다 — 그것은 언제나 목표보다 뒤에 있다. 그래서 지점을 여러 개
- * 남기고, 과거를 물으면 **목표 직전** 지점에서 계산한다. 지점은 각각 상태 전체를 들고 있어 무겁기 때문에
- * 눈금(리비전 간격)을 넘을 때만 남기고 최근 몇 개만 든다 — 더 과거는 0부터 계산한다(알려진 한계).
- */
-test('과거 읽기는 목표 직전 지점에서 계산한다 — 사슬을 쓴다', () => {
-  const body = methodOf('recover')
-  assert.match(body, /this\.chainSeedFor\(domainId, instanceId, \{/, '과거 씨앗을 사슬에서 고른다')
-  assert.match(body, /structureCount <= 1/, '구조가 갈린 트윈에서는 쓰지 않는다')
-  assert.match(body, /revision: And\(MoreThan\(from\), LessThanOrEqual\(untilRevision\)\)/, '씨앗 뒤 · 목표 이내만 읽는다')
-  assert.match(body, /this\.keepChainPoint\(domainId, instanceId, \{/, '지점을 남긴다')
-})
-
-test('시각으로 물으면 지점의 시각도 목표 이내여야 한다 — 짐작하지 않는다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const at = src.indexOf('private static async chainSeedFor(')
-  const body = src.slice(at, src.indexOf('\n  private static async keepChainPoint(', at))
-  assert.match(body, /if \(!Number\.isFinite\(t\) \|\| t > target\.timeMs\) continue/, '시각을 모르는 지점은 쓰지 않는다')
-  assert.match(body, /if \(!value\?\.fold\?\.reducer\) continue/, '재개점 없는 지점은 씨앗이 아니다')
-})
-
-test('사슬은 눈금을 넘을 때만 자라고, 최근 몇 개만 든다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const at = src.indexOf('private static async keepChainPoint(')
-  const body = src.slice(at, src.indexOf('\n  /** 이 트윈 저널의 끝 리비전', at))
-  assert.match(body, /value\.revision - newest < this\.CHAIN_STRIDE\) return/, '눈금을 넘지 않으면 남기지 않는다')
-  assert.match(body, /slice\(-this\.CHAIN_KEEP\)/, '최근 몇 개만 든다')
-  /* 공용 캐시에 삭제 API 가 없다는 사실을 숨기지 않는다 — 버린 지점은 TTL 까지 남는다. */
-  assert.match(body, /values expire with the cache TTL/, '버린 지점의 운명을 말한다')
-})