@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/property-effects.test.ts

@@ -1,128 +0,0 @@
-/*
- * 속성 효과 등록부 — **지어낸 효과를 등록하지 않고, 있는 효과를 숨기지 않는다.**
- *
- * ── 왜 이 시험이 있나 (2026-08-18) ──────────────────────────────────────────
- * 화면은 속성마다 「무엇을 바꾸나」를 말한다. 등록되지 않은 속성에는 「표시만 됩니다」라고 한다 — 그것이
- * 정직한 기본값이다. 그런데 에너지 값들(계약전력·정격·요금)은 **오래전부터 읽히고 있었는데** 등록부에
- * 없었다: 사용자는 계약전력을 넣고도 「이 값은 아무것도 바꾸지 않는다」는 문장을 읽었다. 들어온 것이 없는 거짓말이다.
- *
- * 반대 방향의 위험도 있다: 효과를 등록해 두고 **읽는 코드가 없으면** 화면이 「쓰입니다」라고 말하는데
- * 아무 일도 일어나지 않는다. 그래서 등록부의 각 줄이 가리키는 자리를 이 시험이 확인한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { createRequire } from 'node:module'
-
-import { PROPERTY_EFFECTS, propertyEffectsOf, declarationTargetsOf } from '../server/engine/property-effects.ts'
-
-const req = createRequire(import.meta.url)
-/*
- * 커널과 계약은 각각 **한 벌로 묶인 산출물**을 내보낸다(`dist-cjs/index.cjs`) — 서브패스는 exports 로
- * 막혀 있다. 그래서 모듈마다 읽지 않고 묶음을 읽는다.
- *
- * **둘 다 읽는다** — 어휘와 판별은 계약에, 그것을 쓰는 엔진은 커널에 있다(2026-08-30 층 분리).
- * 한쪽만 읽으면 「읽는 코드가 없다」는 거짓 판정이 난다.
- */
-const kernelBundle =
-  readFileSync(req.resolve('@operato/twin-kernel'), 'utf-8') + '\n' + readFileSync(req.resolve('@operato/ops-contract'), 'utf-8')
-const hostSrc = (file: string): string => readFileSync(fileURLToPath(new URL(`../server/${file}`, import.meta.url)), 'utf-8')
-
-test('등록부의 모든 줄이 자기 자리를 가리킨다 — 빈 항목이 없다', () => {
-  for (const e of PROPERTY_EFFECTS) {
-    assert.ok(e.id, '속성 id 가 있어야 한다')
-    assert.ok(e.axes.length, `${e.id}: 어느 축의 속성인지 말해야 한다`)
-    assert.match(e.effect, /^twin\.propeffect\./, `${e.id}: 효과 문장은 i18n 키다(서버는 사람 말을 만들지 않는다)`)
-    assert.ok(e.readBy && e.readBy.length > 10, `${e.id}: 실제로 읽는 자리를 적어야 한다`)
-  }
-})
-
-test('등록한 속성 id 를 읽는 코드가 실제로 있다 — 「쓰입니다」가 거짓이 되지 않게', () => {
-  /* 읽는 쪽 소스 — 커널(에너지·환산·주행)과 호스트(요금·주행 추정). */
-  const corpus = [kernelBundle, hostSrc('engine/kpi-query.ts'), hostSrc('engine/travel-estimator.ts')].join('\n')
-
-  const missing: string[] = []
-  for (const e of PROPERTY_EFFECTS) {
-    /* id 그대로 나오거나(문자열 리터럴), 커널 어휘 상수의 마지막 마디로 나온다(EMS_PROPERTY.contractKW). */
-    const tail = e.id.includes('.') ? e.id.split('.').pop()! : e.id
-    if (!corpus.includes(`'${e.id}'`) && !corpus.includes(`"${e.id}"`) && !new RegExp(`\\b${tail}\\b`).test(corpus)) missing.push(e.id)
-  }
-  assert.deepEqual(missing, [], `읽는 코드를 찾지 못한 등록 항목:\n${missing.join('\n')}`)
-})
-
-test('에너지 값들이 등록돼 있다 — 예전에는 「표시만 됩니다」라고 말했다', () => {
-  const ids = PROPERTY_EFFECTS.map(e => e.id)
-  for (const id of ['contract.kW', 'power.ratedKW', 'storage.capacityKWh', 'tariff.demandChargePerKW', 'tariff.currency'])
-    assert.ok(ids.includes(id), `${id} 가 등록부에 없다`)
-})
-
-test('축으로 갈라 낸다 — 그 축의 항목에만 효과를 말한다', () => {
-  const locations = propertyEffectsOf('locations')
-  const equipment = propertyEffectsOf('equipment')
-  assert.ok(locations['contract.kW'], '계약전력은 자리의 속성이다')
-  assert.equal(locations['power.ratedKW'], undefined, '설비 속성을 자리에 말하지 않는다')
-  assert.ok(equipment['speed'], '속도는 설비의 속성이다')
-  assert.equal(equipment['tariff.currency'], undefined, '요금은 자리(수전)의 속성이다')
-})
-
-test('요금은 커널이 아니라 호스트가 읽는다 — 그 사실을 readBy 가 말한다', () => {
-  const tariff = PROPERTY_EFFECTS.filter(e => e.id.startsWith('tariff.'))
-  assert.equal(tariff.length, 3)
-  for (const e of tariff) assert.match(e.readBy, /kpi-query/, '금액은 저널을 계산하는 쪽이 만든다')
-})
-
-/*
- * ── 어느 대상에 얹히나 (2026-08-18) ────────────────────────────────────────
- * 지게차에 계약전력을 선언할 수 있었다 — 문은 받고 화면은 「넣었습니다」라고 말하는데, 읽는 코드는
- * 자리(수전)만 본다. 그 제한은 이미 등록부의 축이 알고 있으므로, 검사에 그 지식을 쓴다(두 곳에 적지
- * 않는다). 등록부에 없는 속성은 **제한을 모르는 것**이므로 받아 준다 — 속성은 열려 있고 효과만 닫혀 있다.
- */
-test('축이 곧 얹을 수 있는 대상이다 — 목록을 따로 적지 않는다', () => {
-  assert.deepEqual(declarationTargetsOf('contract.kW'), ['location'])
-  assert.deepEqual(declarationTargetsOf('speed'), ['equipment'])
-  assert.deepEqual(declarationTargetsOf('operation.duration'), ['operation'])
-  /* 선언 대상이 아닌 축(자재 정의)은 제한을 말하지 않는다 — 이 문의 대상이 아니다. */
-  assert.equal(declarationTargetsOf('perBaseUnit'), undefined)
-  assert.equal(declarationTargetsOf('made.up.property'), undefined, '모르는 속성은 제한도 모른다')
-})
-
-test('공정 시간이 등록돼 있고, 그 값을 실어 보내는 자리를 가리킨다', () => {
-  const e = PROPERTY_EFFECTS.find(x => x.id === 'operation.duration')!
-  assert.ok(e, '공정 시간이 등록부에 있어야 한다')
-  assert.deepEqual(e.axes, ['operations'])
-  assert.match(e.readBy, /declareDurations/, '커널의 어느 창구로 가는지 말한다')
-  /* 실어 보내는 코드가 실제로 있다 — 등록만 해 두고 아무도 나르지 않으면 화면이 거짓을 말한다. */
-  const layer = hostSrc('engine/local-declarations.ts')
-  assert.match(layer, /OPERATION_PROPERTY\.duration/, '선언 겹이 그 속성을 안다')
-  assert.match(layer, /isoDurationOf/, '커널이 읽는 표기로 바꾼다')
-  assert.match(hostSrc('engine/twin-engine.ts'), /declareDurations\(declared\)/, '기동·구조전환 때 커널에 싣는다')
-})
-
-/*
- * 모수도 같은 배선을 지난다 (2026-08-19).
- *
- * 이 시험이 소스를 보는 이유: 모수를 읽는 순간은 **작업이 완료될 때**라서 실 앱에서 관측하려면 라인이
- * 한 바퀴 돌아야 한다(복원된 25분 작업이 쌓인 트윈에서는 그 관측이 오래 걸린다 — 실제로 그랬다).
- * 값이 커널까지 가는 **경로**는 여기서 지키고, 커널이 그 값을 쓰는지는 커널 시험이 값으로 지킨다.
- */
-test('수율·셋업이 커널 창구까지 배선돼 있다 — 등록만 하고 나르지 않으면 화면이 거짓을 말한다', () => {
-  const layer = hostSrc('engine/local-declarations.ts')
-  assert.match(layer, /OPERATION_PROPERTY\.yield/, '선언 겹이 수율을 안다')
-  assert.match(layer, /OPERATION_PROPERTY\.setupDuration/, '선언 겹이 셋업을 안다')
-  /* 퍼센트 → 비율 환산은 **한 곳**이어야 한다(두 곳이면 100 이 두 번 걸린다). */
-  const divisions = layer.match(/pct \/ 100/g) ?? []
-  assert.equal(divisions.length, 1, `퍼센트 환산은 한 자리에서만 (발견 ${divisions.length})`)
-  assert.match(hostSrc('engine/twin-engine.ts'), /declareParameters\(params\)/, '기동·구조전환 때 커널에 싣는다')
-  /* 커널이 그 창구를 갖지 않은 버전이면 **말한다** — 알리지 않고 상수로 돌지 않게. */
-  assert.match(hostSrc('engine/twin-engine.ts'), /declareParameters missing/, '버전 어긋남을 경고로 드러낸다')
-})
-
-test('공정 모수가 등록부에 있고 읽는 자리를 가리킨다', () => {
-  for (const id of ['operation.yield', 'operation.setupDuration']) {
-    const e = PROPERTY_EFFECTS.find(x => x.id === id)!
-    assert.ok(e, `${id} 가 등록부에 있어야 한다`)
-    assert.deepEqual(e.axes, ['operations'])
-    assert.match(e.readBy, /declareParameters/, '어느 창구로 가는지 말한다')
-  }
-})

