@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/aggregate-not-findone.test.ts

@@ -1,112 +0,0 @@
-/*
- * ★ 수 하나가 필요하면 **집계로 묻는다** — `findOne(order: …)` 으로 흉내내지 않는다.
- *
- * ── 왜 이 검사가 필요한가 (2026-08-28 전수 조사) ────────────────────────────
- * 「가장 늦은 사건」·「저널 머리」·「첫 사건」처럼 **한 줄만** 필요한 자리에서 이런 모양을 썼다.
- *
- *   findOne({ where: { domain: { id }, … }, order: { revision: 'DESC' } })
- *
- * 관계를 가진 엔티티에서 `find`·`findOne` 은 두 단계 질의가 되고 **안쪽에 상한이 없다** — 조건에 맞는
- * 행을 전부 만든 뒤 밖에서 한 줄을 고른다. 이 파일이 지키는 저장소에서 실측한 값이다.
- *
- *   twinEvents 의 같은 모양      0.024초 대 12초 (저널 375만 행)
- *   현장 성과(`latestEventTime`)  7.2초 — 업무 사실 97만 행을 payload 까지 만든 뒤 한 줄
- *   백테스트 구간(`gapWindow`)    같은 모양을 두 번(첫 사건·마지막 사건)
- *
- * **답은 맞고 비용만 틀리다.** 그래서 사람 리뷰가 잡지 못한다 — 기계에 맡긴다.
- * (같은 이유로 만든 검사가 하나 더 있다: `journal-read-discipline`. 그것은 「통째로 읽는 자리」를 보고,
- *  이 검사는 「한 줄만 필요한데 통째로 읽는 자리」를 본다.)
- *
- * ── 규율 ────────────────────────────────────────────────────────────────────
- * 큰 표에서 한 줄·한 수가 필요하면 질의 빌더로 `MIN`·`MAX`·`COUNT` 를 묻는다. 색인의 끝을 집으므로
- * 행을 만들지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-const ROOT = join(import.meta.dirname, '..', 'server')
-
-/** 이 검사가 보는 큰 표 — 행이 수백만이 될 수 있는 것들. */
-const BIG_TABLES = ['TwinEvent', 'TwinSubjectEvent']
-
-/**
- * 예외 — **이유와 함께** 적는다. 이유가 없으면 예외가 아니다.
- *
- * 지금은 비어 있다. 예외를 더할 때는 왜 한 줄이 아니라 여러 행이 필요한지, 그리고 없어질 조건을 함께 적는다.
- */
-const ALLOWED: { file: string; why: string }[] = []
-
-function sites(): { file: string; line: number; snippet: string }[] {
-  const out: { file: string; line: number; snippet: 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 src = readFileSync(p, 'utf8')
-      /*
-       * 큰 표의 저장소에서 `findOne` 을 부르면서 `order:` 를 주는 모양을 찾는다. 정렬을 준다는 것은
-       * 「끝에서 한 줄」을 원한다는 뜻이고, 그것이 곧 집계다.
-       *
-       * 변수에 담아 부르는 형태도 본다 — 그러지 않으면 이름만 바꿔 이 검사를 지나칠 수 있다.
-       */
-      for (const table of BIG_TABLES) {
-        const vars = new Set<string>()
-        for (const m of src.matchAll(new RegExp(`const\\s+(\\w+)\\s*=\\s*getRe(?:ad)?Repository\\(${table}\\)`, 'g'))) {
-          vars.add(m[1])
-        }
-        const receivers = [`getRepository(${table})`, `getReadRepository(${table})`, ...[...vars]]
-        for (const recv of receivers) {
-          let at = src.indexOf(recv)
-          while (at >= 0) {
-            const after = src.slice(at + recv.length, at + recv.length + 400)
-            const call = /^\s*\n?\s*\.findOne\(\s*\{([\s\S]{0,320})/.exec(after)
-            if (call && /order\s*:/.test(call[1])) {
-              out.push({
-                file: p.slice(ROOT.length + 1),
-                line: src.slice(0, at).split('\n').length,
-                snippet: call[1].replace(/\s+/g, ' ').slice(0, 90)
-              })
-            }
-            at = src.indexOf(recv, at + 1)
-          }
-        }
-      }
-    }
-  }
-  walk(ROOT)
-  return out
-}
-
-test('★ 큰 표에서 한 줄을 원하면 집계로 묻는다 — findOne(order) 으로 흉내내지 않는다', () => {
-  const found = sites().filter(s => !ALLOWED.some(a => a.file === s.file))
-  assert.deepEqual(
-    found.map(s => `${s.file}:${s.line} — ${s.snippet}`),
-    [],
-    '이 모양은 조건에 맞는 행을 전부 만든 뒤 한 줄을 고른다. 질의 빌더로 MIN·MAX·COUNT 를 묻는다.\n' +
-      '정말 여러 행이 필요하면 ALLOWED 에 이유와 없어질 조건을 함께 적는다.'
-  )
-})
-
-test('예외 목록에는 반드시 이유가 붙는다 — 이름만 적어 지나가지 않게', () => {
-  for (const a of ALLOWED) assert.ok(a.why.trim().length > 20, `${a.file} 의 예외에 이유가 없다`)
-})
-
-test('★ 고친 자리들이 실제로 집계를 쓴다 — 되돌아가지 않게 이름으로 못박는다', () => {
-  /*
-   * 이름으로 못박는 이유: 되돌아가도 **답은 맞기 때문에** 결과를 보는 시험으로는 잡히지 않는다.
-   */
-  const kpi = readFileSync(join(ROOT, 'engine', 'kpi-query.ts'), 'utf8')
-  assert.match(kpi, /select\('MAX\(e\.eventTime\)', 'at'\)/, '마지막 업무 기록 시각은 집계로 묻는다')
-
-  const engine = readFileSync(join(ROOT, 'engine', 'twin-engine.ts'), 'utf8')
-  assert.match(engine, /select\('MAX\(e\.revision\)', 'max'\)/, '저널 머리는 집계로 묻는다')
-
-  const forecast = readFileSync(join(ROOT, 'service', 'twin-forecast', 'twin-forecast-query.ts'), 'utf8')
-  assert.match(forecast, /\$\{agg\}\(e\.eventTime\)/, '백테스트 구간의 양 끝은 집계로 묻는다')
-
-  const model = readFileSync(join(ROOT, 'service', 'twin-model', 'twin-model-query.ts'), 'utf8')
-  assert.match(model, /select\('MAX\(e\.revision\)', 'max'\)/, '모델 요약의 저널 끝도 집계로 묻는다')
-})

package/test/area-resolver-db.test.ts

@@ -1,110 +0,0 @@
-/*
- * What an area id is, and whose area it is.
- *
- * The item panel shows a location's parent. When the parent is an area, the host answers what that id is
- * (`external: 'space.area'`). Nothing registered that answer until 2026-09-18, so every location's parent read
- * "no component can resolve this relation" on the running twin.
- *
- * The lookup is (domain, space, areaId) — the area table's own unique key. An `areaId` is unique inside a space,
- * so the same id can exist in two spaces of one tenant; the space comes from the twin the relation belongs to.
- * Held here: the name of this twin's area, "missing" for an id that is in no area of this space, and another
- * space's area of the same id never answering.
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import type { DataSource } from 'typeorm'
-
-const req = createRequire(import.meta.url)
-const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
-const { entities: authEntities } = req('@things-factory/auth-base')
-const { entities: twinEntities } = req('../dist-server/service/index.js')
-const { resolveAreas, installAreaResolver, SPACE_AREA_ENTITY } = req('../dist-server/service/twin-space/area-resolver.js')
-const { externalResolverEntities, clearExternalResolvers, resolveExternal } = req('../dist-server/service/twin-model/external-resolver.js')
-const { TwinSpace } = req('../dist-server/service/twin-space/twin-space.js')
-const { TwinArea } = req('../dist-server/service/twin-space/twin-area.js')
-const { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-let otherDomainId: string
-
-before(async () => {
-  ds = new TypeOrmDataSource({
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    namingStrategy: new NamingStrategy(),
-    entities: [...shellEntities, ...authEntities, ...twinEntities],
-    logging: false
-  })
-  await ds.initialize()
-  addDataSource('default', ds)
-  const d = await ds.getRepository(Domain).save({ name: 'area-test', subdomain: 'area-test' } as any)
-  const other = await ds.getRepository(Domain).save({ name: 'area-other', subdomain: 'area-other' } as any)
-  domainId = d.id
-  otherDomainId = other.id
-
-  const spaces = ds.getRepository(TwinSpace)
-  const north = await spaces.save({ domain: { id: domainId }, spaceId: 'north', name: 'North site' } as any)
-  const south = await spaces.save({ domain: { id: domainId }, spaceId: 'south', name: 'South site' } as any)
-  const far = await spaces.save({ domain: { id: otherDomainId }, spaceId: 'far', name: 'Far site' } as any)
-
-  const areas = ds.getRepository(TwinArea)
-  /* The same areaId in two spaces of one tenant — that is what the space scope is for. */
-  await areas.save({ domain: { id: domainId }, space: { id: north.id }, areaId: 'hall-a', name: 'North Hall A' } as any)
-  await areas.save({ domain: { id: domainId }, space: { id: south.id }, areaId: 'hall-a', name: 'South Hall A' } as any)
-  await areas.save({ domain: { id: otherDomainId }, space: { id: far.id }, areaId: 'hall-a', name: 'Far Hall A' } as any)
-  /* An area with no name — the answer then carries the id alone, and does not invent one. */
-  await areas.save({ domain: { id: domainId }, space: { id: north.id }, areaId: 'annex' } as any)
-
-  const instances = ds.getRepository(TwinInstance)
-  await instances.save({ domain: { id: domainId }, instanceId: 'north-twin', kind: 'wms', restartPolicy: 'resume', purpose: 'operational', spaceId: 'north', status: 'stopped' } as any)
-  await instances.save({ domain: { id: domainId }, instanceId: 'south-twin', kind: 'wms', restartPolicy: 'resume', purpose: 'operational', spaceId: 'south', status: 'stopped' } as any)
-  await instances.save({ domain: { id: domainId }, instanceId: 'homeless-twin', kind: 'wms', restartPolicy: 'resume', purpose: 'operational', status: 'stopped' } as any)
-})
-
-after(async () => {
-  clearExternalResolvers()
-  await ds?.destroy()
-})
-
-test('an area of this twin comes back with its name', async () => {
-  const refs = await resolveAreas(domainId, ['hall-a'], { instanceId: 'north-twin' })
-  assert.deepEqual(refs, [{ id: 'hall-a', name: 'North Hall A' }])
-})
-
-test('the same areaId in another space of the same tenant never answers', async () => {
-  const south = await resolveAreas(domainId, ['hall-a'], { instanceId: 'south-twin' })
-  assert.deepEqual(south, [{ id: 'hall-a', name: 'South Hall A' }], 'each twin sees its own space')
-  const other = await resolveAreas(otherDomainId, ['hall-a'], { instanceId: 'north-twin' })
-  assert.deepEqual(other, [{ id: 'hall-a', missing: true }], 'a twin of another tenant is not this tenant’s twin')
-})
-
-test('an id that is in no area of this space is missing — it is not dropped', async () => {
-  const refs = await resolveAreas(domainId, ['hall-a', 'nowhere'], { instanceId: 'north-twin' })
-  assert.deepEqual(refs, [{ id: 'hall-a', name: 'North Hall A' }, { id: 'nowhere', missing: true }])
-})
-
-test('an area with no name answers with the id alone — no name is invented', async () => {
-  const refs = await resolveAreas(domainId, ['annex'], { instanceId: 'north-twin' })
-  assert.deepEqual(refs, [{ id: 'annex' }])
-})
-
-test('a twin with no space cannot have area parents, and says so', async () => {
-  const warned: string[] = []
-  const refs = await resolveAreas(domainId, ['hall-a'], { instanceId: 'homeless-twin' }, m => warned.push(m))
-  assert.deepEqual(refs, [{ id: 'hall-a', missing: true }])
-  assert.equal(warned.length, 1, 'the reason is said once, not swallowed')
-})
-
-test('the resolver is registered under the word the contract uses, and answers through the seam', async () => {
-  clearExternalResolvers()
-  installAreaResolver()
-  assert.ok(externalResolverEntities().includes(SPACE_AREA_ENTITY))
-  assert.equal(SPACE_AREA_ENTITY, 'space.area')
-  const got = await resolveExternal(SPACE_AREA_ENTITY, domainId, ['hall-a'], { instanceId: 'north-twin' })
-  assert.deepEqual(got, { refs: [{ id: 'hall-a', name: 'North Hall A' }] })
-})

