@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/event-type-split.test.ts

@@ -1,178 +0,0 @@
-/*
- * ★ 여러 종류를 시각순으로 — 거르는 축과 정렬 축이 어긋나면 색인이 버려진다.
- *
- * ── 실측 (2026-08-28 · 승화푸드 저널 3,374,894행) ───────────────────────────
- *   종류 8개 IN + 시각순 50건   SEARCH USING INDEX ix_twin_event_1 (domain, instance)   37.181초 · 0건
- *   같은 조건 · 정렬 없음        SEARCH USING INDEX ix_twin_event_7 (…, event_type=?)     0.003초
- *   종류 하나 + 시각순           SEARCH USING INDEX ix_twin_event_7 (…, event_type=?)     0.003초
- *
- * 정렬을 붙이는 순간 여러 종류의 순서를 합칠 방법이 없어 시각 색인으로 337만 행을 걸으며 행마다 종류를
- * 확인한다. 그 트윈에 에너지 사건은 **0건**이다 — 없는 것을 찾느라 37초를 쓴다.
- *
- * 360 이력이 64초였던 것과 같은 부류다. 고침도 같은 성질이다: **있는 색인을 쓰게 한다.**
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { splitShape } from '../server/service/twin-journal/event-type-split-shape.js'
-
-const dir = (...p: string[]) => join(import.meta.dirname, '..', 'server', ...p)
-const split = readFileSync(dir('service', 'twin-journal', 'event-type-split.ts'), 'utf8')
-const shape = readFileSync(dir('service', 'twin-journal', 'event-type-split-shape.ts'), 'utf8')
-const journal = readFileSync(dir('service', 'twin-journal', 'twin-journal-query.ts'), 'utf8')
-
-const DESC = [{ name: 'eventTime', desc: true }]
-const ENERGY = ['energy.measured', 'energy.equipment', 'energy.demand.window', 'energy.peak']
-
-test('★ 에너지 원장이 보내는 모양이 이 갈래로 간다', () => {
-  const shape = splitShape({ filters: [{ name: 'eventType', operator: 'in', value: ENERGY }] }, DESC)
-  assert.ok(shape)
-  assert.deepEqual(shape!.eventTypes, ENERGY)
-})
-
-test('시간창이 함께 와도 간다 — 화면이 구간을 지정한다', () => {
-  const shape = splitShape(
-    {
-      filters: [
-        { name: 'eventType', operator: 'in', value: ENERGY },
-        { name: 'eventTime', operator: 'between', value: ['2026-08-01T00:00:00.000Z', '2026-08-02T00:00:00.000Z'] }
-      ]
-    },
-    DESC
-  )
-  assert.ok(shape)
-  assert.equal(shape!.fromTime?.toISOString(), '2026-08-01T00:00:00.000Z')
-  assert.equal(shape!.untilTime?.toISOString(), '2026-08-02T00:00:00.000Z')
-})
-
-test('★ 맞지 않는 물음은 일반 경로로 보낸다 — 억지로 답하면 목록이 알리지 않고 달라진다', () => {
-  const cases: [string, any, any[]][] = [
-    ['종류가 하나', { filters: [{ name: 'eventType', operator: 'in', value: ['a'] }] }, DESC],
-    ['종류가 너무 많다', { filters: [{ name: 'eventType', operator: 'in', value: Array.from({ length: 13 }, (_, i) => `t${i}`) }] }, DESC],
-    ['종류 필터가 없다', { filters: [] }, DESC],
-    ['정확일치', { filters: [{ name: 'eventType', operator: 'eq', value: 'a' }] }, DESC],
-    ['제외 목록', { filters: [{ name: 'eventType', operator: 'notin_with_null', value: ENERGY }] }, DESC],
-    ['자유 검색어', { search: '전력', filters: [{ name: 'eventType', operator: 'in', value: ENERGY }] }, DESC],
-    ['다른 필터가 섞였다', { filters: [{ name: 'eventType', operator: 'in', value: ENERGY }, { name: 'epc', operator: 'search', value: 'x' }] }, DESC],
-    ['리비전 정렬', { filters: [{ name: 'eventType', operator: 'in', value: ENERGY }] }, [{ name: 'revision', desc: true }]],
-    ['오름차순', { filters: [{ name: 'eventType', operator: 'in', value: ENERGY }] }, [{ name: 'eventTime', desc: false }]],
-    ['못 읽는 시각', { filters: [{ name: 'eventType', operator: 'in', value: ENERGY }, { name: 'eventTime', operator: 'lte', value: '어제' }] }, DESC]
-  ]
-  for (const [why, params, sortings] of cases) {
-    assert.equal(splitShape(params, sortings), null, `${why} 는 일반 경로로 가야 한다`)
-  }
-})
-
-test('★ 종류를 정확일치로 묻는다 — 이 한 줄이 색인을 쓰게 한다', () => {
-  assert.match(split, /andWhere\('e\.eventType = :eventType', \{ eventType \}\)/)
-  assert.doesNotMatch(split, /eventType IN/, '나눈 뒤에 다시 여러 값으로 묻지 않는다')
-  /* 정렬 축이 색인의 마지막 칸과 같아야 한다. */
-  assert.match(split, /orderBy\('e\.eventTime', 'DESC'\)/)
-})
-
-test('★ 한 갈래라도 못 읽으면 반쪽을 전부인 것처럼 내지 않는다', () => {
-  assert.match(split, /if \(!page\) return null/)
-})
-
-test('★ 이어 읽기 지점을 모든 갈래에 같이 건다', () => {
-  /* 갈래마다 다르게 걸면 어떤 종류는 이미 지나간 구간을 다시 낸다. */
-  assert.match(split, /e\.eventTime < :curAt OR \(e\.eventTime = :curAt AND e\.\$\{tiebreak\} < :curTie\)/)
-  assert.match(split, /if \(!cursor\) return null/, '못 읽는 커서로는 답하지 않는다')
-})
-
-test('★ 나눌 수를 제한한다 — 나누는 것이 손해가 되는 지점이 있다', () => {
-  assert.match(shape, /export const MAX_SPLIT = 24/)
-  assert.match(split, /if \(!pairs \|\| pairs > MAX_SPLIT\) return null/)
-})
-
-test('★ 화면이 부르는 자리에 붙어 있다', () => {
-  assert.match(journal, /const split = splitShape\(effective, effective\.sortings \?\? \[\]\)/)
-  assert.match(journal, /await eventTypeSplitPage\(domain\.id, instanceIds, split, limit, tiebreak, effective\.pagination\?\.after\)/)
-  /* 파생 테이블 갈래보다 뒤, 일반 저널 질의보다 앞이어야 한다. */
-  assert.ok(journal.indexOf('readModelPage(domain.id') < journal.indexOf('splitShape(effective'))
-  assert.ok(journal.indexOf('splitShape(effective') < journal.indexOf('const qb = getQueryBuilderFromListParams'))
-})
-
-test('★ 걷을 조건이 적혀 있다 — 부르는 데가 없어지면 지운다', () => {
-  /*
-   * 앱에서 종류를 여러 값으로 보내는 곳은 에너지 원장 한 곳뿐이다. 그 화면이 종류를 하나씩 고르는
-   * 모양으로 바뀌면 이 갈래는 아무도 부르지 않는다 — 그때 지워야 한다. 그 조건을 코드에 적어 두지
-   * 않으면 아무것도 하지 않는 갈래가 무언가를 받쳐 주는 것처럼 남는다.
-   */
-  assert.match(split, /이 갈래를 걷을 조건/)
-  assert.match(split, /그때 \*\*지운다\.\*\*/)
-})
-
-/* ── 공정 단계 칩 (2026-08-29) ─────────────────────────────────────────────
- *
- * ★ 칩을 고른 순간 이 갈래가 꺼져서, **고르지 않은 쪽이 더 빨랐다.**
- *
- * 원장은 종류 넷을 담아 묻고 그 위에 단계 칩을 겹친다. 앞 버전은 `bizStep` 필터를 만나면 모양을
- * 알아보지 못해 예전 경로로 떨어졌다 — 좁혀 물으면 느려지는 화면이 된다.
- */
-
-test('공정 단계 하나로 좁혀도 갈래 경로가 답한다', () => {
-  const shape = splitShape(
-    {
-      filters: [
-        { name: 'eventType', operator: 'in', value: ['epcis.ObjectEvent', 'epcis.AggregationEvent'] },
-        { name: 'bizStep', operator: 'eq', value: 'shipping' }
-      ]
-    } as any,
-    [{ name: 'eventTime', desc: true }] as any
-  )
-  assert.ok(shape, '이 모양을 알아봐야 한다')
-  assert.equal(shape?.bizStep, 'shipping')
-  assert.deepEqual(shape?.eventTypes, ['epcis.ObjectEvent', 'epcis.AggregationEvent'])
-})
-
-test('단계를 여러 값으로 주면 답하지 않는다 — 갈래가 곱해진다', () => {
-  const shape = splitShape(
-    {
-      filters: [
-        { name: 'eventType', operator: 'in', value: ['epcis.ObjectEvent', 'epcis.AggregationEvent'] },
-        { name: 'bizStep', operator: 'in', value: ['shipping', 'receiving'] }
-      ]
-    } as any,
-    [{ name: 'eventTime', desc: true }] as any
-  )
-  assert.equal(shape, null)
-})
-
-test('빈 단계 값은 받지 않는다 — 모든 행을 뜻하는지 없는 단계를 뜻하는지 알 수 없다', () => {
-  const shape = splitShape(
-    {
-      filters: [
-        { name: 'eventType', operator: 'in', value: ['epcis.ObjectEvent', 'epcis.AggregationEvent'] },
-        { name: 'bizStep', operator: 'eq', value: '  ' }
-      ]
-    } as any,
-    [{ name: 'eventTime', desc: true }] as any
-  )
-  assert.equal(shape, null)
-})
-
-
-/*
- * ── 목록과 건수가 같은 축을 본다 (2026-09-19) ───────────────────────────────
- *
- * 빠른 갈래는 건수를 **다른 빌더**로 센다. 그 빌더가 검색 축을 빈 배열로 선언하고 있었다 — 목록은
- * 걸러지고 건수는 안 걸러지는 모양이다(UX 레인이 검색 길을 세다 짚었다).
- *
- * **지금 그 일은 일어날 수 없다**: 검색어가 있으면 빠른 갈래를 아예 안 탄다(위 「자유 검색어」가 그
- * 축을 붙든다). 그래서 이것은 산 결함이 아니라 **잠긴 함정**이고, 두 자리가 같은 상수를 보게 해서
- * 닫는다 — 저 규칙이 언젠가 느슨해지면 그때 조용히 갈릴 자리다.
- */
-test('★ 건수 probe 와 목록이 같은 검색 축을 쓴다 — 한쪽만 걸러지면 화면이 「한 건 / 전체 수」를 말한다', () => {
-  const uses = [...journal.matchAll(/searchables:\s*([^,\n]+)/g)].map(m => m[1].trim())
-
-  assert.ok(uses.length >= 2, '검색 축을 선언하는 자리가 둘이어야 한다(목록 · 건수 probe)')
-  assert.deepEqual(
-    [...new Set(uses)],
-    ['[...JOURNAL_SEARCHABLES]'],
-    '두 자리가 같은 상수를 봐야 한다 — 배열을 따로 적으면 한쪽만 늘어난다'
-  )
-  assert.doesNotMatch(journal, /searchables:\s*\[\]/, '빈 목록은 「검색어를 조용히 버린다」는 뜻이다')
-})