package/test/provenance-promotion.test.ts

@@ -1,99 +0,0 @@
-/*
- * Whether a fact was declared as having actually happened, promoted out of the payload.
- *
- * ── What this was for (measured 2026-09-09) ───────────────────────────────
- * The twin's journal held 1,134 rows and every one of them was produced by a generator. There
- * was no way to ask:
- *
- *     select count(*) from twin_events                        1134
- *     select count(*) where payload like '%SIM-%'             1134
- *     select count(*) where order_id like 'WO-SIM-%'           558   ← half of them
- *
- * The only signal was a naming convention on the sending side (`SIM-`, `WO-SIM-`), and the
- * column that convention reaches was empty on half the rows. Meanwhile the screens compute
- * yield and utilisation from those rows and cannot say what they are made of.
- *
- * ── The property that matters is the absent case ──────────────────────────
- * `null` means the sender did not declare, which is **not** "it actually happened". Reading
- * those two as the same thing is the whole defect: a generator that omits the field has its
- * output counted as production, and nothing says so.
- *
- * So most of what is asserted here is about absence, not about the two declared values.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { provenanceOf, twinEventKeys } from '../server/service/twin-event/twin-event-keys.js'
-
-const envelope = (over: Record<string, unknown> = {}) => ({
-  eventId: 'e1',
-  eventType: 'task.status',
-  eventTime: '2026-09-09T02:00:00.000Z',
-  tenantId: 't1',
-  data: { taskId: 'SIM-ECU-0001-01', status: 'completed' },
-  ...over
-})
-
-test('★ a fact declared simulated says so in a column, not only inside the payload', () => {
-  assert.equal(provenanceOf(envelope({ provenance: 'simulated' })), 'simulated')
-  assert.equal(twinEventKeys(envelope({ provenance: 'simulated' })).provenance, 'simulated')
-})
-
-test('a fact declared actual says that', () => {
-  assert.equal(provenanceOf(envelope({ provenance: 'actual' })), 'actual')
-})
-
-test('★ no declaration is not a declaration of actual — this is the defect being fixed', () => {
-  /*
-   * The payload here carries `SIM-…` in its task id, which is exactly how the 1,134 rows were
-   * recognisable by hand. The column still says nothing, because the sender said nothing. That
-   * is correct: the twin does not judge, it records what it was told.
-   *
-   * A reader has to distinguish three states. If it folds the last two together, a generator
-   * that forgets the field is counted as production.
-   */
-  assert.equal(provenanceOf(envelope()), undefined)
-  assert.equal(twinEventKeys(envelope()).provenance, undefined)
-
-  assert.notEqual(provenanceOf(envelope()), 'actual', 'absent must never resolve to actual')
-})
-
-test('a value the source made up does not reach the index', () => {
-  /*
-   * Same discipline as `actionOf`, which takes only ADD · OBSERVE · DELETE. A column with three
-   * possible values stops being answerable the moment a fourth arrives from a source we do not
-   * control.
-   */
-  for (const bogus of ['ACTUAL', 'Simulated', 'fake', 'true', '', 'sim', 1, true, null, {}]) {
-    assert.equal(provenanceOf(envelope({ provenance: bogus })), undefined, `${JSON.stringify(bogus)} reached the column`)
-  }
-})
-
-test('the declaration is read from the envelope, not from the source data', () => {
-  /*
-   * `data` is where the source system writes. If this were read from there, a source could
-   * declare its own facts actual by writing a key, and the declaration would no longer be the
-   * connecting side's statement. The envelope is ours.
-   */
-  const sneaky = envelope({ data: { taskId: 'x', provenance: 'actual' } })
-  assert.equal(provenanceOf(sneaky), undefined, 'a value inside data was promoted')
-})
-
-test('promoting it does not disturb the keys already promoted', () => {
-  /*
-   * This function is the write path's only promotion point, so adding one key is checked
-   * together with not disturbing the others.
-   */
-  const full = twinEventKeys(
-    envelope({
-      provenance: 'simulated',
-      data: { action: 'OBSERVE', bizStep: 'commissioning', epcList: ['urn:epc:id:sgtin:1.2.3'], orderId: 'WO-1' }
-    })
-  )
-
-  assert.equal(full.action, 'OBSERVE')
-  assert.equal(full.bizStep, 'commissioning')
-  assert.equal(full.epc, 'urn:epc:id:sgtin:1.2.3')
-  assert.equal(full.orderId, 'WO-1')
-  assert.equal(full.provenance, 'simulated')
-})