package/test/attention-digest.test.ts

@@ -1,161 +0,0 @@
-/*
- * ★ 주의 신호 요약 — 신호가 많은 트윈의 전송량.
- *
- * ── 계기 ────────────────────────────────────────────────────────────────────
- * 축 선택으로 리프레시를 80KB → 2KB 로 줄였는데 **신호가 많은 트윈은 거기서 막혔다**:
- * `hatio-yard` 는 신호 397건이 108KB 라 5배 감소에 그쳤다. 그런데 화면이 그 397건으로 하는 일은
- * 둘뿐이다 — 레일에 20건만 그리고, 자리 7곳의 색을 뽑는다.
- *
- * ── 이 테스트가 지키는 것 ───────────────────────────────────────────────────
- *  ① **자리 색은 전량을 근거로** 계산된다. 상위 N 으로 줄이면 20위 밖의 신호를 가진 자리가 색을 잃는다.
- *  ② **알리지 않고 자르지 않는다.** 전체 개수를 함께 보내야 레일이 "N건 더" 를 말할 수 있다.
- *  ③ **순서가 화면과 같다.** 서버가 고른 20건이 화면이 고를 20건과 달라지면 아무 데서도 안 드러난다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
-
-import { digestAttentions, compareAttentions, mergeLensAttentions } from '../server/engine/attention-digest.ts'
-
-const attn = (id: string, severity: string, locationId?: string, state?: string) => ({ id, severity, state, anchor: locationId ? { locationId } : undefined })
-
-test('상위 N 만 남기고 전체 개수를 함께 낸다 — 알리지 않고 자르지 않는다', () => {
-  const all = Array.from({ length: 50 }, (_, i) => attn(`a${i}`, 'low', `loc-${i % 3}`))
-  const d = digestAttentions(all, 20)
-  assert.equal(d.attentions.length, 20)
-  assert.equal(d.attentionTotal, 50, '전체 개수가 없으면 화면이 "괜찮아졌다" 로 읽는다')
-})
-
-test('자리 색은 전량을 근거로 처리한다 — 상위 N 밖의 자리도 색을 갖는다', () => {
-  /* 앞 20건은 loc-hot 에, 21번째 한 건만 loc-cold 에 — 잘린 뒤에 계산하면 loc-cold 가 색을 잃는다. */
-  const all = [...Array.from({ length: 20 }, (_, i) => attn(`hot${i}`, 'high', 'loc-hot')), attn('cold', 'critical', 'loc-cold')]
-  const d = digestAttentions(all, 20)
-  assert.equal(d.attentions.length, 20)
-  assert.equal(d.severityByLocation['loc-cold'], 'critical', '상위 N 밖의 신호도 자리 색에는 반영돼야 한다')
-  assert.equal(d.severityByLocation['loc-hot'], 'high')
-})
-
-test('자리마다 가장 급한 심각도가 남는다', () => {
-  const d = digestAttentions([attn('a', 'low', 'n1'), attn('b', 'critical', 'n1'), attn('c', 'medium', 'n1')])
-  assert.equal(d.severityByLocation['n1'], 'critical')
-})
-
-test('순서는 화면과 같다 — 확인된 것은 아래로, 그다음 심각도순', () => {
-  const all = [attn('acked-crit', 'critical', 'n1', 'acknowledged'), attn('low', 'low', 'n2'), attn('high', 'high', 'n3')]
-  const d = digestAttentions(all, 2)
-  assert.deepEqual(d.attentions.map(a => a.id), ['high', 'low'], '확인된 critical 보다 확인 안 된 것이 먼저다')
-  assert.equal(d.attentionTotal, 3)
-})
-
-test('한도를 지정하지 않으면 자르지 않는다 — 이 값을 모르는 소비처가 일부만 받으면 안 된다', () => {
-  const all = Array.from({ length: 30 }, (_, i) => attn(`a${i}`, 'low'))
-  assert.equal(digestAttentions(all).attentions.length, 30)
-  assert.equal(digestAttentions(all, 0).attentions.length, 30)
-  assert.equal(digestAttentions(all, -5).attentions.length, 30)
-})
-
-test('자리에 붙지 않은 신호는 색 요약에 들어가지 않는다 — 없는 자리를 만들지 않는다', () => {
-  const d = digestAttentions([attn('orphan', 'critical'), attn('anchored', 'low', 'n1')])
-  assert.deepEqual(Object.keys(d.severityByLocation), ['n1'])
-  assert.equal(d.attentionTotal, 2, '색에 안 들어가도 개수에는 든다')
-})
-
-test('신호가 없으면 빈 요약 — 없는 것을 만들지 않는다', () => {
-  for (const v of [undefined, null, []]) {
-    const d = digestAttentions(v as any, 20)
-    assert.deepEqual(d.attentions, [])
-    assert.equal(d.attentionTotal, 0)
-    assert.deepEqual(d.severityByLocation, {})
-  }
-})
-
-test('정렬 함수는 원본을 바꾸지 않는다 — 스냅샷을 제자리에서 흔들면 다른 소비처가 영향받는다', () => {
-  const all = [attn('low', 'low'), attn('crit', 'critical')]
-  const before = all.map(a => a.id)
-  digestAttentions(all, 1)
-  assert.deepEqual(all.map(a => a.id), before)
-  assert.equal(compareAttentions(all[1], all[0]) < 0, true, 'critical 이 앞이다')
-})
-
-/*
- * ── 여러 렌즈를 한 현장으로 모으기 (2026-08-05) ────────────────────────────
- * 한 공장에 WMS·MES·YMS 가 함께 있으므로 "이 현장에서 봐야 할 것" 은 렌즈 하나로 답할 수 없다.
- * 예전에는 화면이 인스턴스마다 물어 손으로 합쳤고, 그러면 정렬 규칙이 화면마다 갈린다.
- *
- * 모으면서 알리지 않고 틀릴 수 있는 자리 셋을 여기서 못 박는다.
- */
-test('★ 어느 트윈에서 온 신호인지 붙는다 — 조치는 결국 그 트윈에 보내야 한다', () => {
-  const d = mergeLensAttentions([
-    { instanceId: 'wms', attentions: [attn('a', 'high', 'dock-1')] },
-    { instanceId: 'yms', attentions: [attn('b', 'low', 'gate-1')] }
-  ])
-  assert.deepEqual(d.attentions.map(a => [a.id, (a as any).instanceId]), [['a', 'wms'], ['b', 'yms']])
-})
-
-test('★ 순서는 렌즈 순서가 아니라 급한 순서다 — 뒤 렌즈의 심각한 신호가 밀려나면 안 된다', () => {
-  const d = mergeLensAttentions(
-    [
-      { instanceId: 'wms', attentions: [attn('low-1', 'low'), attn('low-2', 'low')] },
-      { instanceId: 'mes', attentions: [attn('crit', 'critical')] }
-    ],
-    1
-  )
-  assert.deepEqual(d.attentions.map(a => a.id), ['crit'], '상위 1건은 뒤 렌즈의 critical 이어야 한다')
-  assert.equal(d.attentionTotal, 3)
-})
-
-test('★ 두 렌즈가 같은 대상을 지목하면 더 급한 쪽이 색을 정한다 — 하나의 현실이므로', () => {
-  const d = mergeLensAttentions([
-    { instanceId: 'wms', attentions: [attn('a', 'low', 'dock-1')] },
-    { instanceId: 'yms', attentions: [attn('b', 'critical', 'dock-1')] }
-  ])
-  assert.equal(d.severityByLocation['dock-1'], 'critical')
-  /* 렌즈 순서를 뒤집어도 같아야 한다 — 색이 순서에 따라 달라지면 화면이 새로고침마다 바뀐다. */
-  const flipped = mergeLensAttentions([
-    { instanceId: 'yms', attentions: [attn('b', 'critical', 'dock-1')] },
-    { instanceId: 'wms', attentions: [attn('a', 'low', 'dock-1')] }
-  ])
-  assert.equal(flipped.severityByLocation['dock-1'], 'critical')
-})
-
-test('★ 신호가 없는 렌즈는 아무것도 보태지 않는다 — 빈 렌즈가 개수를 늘리지 않게', () => {
-  const d = mergeLensAttentions([
-    { instanceId: 'wms', attentions: [attn('a', 'low')] },
-    { instanceId: 'mes', attentions: [] },
-    { instanceId: 'yms', attentions: undefined }
-  ])
-  assert.equal(d.attentionTotal, 1)
-  assert.deepEqual(d.attentions.map(a => a.id), ['a'])
-})
-
-test('★ 렌즈가 하나도 없으면 빈 요약 — 공간에 배치된 트윈이 없을 때', () => {
-  const d = mergeLensAttentions([], 20)
-  assert.deepEqual(d.attentions, [])
-  assert.equal(d.attentionTotal, 0)
-  assert.deepEqual(d.severityByLocation, {})
-})
-
-/*
- * ── 자를 수 있는 문만 자른다 (2026-09-19, 수석 아키텍트 판정) ────────────────
- *
- * 목록 문(`twinAttentions`)에 `limit` 이 있었다. 자르면서 **몇 건을 잘랐는지는 답에 실을 자리가
- * 없었다** — 답이 맨 목록이라서다. 그러면 스무 건을 받은 화면은 그것이 전부인지 이백 중 스물인지
- * 구별할 수 없고, 그 구별이 없으면 「괜찮아졌다」로 읽힌다(위 ②와 같은 자리).
- *
- * 그래서 자르는 일은 **자른 수를 말할 수 있는 문**에만 둔다. 이 검사는 그 규칙을 소스에서 센다 —
- * 인자를 되돌려 놓으면 빨강이 된다.
- */
-test('★ 목록 문은 자르지 않는다 — 자르는 인자는 전체 개수를 함께 내는 문에만 있다', async () => {
-  const source = await readFile(new URL('../server/service/twin-attention/twin-attention-query.ts', import.meta.url), 'utf-8')
-
-  const listAt = source.indexOf('async twinAttentions(')
-  const digestAt = source.indexOf('async twinAttentionDigest(')
-  assert.ok(listAt >= 0 && digestAt > listAt, '두 문을 못 찾았다 — 이 검사는 아무것도 지키지 않는다')
-
-  const list = source.slice(listAt, digestAt)
-  const digest = source.slice(digestAt)
-
-  assert.ok(!/@Arg\(\s*'limit'/.test(list), '목록 문에 자르는 인자가 있다 — 자른 수를 답에 실을 자리가 없다')
-  assert.ok(/@Arg\(\s*'limit'/.test(digest), '자르는 문이 없어졌다 — 화면이 상위 N 을 받을 길이 없다')
-  assert.ok(/digestAttentions\(/.test(digest), '자르는 문은 전체 개수를 함께 내는 함수를 지나야 한다')
-})

package/test/axis-declaration-passthrough-db.test.ts

@@ -1,152 +0,0 @@
-/*
- * 축의 선언이 읽기 문을 그대로 지나간다 — `journalAxis` · `describedBy` (ADR-0074).
- *
- * 둘은 앱의 화면 상수에 있던 것이다. 그 자리에 있는 동안 축 이름이 한 세대 바뀌자 표가 따라오지
- * 못했고, 로케이션 · 오더 · 품목의 360 은 저널을 **묻지도 않은 채** 「이 개념은 이력 축이 없다」를
- * 그렸다. 계약으로 올라온 지금, 화면이 다시 자기 표를 만들지 않으려면 읽기 문이 그 값을 날라야 한다.
- *
- * 여기서 지키는 것은 하나다: **계약이 말한 값이 그대로 도착한다.** 값을 이 파일에 다시 적지 않는다 —
- * 다시 적으면 계약이 바뀔 때 시험이 같이 썩고, 지나가는지를 못 본다.
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import type { DataSource } from 'typeorm'
-
-const req = createRequire(import.meta.url)
-const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
-const { entities: authEntities } = req('@things-factory/auth-base')
-const { entities: twinEntities } = req('../dist-server/service/index.js')
-const { TwinEngine } = req('../dist-server/engine/index.js')
-const { TwinModelItemQuery } = req('../dist-server/service/twin-model/twin-model-item-query.js')
-const { axisInfo } = req('@operato/ops-contract')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let q: any
-let ctx: any
-const INSTANCE = 'declaration-probe'
-
-before(async () => {
-  ds = new TypeOrmDataSource({
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    namingStrategy: new NamingStrategy(),
-    entities: [...shellEntities, ...authEntities, ...twinEntities],
-    logging: false
-  })
-  await ds.initialize()
-  addDataSource('default', ds)
-  const d = await ds.getRepository(Domain).save({ name: 'decl-test', subdomain: 'decl-test' } as any)
-  q = new TwinModelItemQuery()
-  ctx = { state: { domain: { id: d.id } } }
-
-  /*
-   * 축마다 **자기 모양대로** 한 항목씩 — 설명 칸이 축마다 다른 이름으로 온다는 것이 아래 시험의 요점이다.
-   * (등급 넷과 검사 명세는 `name` 으로 들어오는데 형 선언은 `description` 을 말한다 — 실측, 2026-09-18.)
-   */
-  await TwinEngine.ingestMaster(d.id, {
-    source: INSTANCE,
-    system: 'wms',
-    siteName: 'declaration site',
-    space: { width: 40, depth: 20, unit: 'm' },
-    locations: [{ id: 'bin-1', type: 'storage', role: 'location', name: 'Bin 1', capacity: 10 }],
-    equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'bin-1' }],
-    equipmentClasses: [{ id: 'EC-FORKLIFT', name: '지게차' }],
-    materialClasses: [{ id: 'MC-BOX', name: '상자류' }],
-    materialDefinitions: [{ id: 'MD-BOX-01', name: '표준 상자', materialClassIds: ['MC-BOX'] }],
-    testSpecifications: [{ id: 'TS-DROP', name: '낙하 시험', version: '1', criteria: [] }]
-  }, 'reset')
-})
-
-after(async () => {
-  await TwinEngine.stop(ctx.state.domain.id, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('★ 자리의 이력 축과 설명 필드가 계약이 말한 그대로 도착한다', async () => {
-  const item = await q.twinModelItem(INSTANCE, 'locations', 'bin-1', ctx)
-  const declared = axisInfo('locations')
-  assert.ok(declared?.journalAxis, '계약이 자리의 저널 축을 말하지 않는다 — 시험의 기준이 비었다')
-  assert.equal(item.identity.journalAxis, declared.journalAxis)
-  assert.deepEqual(item.identity.describedBy, declared.describedBy)
-})
-
-test('★ 설비도 같은 자리에서 자기 선언을 받는다 — 축마다 다른 값이 온다', async () => {
-  const item = await q.twinModelItem(INSTANCE, 'equipment', 'fk-1', ctx)
-  const declared = axisInfo('equipment')
-  assert.equal(item.identity.journalAxis, declared!.journalAxis)
-  assert.deepEqual(item.identity.describedBy, declared!.describedBy)
-  /* 두 축이 같은 값을 받으면 「지나간다」를 못 본 것이다. */
-  assert.notEqual(declared!.journalAxis, axisInfo('locations')!.journalAxis)
-})
-
-test('★ 저널이 그 축으로 기록하지 않는 개념은 null 로 온다 — 없는 것을 이름으로 채우지 않는다', async () => {
-  const declared = axisInfo('operations')
-  assert.equal(declared?.journalAxis, undefined, '명세 축은 저널 축을 갖지 않는다')
-  /* 이 트윈에는 공정 선언이 없다 — 선언이 없는 축도 문은 같은 모양으로 답한다. */
-  const item = await q.twinModelItem(INSTANCE, 'operations', 'no-such-operation', ctx)
-  if (item) assert.equal(item.identity.journalAxis, null, '없는 것은 null 이고 빈 문자열이 아니다')
-})
-
-/*
- * 상태 축에 없는 개체를 물으면 — **그런 개체가 없다**고 답한다.
- *
- * 2026-09-18, 도는 서버에서: 지어낸 작업 식별자(`tasks:T-1`)로 물었더니 패널이 하나 돌아왔고 화면은
- * 「트윈이 실제로 본 것입니다」라고 적었다. 있지도 않은 개체가 **값이 비어 있는 개체**처럼 보였다.
- * 갈래가 `!snap || !found` 하나여서 두 사실이 한 답으로 접혔기 때문이다.
- *
- *   상태를 읽었는데 없다   → 그런 개체가 없다(문서 축과 같은 `null`)
- *   상태를 못 읽었다       → 모른다. 이유를 코드로 말한다(`not-running`)
- */
-test('★ 상태를 읽었는데 그 개체가 없으면 없다고 답한다 — 빈 개체를 만들지 않는다', async () => {
-  const gone = await q.twinModelItem(INSTANCE, 'tasks', 'NO-SUCH-TASK-ID', ctx)
-  assert.equal(gone, null, '없는 개체에 패널을 돌려주면 화면이 그것을 그린다')
-})
-
-test('★ 같은 물음을 문서 축에 해도 같은 답이다 — 축마다 다른 말을 하지 않는다', async () => {
-  const gone = await q.twinModelItem(INSTANCE, 'locations', 'NO-SUCH-LOCATION', ctx)
-  assert.equal(gone, null)
-})
-
-test('★ 있는 개체는 그대로 답한다 — 위의 고침이 다 지워 버리지 않았는지', async () => {
-  const item = await q.twinModelItem(INSTANCE, 'locations', 'bin-1', ctx)
-  assert.ok(item, '있는 개체가 사라졌다')
-  assert.equal(item.itemId, 'bin-1')
-})
-
-/*
- * **선언이 고른 칸이 실제 항목에 있는가** (2026-09-18).
- *
- * `describedBy` 를 형 선언에서 뽑아 적었더니 여섯 축이 빗나갔다 — 등급 넷 · 품목 정의 · 검사 명세는
- * 형이 `description` 을 말하는데 들어오는 자료는 `name` 을 든다. 화면은 오류 없이 **밑줄이 없는
- * 제목**만 그렸다(도는 트윈에서 실측). 계약과 자료가 갈린 것을 시험이 못 잡았던 이유는, 그 시험이
- * 「그 이름이 계약 어딘가에 선언돼 있나」까지만 봤기 때문이다.
- *
- * 그래서 여기서는 **들어온 항목**에 대고 잰다: 선언한 칸 중 적어도 하나가 그 항목에 값으로 있어야 한다.
- */
-test('★ 선언이 고른 칸 중 하나는 실제 항목이 들고 있다 — 계약과 자료가 갈리면 밑줄이 사라진다', async () => {
-  const sample: Record<string, string> = {
-    locations: 'bin-1',
-    equipment: 'fk-1',
-    equipmentClasses: 'EC-FORKLIFT',
-    materialClasses: 'MC-BOX',
-    materialDefinitions: 'MD-BOX-01',
-    testSpecifications: 'TS-DROP'
-  }
-  const missing: string[] = []
-  for (const [axis, itemId] of Object.entries(sample)) {
-    const item = await q.twinModelItem(INSTANCE, axis, itemId, ctx)
-    assert.ok(item, `${axis}: 픽스처가 안 들어갔다 — 이 시험이 아무것도 재지 못한다`)
-    const keys: string[] = item.identity?.describedBy ?? []
-    assert.ok(keys.length, `${axis}: 계약이 설명 칸을 말하지 않는다`)
-    const has = keys.some(k => {
-      const v = (item.observed ?? {})[k] ?? (item.declared ?? {})[k]
-      return v != null && v !== ''
-    })
-    if (!has) missing.push(`${axis}: 선언은 [${keys.join(', ')}] 인데 항목이 든 것은 [${Object.keys(item.declared ?? {}).join(', ')}]`)
-  }
-  assert.deepEqual(missing, [], missing.join('\n'))
-})

package/test/axis-journal-evidence.test.ts

@@ -1,71 +0,0 @@
-/*
- * 상태가 빈 축의 이유 — **「아직 없다」와 「왔는데 상태에 없다」를 가른다** (2026-08-22).
- *
- * ── 무엇이 있었나 ───────────────────────────────────────────────────────────
- * 카드가 「작업 — 아직 하나도 없습니다」라고 말했다. 그 트윈의 저널에는 `task.status` 5,786건이 있었고
- * **마지막 상태가 `in-progress`** 였다. 사용자가 「작업 지시 835건인데 작업이 0인 이유」를 물었고,
- * 원인은 관측 모드 커널이 관측기의 작업을 스냅샷으로 내보내지 않는 것이었다(커널 자리, 그 레인에 넘겼다).
- *
- * **화면 몫은 단정하지 않는 것이다.** 「아직 하나도 없습니다」는 「선언은 있고 사실이 아직 일어나지
- * 않았다」는 뜻인데 실제로는 「사실이 일어났는데 상태에 오지 못했다」였다. 그 차이를 화면이 말하지
- * 않아서 사용자가 직접 조사해야 했다.
- *
- * 이 시험이 지키는 것:
- *  ① 저널에 그 축의 사건이 있으면 **그렇게 말한다**.
- *  ② 없으면 예전 그대로 「아직 없다」다.
- *  ③ 판단할 수 없는 축은 **아무 말도 만들지 않는다**(`null`) — 모르는 것을 새 사실로 바꾸지 않는다.
- *  ④ 한 건만 묻는다 — 세는 것도 비용이다(저널 358만 행에서 전량 세기는 5.32초였다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { axisSeenInJournal } from '../server/service/twin-model/axis-journal-evidence.ts'
-
-/** 저장소 흉내 — 어떤 조건으로 몇 번 물었는지 기록한다. */
-function repoWith(present: string[]) {
-  const asked: any[] = []
-  return {
-    asked,
-    async find(opts: any) {
-      asked.push(opts)
-      const t = opts?.where?.eventType
-      const hit =
-        typeof t === 'string'
-          ? present.includes(t)
-          : /* Like(…) 객체 — 접두사로 본다 */
-            present.some(p => p.startsWith(String(t?._value ?? '').replace('%', '')))
-      return hit ? [{ id: 'x' }] : []
-    }
-  } as any
-}
-
-const WHERE = { domain: { id: 'd' }, instanceId: 'twin-1' }
-
-test('저널에 그 축의 사건이 있으면 그렇게 말한다 — 작업', async () => {
-  const repo = repoWith(['task.status'])
-  assert.equal(await axisSeenInJournal(repo, WHERE, 'tasks'), true)
-})
-
-test('없으면 예전 그대로 — 아직 없다', async () => {
-  const repo = repoWith(['order.status'])
-  assert.equal(await axisSeenInJournal(repo, WHERE, 'tasks'), false)
-})
-
-test('물품은 사건 이름이 여럿이라 접두사로 본다 — 커널이 이름을 늘려도 낡지 않게', async () => {
-  const repo = repoWith(['epcis.AggregationEvent'])
-  assert.equal(await axisSeenInJournal(repo, WHERE, 'items'), true)
-})
-
-test('판단할 수 없는 축은 아무 말도 만들지 않는다', async () => {
-  const repo = repoWith(['task.status'])
-  assert.equal(await axisSeenInJournal(repo, WHERE, 'locations'), null, '표에 없는 축은 모른다')
-  assert.equal(repo.asked.length, 0, '모르는 축을 두고 저널을 묻지 않는다')
-})
-
-test('한 건만 묻는다 — 세는 것도 비용이다', async () => {
-  const repo = repoWith(['task.status'])
-  await axisSeenInJournal(repo, WHERE, 'tasks')
-  assert.equal(repo.asked.length, 1)
-  assert.equal(repo.asked[0].take, 1, '한 건만 읽는다')
-  assert.deepEqual(repo.asked[0].select, ['id'], '키 컬럼만 읽는다(행 본문을 만들지 않는다)')
-})