package/test/external-resolver.test.ts

@@ -1,177 +0,0 @@
-/*
- * ★ **밖을 가리키는 관계를 푸는 자리** — 선언은 있고 코드가 0곳이던 이음새.
- *
- * ── 무엇이 있었나 (2026-09-05 실측) ────────────────────────────────────────
- * 계약이 `target: { kind: 'external', entity: … }` 를 선언하고 주석에 「해소는 호스트가 한다」고
- * 적어 두었다. 그런데 `headless-twin/server` 어디에도 그것을 다루는 코드가 없었다(0곳).
- *
- * `space.area` 가 도는 것처럼 보인 이유는 이음새가 있어서가 아니라 **호스트에서 그것이 평범한 FK
- * 라서**다 — 선언이 길을 낸 것이 아니다.
- *
- * ── 왜 지금 채웠나 ─────────────────────────────────────────────────────────
- * 아침에는 「아무도 안 막혔으니 급하지 않다」로 적었고 **그 판단이 규모를 작게 잡은 것**이었다.
- *
- * 360 의 소비처는 무한히 늘어난다(사용자 방향). 그러면 각 제품의 자기 저장소가 관계의 원천이 된다.
- * 그때 선언은 「밖을 가리킨다」고 말하는데 푸는 길이 없으면 **제품마다 자기 길을 낸다** — 그것이
- * 정확히 「무한히 갈린다」다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  clearExternalResolvers,
-  externalIncoming,
-  externalResolverEntities,
-  registerExternalResolver,
-  resolveExternal
-} from '../server/service/twin-model/external-resolver.js'
-
-const AREA = 'space.area'
-
-/*
- * 어느 트윈의 관계인지 — `resolve` 는 이것을 함께 받는다(2026-09-18). 밖의 id 는 도메인에서 유일하지
- * 않아서(구역 id 는 공간 안에서만 유일), 문맥 없이 답하면 남의 공간 이름이 이 자리의 부모로 보인다.
- */
-const CTX = { instanceId: 'probe-twin' }
-
-/* ── 못 풀면 못 푼다고 말한다 ────────────────────────────────────────────── */
-
-test('★ 꽂힌 것이 없으면 「해소기가 없다」고 말한다 — 「없다」가 아니다', async () => {
-  /*
-   * 링크를 지우면 화면은 「그런 관계가 없다」로 읽는다. 실제로는 「아무도 답할 수 없다」다.
-   * 사람이 할 일이 다르다 — 앞은 자료를 채울 일이고 뒤는 해소기를 꽂을 일이다.
-   */
-  clearExternalResolvers()
-  const got = await resolveExternal(AREA, 'd1', ['LINE-CAM'], CTX)
-
-  assert.equal(got.unresolved, 'no-resolver')
-  assert.equal(got.refs, undefined)
-})
-
-test('★ 해소기가 터져도 360 을 죽이지 않는다 — 알리고 못 풀었다고 한다', async () => {
-  clearExternalResolvers()
-  const said: string[] = []
-  registerExternalResolver({ entity: AREA, resolve: async () => { throw new Error('DB down') } })
-
-  const got = await resolveExternal(AREA, 'd1', ['X'], CTX, m => said.push(m))
-
-  assert.equal(got.unresolved, 'failed')
-  assert.ok(said.some(m => m.includes('DB down')), '사유를 삼켰다')
-})
-
-/* ── 풀면 무엇인지 말한다 ────────────────────────────────────────────────── */
-
-test('★ 이름과 갈 곳을 낸다 — 막다른 링크를 만들지 않으려고', async () => {
-  clearExternalResolvers()
-  registerExternalResolver({
-    entity: AREA,
-    resolve: async (_d, ids) => ids.map(id => ({ id, name: `라인 ${id}`, href: `/areas/${id}` }))
-  })
-
-  const got = await resolveExternal(AREA, 'd1', ['LINE-CAM'], CTX)
-  assert.equal(got.refs?.[0].name, '라인 LINE-CAM')
-  assert.equal(got.refs?.[0].href, '/areas/LINE-CAM')
-})
-
-test('★ 없는 id 는 없다고 말한다 — 답에서 빼지 않는다', async () => {
-  /* 빼면 화면은 그 참조가 원래 없었던 것으로 읽는다. 실제로는 가리키는데 대상이 없는 것이다. */
-  clearExternalResolvers()
-  registerExternalResolver({ entity: AREA, resolve: async (_d, ids) => ids.map(id => ({ id, missing: true })) })
-
-  const got = await resolveExternal(AREA, 'd1', ['사라진구역'], CTX)
-  assert.equal(got.refs?.length, 1)
-  assert.equal(got.refs?.[0].missing, true)
-})
-
-/* ── 들어오는 쪽 ─────────────────────────────────────────────────────────── */
-
-test('★ 제품이 자기 저장소의 관계를 싣는다 — 커널은 그 표를 모른다', async () => {
-  clearExternalResolvers()
-  registerExternalResolver({
-    entity: 'mes.records',
-    incoming: async () => [
-      { via: 'mes.rel.report', from: 'productionReports', tense: 'past', ids: ['PR-1', 'PR-2'], total: 2 },
-      { via: 'mes.rel.maintenance', from: 'maintenancePlans', tense: 'future', ids: ['MP-1'], total: 1 }
-    ]
-  })
-
-  const got = await externalIncoming('d1', 'mes-miratek', 'equipment', 'EQ-CT-MWELD-01')
-
-  assert.equal(got.length, 2)
-  assert.deepEqual(got.map(g => g.tense).sort(), ['future', 'past'], '시간축이 안 실렸다')
-})
-
-test('★ 시간축이 실린다 — 「걸린 것이 열」이 두 뜻이 되는 자리', async () => {
-  /*
-   * 지난 일 아홉 · 앞으로 올 일 하나와 그 반대는 「이 설비를 세워도 되나」의 답이 정반대다.
-   * 묶음이 스스로 말해야 화면이 가를 수 있다.
-   */
-  clearExternalResolvers()
-  registerExternalResolver({
-    entity: 'mes.records',
-    incoming: async () => [{ via: 'mes.rel.report', from: 'x', tense: 'past', ids: ['a'], total: 9 }]
-  })
-
-  const got = await externalIncoming('d1', 'i', 'equipment', 'E-1')
-  assert.equal(got[0].tense, 'past')
-  assert.equal(got[0].total, 9, '전체 수를 안 말한다 — 잘린 목록만으로는 규모를 모른다')
-})
-
-test('빈 묶음은 싣지 않는다 — 그 제품이 이 축을 안 보는 것이고 할 말이 없다', async () => {
-  clearExternalResolvers()
-  registerExternalResolver({
-    entity: 'mes.records',
-    incoming: async () => [{ via: 'x', from: 'y', ids: [], total: 0 }]
-  })
-  assert.deepEqual(await externalIncoming('d1', 'i', 'equipment', 'E-1'), [])
-})
-
-test('★ 한 제품이 터져도 나머지는 실린다', async () => {
-  clearExternalResolvers()
-  const said: string[] = []
-  registerExternalResolver({ entity: 'broken', incoming: async () => { throw new Error('boom') } })
-  registerExternalResolver({
-    entity: 'ok',
-    incoming: async () => [{ via: 'v', from: 'f', ids: ['a'], total: 1 }]
-  })
-
-  const got = await externalIncoming('d1', 'i', 'equipment', 'E-1', m => said.push(m))
-  assert.equal(got.length, 1, '하나가 터져서 나머지도 안 실렸다')
-  assert.ok(said.some(m => m.includes('boom')))
-})
-
-/* ── 꽂는 규율 ───────────────────────────────────────────────────────────── */
-
-test('★ 같은 대상을 두 제품이 답하려 하면 알린다 — 조용히 덮지 않는다', async () => {
-  clearExternalResolvers()
-  const said: string[] = []
-  registerExternalResolver({ entity: AREA, resolve: async () => [] })
-  registerExternalResolver({ entity: AREA, resolve: async () => [] }, m => said.push(m))
-
-  assert.ok(said.some(m => m.includes(AREA)), '덮어쓴 것을 안 알렸다')
-})
-
-test('entity 없는 해소기는 안 꽂는다 — 아무 관계에도 안 붙는다', async () => {
-  clearExternalResolvers()
-  const said: string[] = []
-  registerExternalResolver({ entity: '  ' } as any, m => said.push(m))
-
-  assert.deepEqual(externalResolverEntities(), [])
-  assert.ok(said.length, '조용히 넘겼다')
-})
-
-test('★ 무엇을 풀 수 있나를 밖에서 잴 수 있다 — 「모른다」와 「없다」를 가르려고', async () => {
-  clearExternalResolvers()
-  registerExternalResolver({ entity: 'b', resolve: async () => [] })
-  registerExternalResolver({ entity: 'a', resolve: async () => [] })
-
-  assert.deepEqual(externalResolverEntities(), ['a', 'b'])
-})
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', async () => {
-  clearExternalResolvers()
-  assert.deepEqual(externalResolverEntities(), [], '지우기가 안 듣는다')
-  registerExternalResolver({ entity: AREA, resolve: async (_d, ids) => ids.map(id => ({ id })) })
-  const got = await resolveExternal(AREA, 'd', ['X'], CTX)
-  assert.equal(got.refs?.length, 1, '꽂았는데 안 불린다')
-})