package/test/read-failure-ledger.test.ts

@@ -1,106 +0,0 @@
-/*
- * ★ 연결된 시스템에 닿지 못한 것과 다시 닿은 것을 인제스트 레저가 기록한다.
- *
- * ── 무엇이 없었나 (2026-08-27) ──────────────────────────────────────────────
- * 커넥터는 폴링이 실패할 때 세 가지를 안다: 연달아 몇 번인지 · 언제부터인지 · 다음에 언제 다시 묻는지.
- * 그런데 어댑터 계약에는 이유 한 줄만 받는 자리가 있었다. 그래서 커넥터가 세 가지를 **한국어 문장으로
- * 합쳐** 이유 칸에 넣고 있었다(`ppms-sunsage.ts`).
- *
- * 두 가지가 틀어진다.
- *   ① 연달아 횟수와 시작 시각은 이 레저가 **이미 센다**. 두 곳에서 세면 갈라진다.
- *   ② 그 칸은 화면에 그려지고 화면은 다섯 언어로 그린다. 한 언어의 문장은 번역되지 않는다.
- *
- * 그리고 회복을 받는 자리가 아예 없었다. 읽기가 다시 성공하면 실패 기록만 지워졌고, 그러면 밤새 두 시간
- * 끊겼던 연결과 한 번도 끊기지 않은 연결이 아침에 똑같이 보인다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  newIngestLedger,
-  recordReadFailure,
-  recordRecovered,
-  clearReadFailure,
-  ingestHealth
-} from '../server/engine/ingest-health.js'
-
-const t0 = Date.UTC(2026, 7, 27, 3, 0, 0)
-
-test('★ 연달아 실패한 횟수와 시작 시각은 레저가 센다 — 커넥터가 보내지 않는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0, 'inverters')
-  recordReadFailure(l, 'connect timeout', t0 + 60_000, 'inverters')
-  recordReadFailure(l, 'connect timeout', t0 + 120_000, 'inverters')
-  assert.equal(l.readFailure?.consecutive, 3)
-  assert.equal(l.readFailure?.sinceMs, t0, '처음 실패한 시각을 붙잡는다')
-  assert.equal(l.readFailure?.lastAtMs, t0 + 120_000)
-})
-
-test('★ 이유는 이유만 담는다 — 세는 값을 문장으로 합쳐 넣지 않는다', () => {
-  /*
-   * 이 테스트는 사람이 읽는 문장이 이유 칸에 들어가는 것을 막지 못한다(문자열은 무엇이든 담긴다).
-   * 막을 수 있는 것은 **그 값들을 담을 다른 자리가 있다**는 사실뿐이다. 그것을 테스트로 고정한다.
-   */
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0, 'inverters', 480_000)
-  assert.equal(l.readFailure?.reason, 'connect timeout')
-  assert.equal(l.readFailure?.nextRetryMs, 480_000)
-})
-
-test('다음 시도까지의 시간은 있을 때만 적는다 — 0 이나 없는 값을 「곧 다시 묻는다」로 만들지 않는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0)
-  assert.equal('nextRetryMs' in (l.readFailure as any), false)
-  recordReadFailure(l, 'connect timeout', t0 + 1000, undefined, 0)
-  assert.equal('nextRetryMs' in (l.readFailure as any), false)
-})
-
-test('★ 돌아오면 실패 기록이 사라지고 돌아온 사실이 남는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0)
-  recordReadFailure(l, 'connect timeout', t0 + 60_000)
-  recordRecovered(l, 2, 120_000, t0 + 120_000)
-  assert.equal(l.readFailure, undefined, '지금은 닿는다')
-  assert.deepEqual(l.lastRecovery, { atMs: t0 + 120_000, afterFailures: 2, downMs: 120_000 })
-})
-
-test('★ 그냥 지우면 끊긴 적이 있었다는 사실이 사라진다 — 그래서 두 함수를 나눈다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0)
-  clearReadFailure(l)
-  assert.equal(l.readFailure, undefined)
-  assert.equal(l.lastRecovery, undefined, '지우기만 하면 남지 않는다')
-})
-
-test('★ 다시 끊기면 새 단절이다 — 지난번 회복 기록이 그것을 가리지 않는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0)
-  recordRecovered(l, 1, 60_000, t0 + 60_000)
-  recordReadFailure(l, '401 unauthorized', t0 + 600_000)
-  assert.equal(l.readFailure?.consecutive, 1, '연달아 횟수가 1 부터 다시 센다')
-  assert.equal(l.readFailure?.sinceMs, t0 + 600_000)
-  assert.equal(l.lastRecovery?.atMs, t0 + 60_000, '지난 회복도 함께 보인다')
-})
-
-test('★ 밖으로 내는 모양에 두 사실이 다 있다 — 화면이 옮기지 못하면 아무 도움이 되지 않는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect timeout', t0, 'inverters', 480_000)
-  const v: any = ingestHealth(l, 'attached')
-  assert.equal(v.readFailure.consecutive, 1)
-  assert.equal(v.readFailure.reason, 'connect timeout')
-  assert.equal(v.readFailure.stream, 'inverters')
-  assert.equal(v.readFailure.nextRetryMs, 480_000)
-  assert.equal(typeof v.readFailure.since, 'string')
-
-  recordRecovered(l, 1, 480_000, t0 + 480_000)
-  const w: any = ingestHealth(l, 'attached')
-  assert.equal(w.readFailure, undefined)
-  assert.equal(w.lastRecovery.at, new Date(t0 + 480_000).toISOString())
-  assert.equal(w.lastRecovery.afterFailures, 1)
-  assert.equal(w.lastRecovery.downMs, 480_000)
-})
-
-test('닿은 적도 끊긴 적도 없으면 두 칸이 다 없다 — 없는 칸을 「끊겼다」로 읽지 않게', () => {
-  const v: any = ingestHealth(newIngestLedger(), 'attached')
-  assert.equal('readFailure' in v, false)
-  assert.equal('lastRecovery' in v, false)
-})

