@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/intake-mapping-parity.test.ts

@@ -1,175 +0,0 @@
-/*
- * ★ **접수 타입에 있는 칸은 매핑도 옮긴다** — 문턱에서 조용히 버려지던 자리.
- *
- * ── 오늘 이 부류가 일곱 번이었다 (2026-09-04) ──────────────────────────────
- *   ActuationAck 이 세 칸을 버린다고 말한다     타입과 값 사이
- *   save 가 새 칸을 안 쓴다                    칸과 쓰는 길
- *   질의가 noteNext 를 안 낸다                 저장과 화면 사이
- *   커넥터가 등급 셋을 읽어 놓고 버린다          원본 쪽
- *   homeLocation vs homeLocationId            낱말 하나
- *   equipmentClassIds 칸이 접수면에 없다        ← 이 검사가 막는 것
- *   materialActual 안쪽을 안 본다               검사가 얕다
- *
- * **일곱 다 오류가 안 나서** 검사로만 잡혔다.
- *
- * ── 이 자리가 특히 조용하다 ─────────────────────────────────────────────────
- * 접수 타입(`RefEquipment` …)에 칸이 있어도 매핑 함수가 안 옮기면 **원본이 채운 값이 문턱에서
- * 사라진다.** 타입만 봐서는 안 보인다 — 타입은 「받는다」고 말하고 있으니까.
- *
- * 실제로 그렇게 났다: 설비 22대에 등급을 다 채웠는데 등급 목록만 서고 소속은 아무도 없었다.
- * 화면에서 등급을 골라도 설비가 안 나왔고, 거절도 경고도 없었다.
- *
- * ── 왜 원문을 읽나 ──────────────────────────────────────────────────────────
- * 매핑은 객체 리터럴이라 런타임에 「무엇을 옮기나」를 물을 수 없다(입력을 다 채워 넣어 답을 보는
- * 방법이 있지만, 그러면 선택 필드마다 픽스처를 손으로 적어야 하고 그 손이 바로 빠뜨리는 자리다).
- * 원문에서 읽으면 **이름을 손으로 적지 않아** 타입이 늘 때 검사가 함께 따라간다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-const SRC = readFileSync(new URL('../server/service/reference/reference-master.ts', import.meta.url), 'utf8')
-  .replace(/\/\*[\s\S]*?\*\//g, '')
-  .replace(/\/\/[^\n]*/g, '')
-
-/** 접수 타입 하나의 칸 이름들 — `export interface X { … }` 의 깊이 1 필드. */
-function intakeFields(name: string): string[] {
-  const start = SRC.indexOf(`export interface ${name} {`)
-  assert.ok(start >= 0, `접수 타입을 못 찾았다: ${name} — 이 검사가 따라가야 한다`)
-  const body = SRC.slice(SRC.indexOf('{', start))
-  const end = body.indexOf('\n}')
-  assert.ok(end > 0, `${name} 의 끝을 못 찾았다`)
-  return [...new Set([...body.slice(0, end).matchAll(/^\s{2}([a-zA-Z][\w]*)\??:/gm)].map(m => m[1]))]
-}
-
-/**
- * 매핑 함수가 **읽는** 칸들 — `e.foo` · `a.foo` 처럼 원본 줄에서 꺼내는 이름.
- *
- * 옮긴 뒤 이름이 바뀌는 것도 있다(`homeLocationId → homeLocation`). 그래서 「나가는 이름」이 아니라
- * **「읽는 이름」**을 센다 — 읽지 않으면 옮길 수도 없다.
- */
-function readFields(varName: string): string[] {
-  return [...new Set([...SRC.matchAll(new RegExp(`\\b${varName}\\.([a-zA-Z][\\w]*)`, 'g'))].map(m => m[1]))]
-}
-
-/**
- * 일부러 안 옮기는 칸 — 이유와 함께.
- *
- * 비어 있는 것이 정상이 아니다: 접수면이 받아 두고 커널에 안 넘기는 값이 있으면 **왜 받는지**가
- * 적혀 있어야 한다. 안 적으면 다음 사람이 「원래 그런가 보다」로 넘긴다.
- */
-const NOT_MAPPED: Record<string, { fields: string[]; why: string }> = {
-  RefEquipment: {
-    fields: [],
-    why: ''
-  },
-  RefAsset: {
-    fields: [],
-    why: ''
-  },
-  RefPerson: {
-    fields: [],
-    why: ''
-  }
-}
-
-const CASES = [
-  { intake: 'RefEquipment', reads: 'e' },
-  { intake: 'RefAsset', reads: 'a' },
-  { intake: 'RefPerson', reads: 'p' }
-] as const
-
-test('★ 접수 타입의 칸을 매핑이 다 읽는다 — 안 읽으면 원본이 채운 값이 문턱에서 사라진다', () => {
-  const dropped: string[] = []
-
-  for (const c of CASES) {
-    const excused = new Set(NOT_MAPPED[c.intake]?.fields ?? [])
-    const read = new Set(readFields(c.reads))
-
-    for (const f of intakeFields(c.intake)) {
-      if (!read.has(f) && !excused.has(f)) dropped.push(`${c.intake}.${f}`)
-    }
-  }
-
-  assert.deepEqual(
-    dropped,
-    [],
-    '접수 타입은 받는다고 말하는데 매핑이 안 읽는다. 원본이 채운 값이 조용히 사라진다:\n  ' +
-      dropped.join('\n  ') +
-      '\n매핑에 넣거나, 일부러 안 넘긴다면 NOT_MAPPED 에 이유를 적는다.'
-  )
-})
-
-test('★ 등급 소속 셋이 다 접수면을 지난다 — 이름으로 못 박는다', () => {
-  /*
-   * 위 검사는 목록 대조라 예외 표에 올리면 통과한다. 이 셋은 **소속이 없으면 등급으로 부르는
-   * 요구가 채워지지 않는** 자리여서 예외가 될 수 없다.
-   */
-  for (const [type, field, reads] of [
-    ['RefEquipment', 'equipmentClassIds', 'e'],
-    ['RefAsset', 'assetClassIds', 'a'],
-    ['RefPerson', 'personnelClassIds', 'p']
-  ] as const) {
-    assert.ok(intakeFields(type).includes(field), `${type} 에 ${field} 칸이 없다`)
-    assert.ok(readFields(reads).includes(field), `매핑이 ${type}.${field} 를 안 읽는다 — 소속이 문턱에서 사라진다`)
-  }
-})
-
-test('★ 사람도 정체성 자리를 갖는다 — 그리고 그 자리는 개인정보가 아니다', () => {
-  /*
-   * ── 왜 열었나 (2026-09-05, 인티그레이션 레인이 물음) ────────────────────────
-   * 설비에서 이 자리를 만든 이유가 사람에게도 그대로 걸린다 — 지역 이름은 그 현장 안에서만
-   * 고유하다. `E-1001` 이 다른 공장에도 있으면 여러 현장을 함께 보는 순간 한쪽이 사라진다.
-   *
-   * ── 왜 이 검사에 규약을 함께 적나 ──────────────────────────────────────────
-   * 설비와 사람이 갈리는 자리가 있다. 사람의 「전역에서 고유한 값」은 사원번호·카드번호처럼
-   * **그 사람에 관한 사실**이고, 저널은 되풀이 읽히고 미러로 복제되고 구독으로 방송된다 —
-   * 한 번 들어가면 지워지지 않는다.
-   *
-   * 이 칸이 요구하는 것은 **현장을 앞에 붙여 전역에서 고유해진 이름**이다(`objectUri` 가 만든다).
-   * 그 규약이 주석에만 있으면 다음 커넥터가 카드번호를 넣는다 — 그러니 소스에 그 문장이 실제로
-   * 있는지를 검사가 지킨다.
-   */
-  assert.ok(intakeFields('RefPerson').includes('identity'), 'RefPerson 에 identity 칸이 없다')
-  assert.ok(readFields('p').includes('identity'), '매핑이 사람의 identity 를 안 읽는다')
-
-  /* 규약이 글로 남아 있나 — 지우면 이 줄이 빨개진다. */
-  const raw = readFileSync(new URL('../server/service/reference/reference-master.ts', import.meta.url), 'utf8')
-  const start = raw.indexOf('export interface RefPerson')
-  const personDoc = raw.slice(start, raw.indexOf('\n}', start))
-  assert.ok(personDoc.includes('개인정보'), '개인정보를 넣지 않는다는 규약이 사라졌다')
-  assert.ok(personDoc.includes('objectUri'), '무엇을 넣어야 하는지(이름공간 아래 식별자)가 사라졌다')
-})
-
-test('★ 정체성 낱말이 세 자리에서 같다 — 마스터가 내는 이름과 접수면이 받는 이름', () => {
-  /*
-   * 설비는 `identity` 로 바꿨는데 자산은 `gs1Id` 로 남아 있었다. 마스터는 둘 다 `identity` 로
-   * 내므로 자산 쪽은 **원본이 채우는 순간 조용히 사라졌다** — 값이 다 비어 있어 아직 잃은 것은
-   * 없었다(인티그레이션 레인 실측).
-   *
-   * 자리(`RefLocation`)는 `gs1Id` 가 맞다 — 거기는 실제로 SGLN 이 온다.
-   */
-  assert.ok(intakeFields('RefEquipment').includes('identity'), '설비 정체성 이름이 바뀌었다')
-  assert.ok(intakeFields('RefAsset').includes('identity'), '자산이 아직 마스터와 다른 이름을 쓴다')
-  assert.ok(!intakeFields('RefAsset').includes('gs1Id'), '자산에 옛 이름이 남아 있다')
-  assert.ok(intakeFields('RefLocation').includes('gs1Id'), '자리는 SGLN 이 오므로 그 이름이 맞다')
-})
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  /*
-   * 정규식이 모양을 못 따라가면 목록이 비고, 그러면 위 검사가 **초록인데 아무것도 안 재는 상태**가
-   * 된다. 오늘 이 저장소에서 그 부류를 여러 번 잡았다.
-   */
-  for (const c of CASES) {
-    const fields = intakeFields(c.intake)
-    const read = readFields(c.reads)
-    assert.ok(fields.length > 5, `${c.intake} 칸을 ${fields.length}개만 읽었다`)
-    assert.ok(read.length > 5, `${c.reads}.* 를 ${read.length}개만 읽었다`)
-  }
-
-  /* 이유 없는 예외는 예외가 아니다 — 비어 있는 항목은 예외가 아니라 자리표시다. */
-  for (const [type, e] of Object.entries(NOT_MAPPED)) {
-    if (!e.fields.length) continue
-    assert.ok(e.why?.trim(), `${type} 의 예외에 이유가 없다`)
-  }
-})