package/test/fact-scope-wiring.test.ts

@@ -1,96 +0,0 @@
-/*
- * 마감된 구간 사실의 **범위 배선** — 유입을 부르는 곳은 모두 어느 트윈인지 말해야 한다.
- *
- * ── 왜 이 시험이 있나 (2026-08-30) ────────────────────────────────────────
- * 커널은 `new Kernel(domainId, …)` 으로 서므로 자기가 어느 트윈인지 모른다. 설비 번호·계량 지점 번호는
- * 트윈 안에서만 통하는 이름표라, 범위를 넘기지 않으면 **서로 다른 설비의 같은 날이 한 사실**이 된다.
- * 실측으로 그 일이 났다 — 두 발전소의 `002` 가 겹쳐, 저널에 6줄이 있는데 서로 다른 이름은 5개였다.
- * 여러 현장을 함께 계산하는 성과 화면은 이름으로 중복을 걷어내므로 한쪽 발전량이 사라진다.
- *
- * 배선은 조용히 빠진다. 인자를 안 넘겨도 컴파일되고, 시험도 초록이고, 실 서버에서 값이 하나 사라질
- * 뿐이다. 그래서 **부르는 자리를 세어서** 지킨다 — `ingest-wiring-guard` 와 같은 부류다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-import { resolveSubject, ingestEnergyGenerationPeriodRecords } from '@operato/ops-contract'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const serverDir = join(here, '..', 'server')
-
-function allTs(dir: string, out: string[] = []): string[] {
-  for (const name of readdirSync(dir)) {
-    const full = join(dir, name)
-    if (statSync(full).isDirectory()) allTs(full, out)
-    else if (name.endsWith('.ts')) out.push(full)
-  }
-  return out
-}
-
-/**
- * 주석을 걷어낸다 — **설명에 적힌 이름을 호출로 세지 않는다.**
- *
- * 처음 이 시험을 만들었을 때 `reference-live.ts` 의 흐름 설명 한 줄(`ingestCanonicalRecords(정규→봉투)`)을
- * 배선 빠진 호출로 잡았다. 주석을 고치게 만드는 시험은 아무것도 지키지 않는다.
- */
-function withoutComments(src: string): string {
-  return src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/[^\n]*/g, '$1')
-}
-
-test('★ 유입을 부르는 곳은 모두 어느 트윈인지 말한다 — 안 말하면 두 현장의 같은 번호가 겹친다', () => {
-  const bad: string[] = []
-  for (const file of allTs(serverDir)) {
-    if (file.endsWith('canonical-ingest.ts')) continue // 정의하는 자리
-    const src = withoutComments(readFileSync(file, 'utf-8'))
-    let i = src.indexOf('ingestCanonicalRecords(')
-    while (i >= 0) {
-      /* 호출 하나를 괄호 균형으로 잘라 낸다 — 줄바꿈이 있어도 본다. */
-      let depth = 0
-      let j = i + 'ingestCanonicalRecords'.length
-      for (; j < src.length; j++) {
-        if (src[j] === '(') depth++
-        else if (src[j] === ')') {
-          depth--
-          if (depth === 0) break
-        }
-      }
-      const call = src.slice(i, j + 1)
-      if (!call.includes('factScope')) {
-        bad.push(`${file.slice(serverDir.length + 1)}: ${call.replace(/\s+/g, ' ').slice(0, 90)}`)
-      }
-      i = src.indexOf('ingestCanonicalRecords(', j)
-    }
-  }
-  assert.deepEqual(
-    bad,
-    [],
-    `범위를 넘기지 않는 유입 호출:\n${bad.join('\n')}\n` +
-      'TwinEngine.factScope(domainId, instanceId) 를 넷째 인자로 넘겨라 — ' +
-      '넘기지 않으면 다른 현장의 같은 설비 번호가 한 사실로 겹치고, 성과 화면에서 한쪽이 사라진다.'
-  )
-})
-
-test('★ 범위를 넘기면 두 현장의 같은 번호가 다른 사실이다', () => {
-  const rec = { equipmentId: '002', from: '2026-08-28T15:00:00.000Z', to: '2026-08-29T15:00:00.000Z', kWh: 400.6 }
-  const a = ingestEnergyGenerationPeriodRecords(rec, { tenantId: 'd', scopeId: 'twin-a' }).accepted[0]
-  const b = ingestEnergyGenerationPeriodRecords(rec, { tenantId: 'd', scopeId: 'twin-b' }).accepted[0]
-  assert.notEqual(a.eventId, b.eventId)
-})
-
-test('선언된 정체성이 있으면 범위와 무관하게 한 사실이다 — 그릇이 정체성을 정하지 않는다', () => {
-  const rec = { equipmentId: '002', from: '2026-08-28T15:00:00.000Z', to: '2026-08-29T15:00:00.000Z', kWh: 400.6 }
-  const identityOf = () => 'https://example.com/obj/inv-002'
-  const a = ingestEnergyGenerationPeriodRecords(rec, { tenantId: 'd', scopeId: 'twin-a', identityOf }).accepted[0]
-  const b = ingestEnergyGenerationPeriodRecords(rec, { tenantId: 'd', scopeId: 'twin-b', identityOf }).accepted[0]
-  assert.equal(a.eventId, b.eventId)
-  assert.equal((a.data as any).subjectBasis, 'declared')
-})
-
-test('커널이 범위를 답할 자리가 있다 — 호스트가 그것을 넘긴다', () => {
-  const r = resolveSubject('equipment', '002', { tenantId: 'd', scopeId: 'ppms-호현' })
-  assert.equal(r.basis, 'twin-local')
-  assert.equal(r.subject, 'ppms-호현/002')
-})