package/test/read-failure-visible.test.ts

@@ -1,145 +0,0 @@
-/*
- * ★ 「원본에 닿지 못한다」와 「연결된 시스템에서 들어온 것이 없다」는 **다른 사실**이다 — 상태가 그것을 가려야 한다.
- *
- * ── 무엇이 아무 신호도 내지 않았나 (2026-08-23 실측) ───────────────────────────────────────
- * 실 원본이 끊겼다(`jejoup.hatiolab.com:4000` 접속 시간 초과, HTTP 000 / 8초). 그런데 트윈의
- * **조회 가능한 상태 어디에도 그 사실이 없었다.**
- *
- *   recordIngest        `onRecords` 가 불릴 때만 도달한다 — 읽기 실패는 그 문에 오지 않는다
- *   TwinReference.lastError  마스터 동기·접속 시험에만 적힌다 — 라이브 피드는 적지 않았다
- *   계약                `openLiveFeed` 에 「읽지 못했다」를 말할 통로가 없었다
- *
- * 어댑터는 **로그로는 말하고 있었다**(재시도 경고). 그러나 로그는 사람이 볼 때만 값이 있다 — 화면이
- * 말하려면 상태에 있어야 한다. 실증 데모 중에 원본이 끊기면 사용자가 원인을 찾을 수 없다.
- *
- * ── 이 시험이 지키는 것 ─────────────────────────────────────────────────────
- * ① 실패가 상태에 남는다  ② 「몇 번」과 「언제부터」를 함께 든다(한 번의 흔들림과 20분째 단절은 다르다)
- * ③ **빈 읽기는 성공이다** — 들어온 것이 없는 연결을 끊긴 원본으로 만들지 않는다
- * ④ 조회 뷰로 나간다 — 상태에만 있고 안 나가면 화면이 못 본다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import {
-  clearReadFailure,
-  ingestHealth,
-  newIngestLedger,
-  recordIngest,
-  recordReadFailure
-} from '../server/engine/ingest-health.ts'
-
-const T0 = Date.parse('2026-08-23T06:00:00.000Z')
-
-test('실패가 상태에 남는다 — 사유와 흐름까지', () => {
-  const l = newIngestLedger()
-  assert.equal(l.readFailure, undefined, '처음에는 없다(없음이 「닿는다」는 뜻이다)')
-  recordReadFailure(l, 'connect ETIMEDOUT', T0, 'lot')
-  assert.equal(l.readFailure?.consecutive, 1)
-  assert.equal(l.readFailure?.reason, 'connect ETIMEDOUT')
-  assert.equal(l.readFailure?.stream, 'lot', '어느 표가 막혔나가 원인 찾기의 절반이다')
-})
-
-test('한 번의 흔들림과 20분째 단절을 가른다 — 시작 시각을 지킨다', () => {
-  /*
-   * 매번 새로 적으면 화면이 늘 「방금 실패했다」만 보게 되고, 계속된 단절을 대수롭지 않게 말한다.
-   */
-  const l = newIngestLedger()
-  recordReadFailure(l, 'ETIMEDOUT', T0)
-  recordReadFailure(l, 'ETIMEDOUT', T0 + 600_000)
-  recordReadFailure(l, 'ETIMEDOUT', T0 + 1_200_000)
-  assert.equal(l.readFailure?.consecutive, 3)
-  assert.equal(l.readFailure?.sinceMs, T0, '처음 실패한 시각을 지킨다')
-  assert.equal(l.readFailure?.lastAtMs, T0 + 1_200_000, '마지막 실패는 갱신된다')
-})
-
-test('빈 읽기는 성공이다 — 들어온 것이 없는 연결을 끊긴 원본으로 만들지 않는다', () => {
-  /*
-   * ★ 이 단정이 고치려던 것의 **반대 방향으로 틀리는 것**을 막는다. 원본이 「새 것이 없다」고 답한 것은
-   * 닿았다는 뜻이다.
-   */
-  const l = newIngestLedger()
-  recordReadFailure(l, 'ETIMEDOUT', T0)
-  clearReadFailure(l)
-  assert.equal(l.readFailure, undefined, '읽었으면 단절 기록이 사라진다')
-  /* 그리고 그 뒤 다시 실패하면 **새 단절**이다 — 옛 시작 시각을 물려받지 않는다. */
-  recordReadFailure(l, 'ETIMEDOUT', T0 + 3_600_000)
-  assert.equal(l.readFailure?.consecutive, 1, '연속이 끊겼으므로 1 부터')
-  assert.equal(l.readFailure?.sinceMs, T0 + 3_600_000, '새 단절의 시작이다')
-})
-
-test('조회 뷰로 나간다 — 상태에만 있으면 화면이 못 본다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect ETIMEDOUT', T0, 'inventory')
-  const v = ingestHealth(l, 'attached', undefined, T0 + 60_000)
-  assert.ok(v.readFailure, '뷰에 실려야 한다')
-  assert.equal(v.readFailure?.consecutive, 1)
-  assert.equal(v.readFailure?.since, new Date(T0).toISOString())
-  assert.equal(v.readFailure?.reason, 'connect ETIMEDOUT')
-  assert.equal(v.readFailure?.stream, 'inventory')
-})
-
-test('닿고 있으면 그 필드를 만들지 않는다 — 빈 값이 「닿는다」로 읽히지 않게', () => {
-  const l = newIngestLedger()
-  recordIngest(l, 3, [], T0)
-  const v = ingestHealth(l, 'attached', undefined, T0 + 1000)
-  assert.equal(v.readFailure, undefined)
-  /* 가드가 스스로를 증명한다 — 이 장부가 실제로 무엇을 받았다. */
-  assert.equal(v.total.offered, 3, '빈 비교로 통과하지 않는다')
-})
-
-test('「유입 없음」과 「닿지 못함」은 다른 판정이다', () => {
-  /*
-   * 유입 없음은 연결된 시스템에서 들어온 것이 없는 것일 수 있고, 닿지 못함은 우리가 묻지도 못한 것이다. 두 상태가 같은
-   * 값으로 뭉개지면 화면이 두 문장을 다르게 말할 수 없다.
-   */
-  const quiet = newIngestLedger()
-  const dark = newIngestLedger()
-  recordReadFailure(dark, 'ETIMEDOUT', T0)
-
-  const vq = ingestHealth(quiet, 'attached', undefined, T0)
-  const vd = ingestHealth(dark, 'attached', undefined, T0)
-  assert.equal(vq.lastAt, null, '들어온 것이 없는 쪽도 받은 것이 없다')
-  assert.equal(vd.lastAt, null, '끊긴 쪽도 받은 것이 없다 — 그 값만으로는 갈리지 않는다')
-  assert.notEqual(Boolean(vq.readFailure), Boolean(vd.readFailure), '이 축이 그 둘을 가른다')
-})
-
-/*
- * ── 읽기 실패가 **피드를 끄면 안 된다** (2026-08-23, 되돌린 자리) ────────────
- *
- * 처음 구현에서 읽기 실패가 레퍼런스 행의 `status` 를 `'error'` 로 적었다. 그것이 **피드를 영구히
- * 껐다**: 부팅 재부착은 `status: 'connected'` 인 레퍼런스만 되살리므로, 원본이 **잠깐** 끊긴 것이
- * 다음 재기동에서 그 트윈을 아예 굶겼다. 실측으로 그렇게 났다 — 그 버전의 로그에 `[twin-live]` 줄이
- * 한 줄도 없었다.
- *
- * 두 축을 한 칸에 섞은 것이 원인이다.
- *
- *   status      **연결 설정이 성립하나** — 접속 시험·마스터 동기가 정한다. 재부착의 **자격**이다
- *   읽기 실패    **지금 닿나** — 오갈 수 있는 사실이고 유입 장부가 그 축을 갖는다
- *
- * 「사실을 말하게」 하려던 것이 「사실을 못 듣게」 만들었다. 그 방향의 실패는 들어온 것이 없다 — 화면은
- * 「원본에 닿지 못한다」를 정직하게 말하면서, 정작 다시 닿을 기회를 잃는다.
- */
-test('읽기 실패가 레퍼런스의 status 를 건드리지 않는다 — 그것이 재부착의 자격이다', () => {
-  const src = readFileSync(join(import.meta.dirname, '..', 'server', 'service', 'reference', 'reference-live.ts'), 'utf8')
-  const code = src.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(^|[^:])\/\/.*$/gm, '$1')
-
-  const at = code.indexOf('onReadFailure:')
-  assert.ok(at > 0, 'onReadFailure 배선이 있어야 한다')
-  const body = code.slice(at, at + 600)
-
-  assert.doesNotMatch(body, /status:/, '읽기 실패는 status 를 적지 않는다 — 적으면 다음 부팅이 그 피드를 되살리지 않는다')
-  /* 대신 이유는 남긴다 — 사람이 목록에서 볼 수 있게. */
-  assert.match(body, /lastError/, '이유는 레퍼런스 행에 남긴다')
-  /* 그리고 「지금 닿나」는 장부가 답한다. */
-  assert.match(body, /recordIngestReadFailure/, '유입 장부가 그 축을 든다')
-})
-
-test('재부착의 자격은 connected 뿐이다 — 그래서 그 값을 함부로 바꾸면 안 된다', () => {
-  /*
-   * 이 단정이 위 가드의 **이유**를 못박는다. 재부착 조건이 넓어지면 위 규율의 근거가 약해지므로,
-   * 둘이 함께 움직여야 한다.
-   */
-  const src = readFileSync(join(import.meta.dirname, '..', 'server', 'service', 'reference', 'reference-live.ts'), 'utf8')
-  assert.match(src, /find\(\{ where: \{ status: 'connected' \}/, '부팅 재부착은 connected 만 되살린다')
-})

package/test/read-time.test.ts

@@ -1,118 +0,0 @@
-/*
- * ★ 저장된 값을 시각으로 읽는 규칙 — 드라이버의 문을 지난다.
- *
- * ── 무엇이 어긋났나 (2026-08-28 실측) ───────────────────────────────────────
- * `getRawOne` 은 드라이버가 준 값을 그대로 준다. sqlite 가 주는 그 값에는 시간대가 없다
- * (`2026-08-27 14:37:20.049`). 그것을 `new Date()` 로 읽으면 서버의 지역 시간으로 해석해 한국에서
- * 9시간이 밀린다. 네 자리에서 났고, 둘은 **지우는 경계**였다(경계가 이르게 밀리면 정리가 0건이 되어
- * 멈춘다).
- *
- * ── 처음에 편법을 썼다 ──────────────────────────────────────────────────────
- * 「시간대가 없으면 UTC 로 읽는다」를 응용 코드에 직접 적었다. 그것은 드라이버가 어떤 문자열로
- * 저장하는지를 우리가 아는 것이고, 다섯 드라이버 규칙에 어긋난다.
- *
- * 표준 문은 `Driver.prepareHydratedValue` 다 — 엔티티 변환이 지나는 그 함수. 이 시험은 컬럼 값을
- * 읽을 때 **우리가 해석하지 않고 그 문에 물어보는지**를 지킨다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { absoluteTime, hydratedDate } from '../server/engine/read-time.js'
-
-/** 드라이버를 흉내낸 저장소 — 이 시험이 확인하는 것은 「누가 해석하나」다. */
-const fakeRepository = (opts: { hasColumn?: boolean; hydrate?: (v: unknown) => unknown } = {}) => {
-  const calls: unknown[] = []
-  const repo = {
-    metadata: {
-      name: 'TwinEvent',
-      findColumnWithPropertyName: (name: string) => (opts.hasColumn === false ? undefined : { propertyName: name, type: Date })
-    },
-    manager: {
-      connection: {
-        driver: {
-          prepareHydratedValue: (value: unknown) => {
-            calls.push(value)
-            return opts.hydrate ? opts.hydrate(value) : new Date('2026-08-27T14:37:20.049Z')
-          }
-        }
-      }
-    }
-  }
-  return { repo: repo as any, calls }
-}
-
-test('★ 컬럼 값은 우리가 해석하지 않고 드라이버에게 물어본다', () => {
-  const { repo, calls } = fakeRepository()
-  const at = hydratedDate(repo, 'createdAt', '2026-08-27 14:37:20.049')
-  assert.equal(at?.toISOString(), '2026-08-27T14:37:20.049Z')
-  assert.deepEqual(calls, ['2026-08-27 14:37:20.049'], '드라이버의 문을 그 값으로 한 번 지나야 한다')
-})
-
-test('빈 값은 드라이버를 부르지 않고 null — 없는 것은 없는 것이다', () => {
-  const { repo, calls } = fakeRepository()
-  assert.equal(hydratedDate(repo, 'createdAt', null), null)
-  assert.equal(hydratedDate(repo, 'createdAt', undefined), null)
-  assert.deepEqual(calls, [])
-})
-
-test('드라이버가 날짜를 내주지 못하면 null — 「지금」으로 메우지 않는다', () => {
-  const { repo } = fakeRepository({ hydrate: () => 'still a string' })
-  assert.equal(hydratedDate(repo, 'createdAt', 'x'), null)
-  const bad = fakeRepository({ hydrate: () => new Date('nope') })
-  assert.equal(hydratedDate(bad.repo, 'createdAt', 'x'), null)
-})
-
-test('★ 컬럼 이름을 못 찾으면 명시 실패한다 — 이름이 바뀐 것을 값으로 덮지 않는다', () => {
-  const { repo } = fakeRepository({ hasColumn: false })
-  assert.throws(() => hydratedDate(repo, 'createdAt', '2026-08-27 14:37:20.049'), /no column for property/)
-})
-
-test('★ 계약이 절대시각인 값 — 시간대가 없으면 UTC 다(지역 시간으로 읽을 근거가 없다)', () => {
-  assert.equal(absoluteTime('2026-08-27 14:37:20.049')?.toISOString(), '2026-08-27T14:37:20.049Z')
-  /* 지역 시간으로 읽었다면 한국에서 9시간이 밀린다. */
-  assert.notEqual(absoluteTime('2026-08-27 14:37:20.049')?.toISOString(), '2026-08-27T05:37:20.049Z')
-})
-
-test('시간대가 적혀 있으면 그 말을 믿는다', () => {
-  assert.equal(absoluteTime('2026-08-27T14:37:20.049Z')?.toISOString(), '2026-08-27T14:37:20.049Z')
-  assert.equal(absoluteTime('2026-08-27T23:37:20.049+09:00')?.toISOString(), '2026-08-27T14:37:20.049Z')
-  assert.equal(absoluteTime('2026-08-27T09:37:20.049-05:00')?.toISOString(), '2026-08-27T14:37:20.049Z')
-})
-
-test('날짜 객체와 밀리초도 받는다', () => {
-  const d = new Date('2026-08-27T14:37:20.049Z')
-  assert.equal(absoluteTime(d), d)
-  assert.equal(absoluteTime(1_756_305_440_049)?.getTime(), 1_756_305_440_049)
-})
-
-test('★ 읽을 수 없는 값은 null — 경계를 정하는 자리가 이 함수를 쓴다', () => {
-  for (const bad of [null, undefined, '', '   ', '어제', 'not-a-date', {}, [], NaN, new Date('x')]) {
-    assert.equal(absoluteTime(bad), null, `${String(bad)} 는 null 이어야 한다`)
-  }
-})
-
-test('★ 컬럼 값을 직접 날짜로 만드는 자리가 남아 있지 않다', () => {
-  /*
-   * 규칙이 있어도 새로 쓰는 코드가 그것을 지나지 않으면 같은 결함이 다시 난다. 그래서 자리를 세어
-   * 둔다 — 원시 결과의 컬럼을 `new Date(...)` 로 감싸는 모양을 찾는다.
-   *
-   * 밀리초 숫자(`new Date(someMs)`)는 시간대가 없으므로 이 그물에 걸리지 않는다.
-   */
-  const root = join(import.meta.dirname, '..', 'server')
-  const offenders: string[] = []
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir)) {
-      const p = join(dir, name)
-      if (statSync(p).isDirectory()) { walk(p); continue }
-      if (!name.endsWith('.ts')) continue
-      const text = readFileSync(p, 'utf8')
-      for (const m of text.matchAll(/new Date\(\s*[A-Za-z_$][\w$?.]*\.(eventTime|createdAt|updatedAt|at)\b[^)]*\)/g)) {
-        offenders.push(`${name}: ${m[0]}`)
-      }
-    }
-  }
-  walk(root)
-  assert.deepEqual(offenders, [], '컬럼 값을 직접 날짜로 만드는 자리가 있다 — hydratedDate() 를 지나야 한다')
-})