package/test/integration-probes.test.ts

@@ -1,103 +0,0 @@
-/*
- * ★ 연결 적합성 하네스 — **절반만 돌린 스위트가 초록을 주장하지 못하게.**
- *
- * 지키는 것:
- *  ① 돌리지 않은 프로브는 **「모른다」**로 처리된다 → 판정이 그 단계를 달성으로 만들지 않는다.
- *  ② **실패한 프로브의 수를 0 으로 읽지 않는다.** 「0건이었다」와 「세지 못했다」는 다른 사실이다.
- *  ③ **쓰기 프로브는 동의 없이 계획에 들어오지 않는다** — 남의 운영 시스템에 명령을 넣는 일이다.
- *  ④ **게이팅 실패 뒤는 돌리지 않는다** — 빨간 칸을 늘리는 것은 원인을 알려 주지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { PROBE_SEQUENCE, foldProbeResults, plannedProbes, type ProbeResult } from '../server/engine/integration-probes.ts'
-import { assessStagePath, forbiddenClaims } from '../server/engine/stage-path.ts'
-
-const pass = (id: any, count?: number, coverage?: { declared: number; total: number }): ProbeResult =>
-  ({ id, ran: true, passed: true, ...(count !== undefined ? { count } : {}), ...(coverage ? { coverage } : {}) })
-
-/** 읽기 프로브 전부 통과 — 반출까지 관측된 상태. */
-const readOnlyAllPass = (): ProbeResult[] => [
-  pass('connect'), pass('discover', 1), pass('master', 12), pass('master-warnings', 3), pass('items', 340),
-  pass('live-ingest', 1200), pass('live-removal', 17),
-  pass('declarations', undefined, { declared: 6, total: 8 }), pass('forecast'),
-  pass('actuate-declared')
-]
-
-test('시퀀스는 읽기부터 시작하고 쓰기 프로브는 하나뿐이다', () => {
-  assert.equal(PROBE_SEQUENCE[0].id, 'connect')
-  assert.deepEqual(PROBE_SEQUENCE.filter(p => p.writes).map(p => p.id), ['actuate-effect'])
-})
-
-test('아무것도 돌리지 않았으면 첫 칸부터 「모른다」다 — 실패로 계산하지 않는다', () => {
-  const p = assessStagePath(foldProbeResults([]))
-  assert.equal(p.reached, null)
-  assert.deepEqual(p.next?.stage, 'structure')
-  assert.ok(p.stages[0].blockedBy.includes('no-locations'))
-  assert.ok(p.stages[0].unmeasured.includes('master-warnings'), '세지 않은 것은 모르는 것이다')
-})
-
-test('읽기만 전부 통과하면 예측까지 도달하고 폐루프는 「검증되지 않음」으로 남는다', () => {
-  const p = assessStagePath(foldProbeResults(readOnlyAllPass()))
-  assert.equal(p.reached, 'forecast')
-  assert.deepEqual(p.stages[3].unmeasured, ['correlated-effect'])
-  assert.deepEqual(p.stages[3].blockedBy, [], '능력은 선언∩구현이므로 막힌 것이 아니라 안 돌린 것이다')
-  assert.deepEqual(forbiddenClaims(p), ['claim.automatic-control'])
-})
-
-test('쓰기 프로브를 돌려 효과가 관측되면 폐루프가 닫힌다', () => {
-  const p = assessStagePath(foldProbeResults([...readOnlyAllPass(), pass('actuate-effect', 2)]))
-  assert.equal(p.reached, 'closed-loop')
-  assert.deepEqual(forbiddenClaims(p), [])
-})
-
-test('측정하지 못한 프로브는 수를 들지 않는다 — 0 을 지어내지 않는다', () => {
-  /*
-   * 규칙은 「실패면 모른다」가 아니다 — **센 값은 판정과 무관한 사실**이다(0건도 사실이다).
-   * 측정 자체를 못 한 프로브(타임아웃 등)는 `count` 를 **비운다**. 0 을 채우면 「세어 보니 없었다」로
-   * 읽히고, 그건 스냅샷 피드를 delta 로 오인하게 만드는 정반대의 결론을 낳는다.
-   */
-  const rs: ProbeResult[] = [...readOnlyAllPass().filter(r => r.id !== 'live-removal'),
-    { id: 'live-removal', ran: true, passed: false, detail: 'timeout' }]
-  const e = foldProbeResults(rs)
-  assert.equal(e.removalsObserved, null, '측정하지 못했으면 모른다')
-  assert.deepEqual(assessStagePath(e).stages[1].unmeasured, ['removals'])
-})
-
-test('세어서 0 을 얻은 것은 사실이다 — 모른다로 계산하지 않는다', () => {
-  const rs: ProbeResult[] = [...readOnlyAllPass().filter(r => r.id !== 'live-removal'),
-    { id: 'live-removal', ran: true, passed: false, count: 0 }]
-  const e = foldProbeResults(rs)
-  assert.equal(e.removalsObserved, 0)
-  assert.deepEqual(assessStagePath(e).stages[1].blockedBy, ['no-removal-observed'])
-})
-
-test('반출을 세었는데 0 이면 라이브가 막힌다 — 스냅샷 되풀어 읽기', () => {
-  const rs: ProbeResult[] = [...readOnlyAllPass().filter(r => r.id !== 'live-removal'), pass('live-removal', 0)]
-  const p = assessStagePath(foldProbeResults(rs))
-  assert.deepEqual(p.stages[1].blockedBy, ['no-removal-observed'])
-  assert.equal(p.reached, 'structure')
-  assert.ok(forbiddenClaims(p).includes('claim.realtime'))
-})
-
-test('쓰기 프로브는 동의 없이 계획에 들어오지 않는다', () => {
-  assert.ok(!plannedProbes([]).includes('actuate-effect'))
-  assert.ok(plannedProbes([], { allowWrites: true }).includes('actuate-effect'))
-})
-
-test('게이팅 프로브가 실패하면 그 뒤는 계획하지 않는다', () => {
-  const planned = plannedProbes([{ id: 'connect', ran: true, passed: false, detail: '401' }])
-  assert.deepEqual(planned, [], '붙지 못했으면 뒤를 두드릴 이유가 없다')
-})
-
-test('통과한 프로브는 다시 계획하지 않고, 남은 것만 계획한다', () => {
-  const planned = plannedProbes([pass('connect'), pass('discover', 1)])
-  assert.equal(planned[0], 'master')
-  assert.ok(!planned.includes('connect'))
-})
-
-test('게이팅이 아닌 프로브의 실패는 뒤를 멈추지 않는다', () => {
-  const planned = plannedProbes([pass('connect'), pass('discover', 1), pass('master', 12),
-    { id: 'master-warnings', ran: true, passed: false, detail: 'not-counted' }])
-  assert.ok(planned.includes('items'), '못 옮긴 값을 세지 못한 것이 구조 확인을 멈추지는 않는다')
-})