package/test/fill-dedupe.test.ts

@@ -1,59 +0,0 @@
-/*
- * backfill 이 이미 있는 사실을 다시 앉히지 않게 하는 부분.
- *
- * ── 무엇이 있었나 (2026-09-06 측정) ─────────────────────────────────────────
- * 중복 판정 기억은 프로세스 안에만 있다. 재기동하면 비워지고, 그 뒤 backfill 을 돌리면 이미 저널에
- * 있는 사실도 「처음 본 것」이 된다.
- *
- * ```
- * mes-line-a 를 재기동 뒤 backfill
- *   저널 44 → 83건 · 서로 다른 것 39가지 · 중복 44가지
- *   같은 프로세스에서 다시 돌리면 applied 0    (기억이 살아 있어서)
- * ```
- *
- * 저널 조회는 DB 를 물어야 해서 여기서 다루지 않는다. 확인하는 것은 **어느 구간을 읽을지 정하는
- * 판정**이다 — 그것이 틀리면 조회가 엉뚱한 곳을 보고 기억이 안 찬다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { spanOf } from '../server/service/reference/fill-span.js'
-
-const at = (s: string) => ({ subjectId: 'L', decision: 'scrap', at: s })
-
-test('★ 레코드가 덮는 구간을 정한다', () => {
-  const span = spanOf([at('2026-09-01T00:00:00.000Z'), at('2026-09-03T12:00:00.000Z'), at('2026-09-02T00:00:00.000Z')])
-  assert.ok(span)
-  assert.equal(span!.from.toISOString(), '2026-08-31T23:59:59.000Z')
-  assert.equal(span!.to.toISOString(), '2026-09-03T12:00:01.000Z')
-})
-
-test('★ 양쪽을 1초씩 넓힌다 — 좁게 읽으면 경계의 사실이 다시 앉는다', () => {
-  /*
-   * 저장된 시각은 밀리초까지 있고 경계에서 같은 값이 갈릴 수 있다. 넓게 읽는 것은 기억이 조금 더
-   * 차는 것뿐이라 손해가 없다.
-   */
-  const one = '2026-09-01T00:00:00.000Z'
-  const span = spanOf([at(one)])!
-  assert.equal(span.to.getTime() - span.from.getTime(), 2000)
-})
-
-test('★ 하나도 시각을 안 말하면 구간이 없다 — 저널 전체를 읽지 않는다', () => {
-  /*
-   * 구간을 못 정하면 채우지 않는다. 저널 전체를 읽는 쪽으로 넓히면 2백만 줄을 훑게 되고, 그것이
-   * 필요한 상황이면 조회가 아니라 정체 색인으로 풀어야 한다.
-   */
-  assert.equal(spanOf([{ subjectId: 'L', decision: 'scrap' }]), undefined)
-  assert.equal(spanOf([]), undefined)
-})
-
-test('시각을 말하는 것과 안 말하는 것이 섞이면 말하는 것으로 정한다', () => {
-  const span = spanOf([{ subjectId: 'A' }, at('2026-09-01T00:00:00.000Z'), { subjectId: 'B' }])
-  assert.ok(span, '한 줄이라도 말하면 구간이 있다')
-})
-
-test('★ 이 테스트가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  const narrow = spanOf([at('2026-09-01T00:00:00.000Z')])!
-  const wide = spanOf([at('2026-09-01T00:00:00.000Z'), at('2026-09-10T00:00:00.000Z')])!
-  assert.ok(wide.to.getTime() > narrow.to.getTime(), '구간이 레코드를 안 따라간다')
-})

package/test/fill-loop.test.ts

@@ -1,35 +0,0 @@
-/*
- * 빠진 구간을 **언제** 다시 받나 — 세 자리의 규율.
- *
- * ```
- * 1  재기동 직후 한 번    우리가 내려가 있는 동안 그쪽이 보낸 것
- * 2  구멍을 본 그 자리     번호가 비었다는 것을 아는 가장 이른 순간
- * 3  10분 그물            위 둘이 다 놓치는 경우
- * ```
- *
- * 여기서 확인하는 것은 **두 번 부르지 않는 규율**이다. 밀어 받는 쪽이 구멍 뒤의 봉투를 계속 보내면
- * 그때마다 구멍 판정이 나고, 막지 않으면 봉투마다 backfill 이 돈다.
- *
- * 실제 조회는 DB 와 어댑터를 물어야 해서 여기서 다루지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { FILL_DEBOUNCE_MS, FILL_PERIOD_MS } from '../server/service/reference/fill-cadence.js'
-
-test('★ 그물은 10분이다 — 30초가 아니다', () => {
-  /*
-   * 인티그레이션 레인이 측정으로 준 권고다. backfill 은 원본에 조회를 걸고 저널을 읽는다.
-   * 30초마다 돌면 얻는 것 없이 두 쪽을 계속 친다 — 놓친 구간은 10분 뒤에 받아도 사실이 달라지지 않는다.
-   *
-   * 규칙 주기(30초)에 얹지 않은 이유이기도 하다. 얹으면 간격이 그쪽에 묶이고, 나중에 규칙 주기를
-   * 바꾸면 이쪽이 소리 없이 따라간다.
-   */
-  assert.equal(FILL_PERIOD_MS, 10 * 60_000)
-  assert.notEqual(FILL_PERIOD_MS, 30_000, '규칙 주기와 같아졌다 — 그러면 하나를 바꿀 때 둘이 움직인다')
-})
-
-test('★ 같은 단위를 1분 안에 두 번 안 받는다 — 봉투마다 돌면 안 된다', () => {
-  assert.equal(FILL_DEBOUNCE_MS, 60_000)
-  assert.ok(FILL_DEBOUNCE_MS < FILL_PERIOD_MS, '막는 간격이 그물보다 길면 그물이 헛돈다')
-})