package/test/integration-runner.test.ts

@@ -1,95 +0,0 @@
-/*
- * ★ 실행기 — **회색 칸이 빨간 칸으로 위장되지 않게.**
- *
- *  ① 시뮬 트윈에 라이브를 요구하지 않는다(해당 없음). 그 빨강은 결함이 아니다.
- *  ② 템플릿으로 세운 트윈에는 옮겨 온 마스터가 없다 — 「못 옮긴 값」을 물을 대상이 아니다.
- *  ③ 반출 0 의 처방이 둘로 갈린다: 스냅샷이면 방식을 바꿔야 하고, 아니면 더 기다릴 수 있다.
- *  ④ 액추에이션은 계약에 없다 — 측정을 만들지 않고 미실행으로 남긴다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { assessSuite, type SuiteFacts } from '../server/engine/integration-runner.ts'
-
-const live = (): SuiteFacts => ({
-  subject: 'live',
-  fromReference: true,
-  adapterCapabilities: ['live'],
-  connectOk: true,
-  siteCount: 3,
-  locationCount: 12,
-  itemCount: 340,
-  lastWarningCount: 2,
-  journalTotal: 1200,
-  removalsJournaled: 17,
-  specCoverage: { declared: 6, total: 8 },
-  forecastRan: true,
-  feed: 'delta-poll'
-})
-
-test('라이브 전부 갖추면 예측까지 도달하고, 폐루프는 능력이 없어 막힌다', () => {
-  const a = assessSuite(live())
-  assert.equal(a.path.reached, 'forecast')
-  assert.deepEqual(a.path.stages[3].blockedBy, ['no-actuate-capability'])
-  assert.deepEqual(a.forbiddenClaims, ['claim.automatic-control'])
-  assert.equal(a.profile.multiSite, true)
-})
-
-test('시뮬 트윈은 라이브가 해당 없음이고, 그 사유를 말한다', () => {
-  const a = assessSuite({ ...live(), subject: 'sim', journalTotal: null, removalsJournaled: null })
-  assert.deepEqual(a.notApplicable.map(n => n.id), ['live-ingest', 'live-removal'])
-  assert.deepEqual(a.path.stages[1].blockedBy, ['subject-is-simulation'])
-  assert.deepEqual(a.path.stages[1].unmeasured, [], '해당 없음을 미측정으로 계산하지 않는다')
-  assert.equal(a.path.reached, 'structure')
-  assert.ok(!a.planned.includes('live-removal'), '해당 없는 프로브는 계획하지 않는다')
-})
-
-test('템플릿으로 세운 트윈은 못 옮긴 값을 물을 대상이 아니다', () => {
-  const a = assessSuite({ ...live(), fromReference: false, lastWarningCount: null })
-  assert.deepEqual(a.notApplicable.map(n => n.id), ['master-warnings'])
-  assert.equal(a.path.stages[0].achieved, true, '해당 없음이 구조 달성을 막지 않는다')
-})
-
-test('반출 0 — 스냅샷이면 방식을 바꿔야 한다고 말한다', () => {
-  const a = assessSuite({ ...live(), removalsJournaled: 0, feed: 'snapshot-poll' })
-  assert.deepEqual(a.path.stages[1].blockedBy, ['snapshot-only-feed'])
-  assert.ok(a.forbiddenClaims.includes('claim.realtime'))
-})
-
-test('반출 0 — 스냅샷이 아니면 아직 일어나지 않은 것일 수 있다', () => {
-  const a = assessSuite({ ...live(), removalsJournaled: 0, feed: 'delta-poll' })
-  assert.deepEqual(a.path.stages[1].blockedBy, ['no-removal-observed'])
-})
-
-test('승격 전 저널은 반출을 셀 수 없다 — 「없다」가 아니라 「모른다」', () => {
-  const a = assessSuite({ ...live(), removalsJournaled: null })
-  assert.deepEqual(a.path.stages[1].unmeasured, ['removals'])
-  assert.deepEqual(a.path.stages[1].blockedBy, [])
-})
-
-test('액추에이션 효과는 측정을 만들지 않고 미실행으로 남긴다', () => {
-  const a = assessSuite({ ...live(), adapterCapabilities: ['live', 'actuate'] })
-  const eff = a.results.find(r => r.id === 'actuate-effect')!
-  assert.equal(eff.ran, false)
-  assert.equal(eff.detail, 'actuation-not-wired')
-  assert.deepEqual(a.path.stages[3].unmeasured, ['correlated-effect'])
-})
-
-test('쓰기 프로브는 동의 없이 계획에 들어오지 않는다', () => {
-  const able = { ...live(), adapterCapabilities: ['live', 'actuate'] }
-  assert.ok(!assessSuite(able).planned.includes('actuate-effect'))
-  assert.ok(assessSuite(able, { allowWrites: true }).planned.includes('actuate-effect'))
-})
-
-test('액추에이션 능력이 없으면 쓰기 동의가 있어도 계획하지 않는다 — 보낼 문이 없다', () => {
-  assert.ok(!assessSuite(live(), { allowWrites: true }).planned.includes('actuate-effect'))
-})
-
-test('접속을 안 돌렸으면 구조부터 미측정이 아니라 미실행으로 남고, 계획의 첫 칸이 된다', () => {
-  const a = assessSuite({ ...live(), connectOk: null })
-  assert.equal(a.planned[0], 'connect')
-})
-
-test('못 옮긴 값이 0 이어도 세었으므로 통과다', () => {
-  assert.equal(assessSuite({ ...live(), lastWarningCount: 0 }).path.stages[0].achieved, true)
-})

package/test/item-ref.test.ts

@@ -1,78 +0,0 @@
-/*
- * 개체 → 품목 참조 — **정체성 모양이 하나가 아니고, 구분자는 우리가 정하지 않는다** (2026-08-23).
- *
- * ── 무엇이 알리지 않고 비어 있었나 ───────────────────────────────────────────────
- * 화면이 「이 개체는 선언된 자재가 아닙니다」라고 말했다. 그런데 그 품목은 원본의 선언에 이름까지 있었고
- * (「냉동그린빈스」), 대응 표도 멀쩡했다. 원인은 참조를 꺼내는 규칙이 GS1 SGTIN 하나만 알았던 것이다.
- *
- * ── 그리고 고치는 방향을 한 번 더 고쳤다 ────────────────────────────────────
- * 처음에는 「`@` 뒤는 개체다」를 규칙으로 넣었다. 그것은 **한 원본(chef)의 관행**이고, 커널 계약이 그
- * 구분자를 정한 적이 없다 — 사용자가 「이 화면이 특정 레거시를 기준으로 해서는 안 된다」고 짚었다.
- * 그래서 자르는 판단을 걷고, **그 트윈의 선언과 비교해** 답한다.
- *
- * 이 시험이 지키는 것:
- *  ① SGTIN 은 표준이 정한 자리에서 품목 참조를 꺼낸다.
- *  ② 그 밖의 모양은 **손대지 않는다**(구분자를 모른다).
- *  ③ 선언과 비교할 때는 두 방향을 본다 — 관측이 선언을 확장한 경우, 화면이 짧게 줄인 경우.
- *  ④ 후보가 둘 이상이면 **답하지 않는다**(모르는 것이 틀린 답보다 낫다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { itemRefOf, resolveByDeclaration } from '../server/service/twin-model/item-ref.ts'
-
-test('GS1 SGTIN 은 품목 참조 숫자다 — 표준이 자리를 정해 두었다', () => {
-  assert.equal(itemRefOf('urn:epc:id:sgtin:0614141.077101.42'), '077101')
-  assert.equal(itemRefOf('urn:epc:idpat:sgtin:0614141.078101.*'), '078101')
-})
-
-test('그 밖의 정체성은 손대지 않는다 — 어느 부호가 개체인지 우리가 정하지 않는다', () => {
-  assert.equal(itemRefOf('https://x.net/class/product-M1@M2R0001'), 'https://x.net/class/product-M1@M2R0001')
-  assert.equal(itemRefOf('https://x.net/class/product-M1'), 'https://x.net/class/product-M1')
-  assert.equal(itemRefOf('  https://x.net/class/p-1  '), 'https://x.net/class/p-1', '앞뒤 공백만 다듬는다')
-})
-
-test('읽을 수 없는 값은 null 이다', () => {
-  assert.equal(itemRefOf(''), null)
-  assert.equal(itemRefOf('   '), null)
-  assert.equal(itemRefOf(null), null)
-  assert.equal(itemRefOf(undefined), null)
-  assert.equal(itemRefOf(42), null)
-})
-
-const DECLARED = new Map<string, string>([
-  ['https://x.net/class/product-M0000438', 'M0000438'],
-  ['https://x.net/class/product-B0000033', 'B0000033']
-])
-
-test('그대로 같으면 그것이다', () => {
-  assert.equal(resolveByDeclaration('https://x.net/class/product-M0000438', DECLARED), 'M0000438')
-})
-
-test('관측이 선언을 확장한 경우 — 개체는 자기 클래스로 시작한다(부호를 모른다)', () => {
-  for (const sep of ['@', '#', '/', ':', '']) {
-    assert.equal(
-      resolveByDeclaration(`https://x.net/class/product-M0000438${sep}M2R0001`, DECLARED),
-      'M0000438',
-      `구분자 「${sep}」 에서도 같은 답이어야 한다`
-    )
-  }
-})
-
-test('화면이 짧게 줄인 경우 — 선언이 그것으로 끝난다', () => {
-  assert.equal(resolveByDeclaration('net/class/product-B0000033', DECLARED), 'B0000033')
-  assert.equal(resolveByDeclaration('product-M0000438', DECLARED), 'M0000438')
-})
-
-test('후보가 둘 이상이면 답하지 않는다 — 남의 레시피와 비교하지 않게', () => {
-  const ambiguous = new Map<string, string>([
-    ['https://a.net/class/product-1', 'A1'],
-    ['https://b.net/class/product-1', 'B1']
-  ])
-  assert.equal(resolveByDeclaration('class/product-1', ambiguous), undefined)
-})
-
-test('선언에 없으면 없는 것이다 — 비슷한 것을 이어 주지 않는다', () => {
-  assert.equal(resolveByDeclaration('https://x.net/class/product-ZZZ', DECLARED), undefined)
-  assert.equal(resolveByDeclaration(null, DECLARED), undefined)
-})

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

@@ -1,80 +0,0 @@
-/*
- * ★ 필터가 없을 때도 시각순으로 낸다 — 상한이 시간축의 임의 구간을 잘라내던 자리.
- *
- * ── 무엇이 났나 (2026-08-25 실측 · 승화푸드) ─────────────────────────────────
- * 공정 타임라인은 필터 없이 상한만 걸고 지난 기록을 부른다.
- *
- *   loadTwinEvents(id, { eventType: 'task.status', limit: TASK_CAP })
- *
- * 그 갈래의 정렬이 `revision DESC` 였다. `revision` 은 **적힌 순서**다. 연결된 시스템을 되읽는
- * 트윈에서는 적힌 순서와 일어난 순서가 다르다 — 커넥터가 연결된 시스템의 갱신 순서를 걷기 때문에,
- * 그쪽에서 나중에 손댄 행이 4월 사실을 담고 있으면 그 행이 큰 revision 을 받는다.
- *
- *   작업 축에 있는 가장 늦은 사실      2026-08-23 03:20
- *   revision 이 가장 큰 작업 사실      2026-04-15 10:49   ← 상한이 잡던 값
- *
- * 상한 안에 8월 두 달치가 들어오지 않았고, 화면은 4월 사실을 최근 것으로 그렸다. 사용자가 세 번
- * 짚었다. 화면이 낸 「앞부분이 빠져 있습니다」도 사실과 달랐다 — 빠진 것은 앞부분이 아니라 시간축의
- * 임의 구간이었다.
- *
- * ── 성능은 이유가 되지 않는다 ───────────────────────────────────────────────
- * 오히려 시각 정렬이 인덱스(`ix_twin_event_1`)를 순서대로 타서 빠르다. 같은 파일의 실측 기록:
- * `revision DESC` 200건 33.4초 · `eventTime DESC, revision DESC` 200건 0.007초.
- *
- * ── `revision` 순서를 없애지는 않는다 ───────────────────────────────────────────
- * 부르는 쪽이 `revision` 범위로 물었으면 그 순서가 물음의 답이다. 거르는 축과 정렬 축을 맞추는
- * 규칙과도 같다(`journal-sort-axis.test.ts`).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { journalOrder } from '../server/service/twin-journal/journal-order.js'
-
-test('★ 아무 필터도 없으면 시각순이다 — 타임라인이 부르는 방식이 이것이다', () => {
-  assert.deepEqual(journalOrder({}), { eventTime: 'DESC', revision: 'DESC' })
-  assert.deepEqual(journalOrder({ untilTime: null, fromRevision: null, toRevision: null }), {
-    eventTime: 'DESC',
-    revision: 'DESC'
-  })
-})
-
-test('★ 시각으로 물으면 시각순이다 — 거르는 축과 정렬 축이 맞아야 상한이 일한다', () => {
-  assert.deepEqual(journalOrder({ untilTime: '2026-08-25T00:00:00.000Z' }), { eventTime: 'DESC', revision: 'DESC' })
-})
-
-test('★ `revision` 범위로 물으면 그 순서로 낸다 — 그때는 그것이 물음의 답이다', () => {
-  assert.deepEqual(journalOrder({ fromRevision: 100, toRevision: 200 }), { revision: 'DESC' })
-  assert.deepEqual(journalOrder({ toRevision: 200 }), { revision: 'DESC' })
-  assert.deepEqual(journalOrder({ fromRevision: 100 }), { revision: 'DESC' })
-})
-
-test('시각과 `revision` 이 함께 오면 시각이 이긴다 — 거르는 쪽이 그렇게 정해져 있다', () => {
-  /*
-   * `where` 절이 `untilTime` 을 먼저 보고 `revision` 조건을 쓰지 않는다. 정렬만 `revision` 으로 두면 축이
-   * 어긋나고, 그 어긋남이 바로 위 실측의 33.4초다.
-   */
-  assert.deepEqual(journalOrder({ untilTime: '2026-08-25T00:00:00.000Z', fromRevision: 1, toRevision: 9 }), {
-    eventTime: 'DESC',
-    revision: 'DESC'
-  })
-})
-
-test('동시각의 순서는 `revision` 이 정한다 — 둘째 축을 없애지 않는다', () => {
-  /* 같은 시각에 여러 사실이 들어오는 것은 흔하다(한 번의 폴링이 여러 행을 낸다). 그때 순서가 없으면
-     화면이 새로 고칠 때마다 줄 순서가 바뀐다. */
-  for (const q of [{}, { untilTime: '2026-08-25T00:00:00.000Z' }]) {
-    assert.equal(journalOrder(q).revision, 'DESC')
-  }
-})
-
-test('구간으로 물으면 시각순이다 — 화면이 그리는 구간을 그대로 묻는 길', () => {
-  assert.deepEqual(journalOrder({ fromTime: '2026-08-22T00:00:00.000Z' }), { eventTime: 'DESC', revision: 'DESC' })
-  assert.deepEqual(
-    journalOrder({ fromTime: '2026-08-22T00:00:00.000Z', untilTime: '2026-08-23T00:00:00.000Z' }),
-    { eventTime: 'DESC', revision: 'DESC' }
-  )
-  /* 구간과 `revision` 범위가 함께 와도 시각이 이긴다 — 거르는 쪽이 그렇게 정해져 있다. */
-  assert.deepEqual(
-    journalOrder({ fromTime: '2026-08-22T00:00:00.000Z', fromRevision: 1, toRevision: 9 }),
-    { eventTime: 'DESC', revision: 'DESC' }
-  )
-})