@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/declaration-reaches-model.test.ts

@@ -1,226 +0,0 @@
-/*
- * 선언 적합성(경계 편) — **원본이 말한 사실은 모델까지 간다.**
- *
- * ── 왜 필요한가 ─────────────────────────────────────────────────────────────
- * 커널 쪽에는 같은 이름의 하네스가 있다(kernel/test/declaration-in-state: 선언 ⊆ 상태). 그런데 사실이
- * 새던 자리는 그 앞에도 있었다: **레퍼런스 마스터 → 커널 모델** 이라는 문 하나(`masterToTwin`).
- *
- * 여기서 새면 아무도 모른다. 원본은 말했고, 화면은 알리지 않고 id 를 보인다. 실제로 그렇게 잃었다 —
- * 자리의 이름(화면이 `cut-station` 을 찍었다), 사람의 이름, GS1 참조, 자원 속성, 시험 명세 참조,
- * 사람·설비의 시험 결과. 하루 사이에 여섯 번이고, 전부 **한 줄에서 필드 하나가 빠진** 것이었다.
- *
- * 타입 검사는 못 잡는다: 필드가 거의 다 선택(optional)이라 **안 옮기는 것이 합법**이다.
- *
- * ── 무엇을 검사하나 ─────────────────────────────────────────────────────────
- * `RefLocation`·`RefEquipment`·`RefPerson`·`RefAsset` 의 **모든 필드**가 셋 중 하나여야 한다:
- *
- *   1. 같은 이름으로 모델에 있다(대부분).
- *   2. `RENAMED` 에 적힌 다른 이름으로 모델에 있다(`homeLocationId → homeLocation`).
- *   3. `ELSEWHERE` 에 **다른 길이 무엇인지 적혀** 있다(좌표는 `layout` 으로, 역할은 분기에 쓰인다).
- *
- * 셋 중 어느 것도 아니면 실패한다 — 새 필드를 추가한 사람이 그때 분류해야 한다. 분류를 강제하는 것이
- * 이 검사의 전부다: 잊는 것이 기본값이면 잊는다.
- *
- * 필드 목록은 **소스에서 읽는다**(손으로 적지 않는다). 손으로 적으면 새 필드가 알리지 않고 빠지고, 그것이
- * 바로 이 검사가 막으려는 실패다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-
-/*
- * 주석을 먼저 걷어낸다 — **주석 속 예시가 필드로 세어졌다.**
- * 문서에 `effectivity: 'not-yet' | 'expired'` 라고 적어 둔 한 줄 때문에 없는 필드가 검사 대상에 들어왔다.
- * 검사가 없는 것을 요구하면 그 검사는 유지되지 않는다(사람이 예외를 늘려 입을 막는다).
- */
-const SOURCE = 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 fieldsOf(name: string): string[] {
-  const start = SOURCE.indexOf(`export interface ${name}`)
-  assert.ok(start >= 0, `선언 인터페이스를 못 찾았다: ${name} — 모양이 바뀌면 이 하네스도 따라가야 한다`)
-  const body = SOURCE.slice(SOURCE.indexOf('{', start))
-  const block = body.slice(0, body.indexOf('\n}') + 2)
-  const out: string[] = []
-  let depth = 0
-  let token = ''
-  for (const ch of block) {
-    if (ch === '{') { depth++; token = ''; continue }
-    if (ch === '}') { depth--; token = ''; continue }
-    if (depth === 1 && /[A-Za-z0-9_?]/.test(ch)) { token += ch; continue }
-    if (depth === 1 && ch === ':') { if (token) out.push(token.replace('?', '')); token = ''; continue }
-    token = ''
-  }
-  return out
-}
-
-/** 경계에서 이름이 바뀌는 필드 — 바뀌는 이유는 커널 어휘를 따르기 때문이다(호스트 어휘를 밀어넣지 않는다). */
-const RENAMED: Record<string, string> = { homeLocationId: 'homeLocation' }
-
-/**
- * **다른 길로 가는 사실** — 모델의 그 자원 줄에는 없지만 잃지도 않는다. 길을 여기 적는다.
- * 적지 않고 넘기면 "원래 안 가는 것" 과 "새는 것" 이 같아 보인다.
- */
-const ELSEWHERE: Record<string, string> = {
-  role: '자리인가 구역인가를 가르는 입력 — 모델의 locations 와 공간의 areas 로 갈라진다(값 자체는 나를 필요가 없다).',
-  footprint: '좌표는 `model.layout`(중심점)과 구역 기하로 간다 — 자리 줄에 실리는 값이 아니다.',
-  system: '이 렌즈의 자리인가 참조인가를 가르는 입력 — 다른 영역이면 `model.referencedLocations` 로 간다(ADR-0081 보탬, lens-own-places 시험).'
-}
-
-/** 모든 필드에 값을 실은 원본 — 값을 모르는 필드가 나오면 이 하네스는 실패한다(알리지 않고 건너뛰지 않는다). */
-const VALUE: Record<string, unknown> = {
-  id: '__ID__',
-  type: 'cut-station',
-  kind: 'welder',
-  name: '절단 스테이션',
-  description: '강판을 자르는 자리',
-  role: 'location',
-  /* 픽스처 원본의 렌즈와 같은 영역 — 이 자리는 자기 자리로 선다(다른 영역이면 참조로 간다). */
-  system: 'mes',
-  parentId: 'zone-a',
-  /* 전기 상류 — 공간 부모(`parentId`)와 다른 관계다. 값이 모델까지 가는지 이 하네스가 지킨다. */
-  upstreamId: 'incoming-1',
-  capacity: 40,
-  parallelism: 2,
-  level: 'WorkCenter',
-  footprint: { x: 1, y: 2, w: 3, h: 4 },
-  gs1Id: 'urn:epc:id:sgln:0614141.00001.0',
-  /* 설비의 정체성 — **GS1 키가 아닌 것이 정상이다**(실측: 인버터 하드웨어 식별자). */
-  identity: 'ES100000007d8d061d-1',
-  /* 설비 등급 소속 — 2026-09-04 에 이 칸이 접수면에 없어서 원본이 채운 등급 22대가 문턱에서
-     버려졌다(인티그레이션 레인 실측). 사람·자산은 받는데 설비만 없었다. */
-  equipmentClassIds: ['welding-robot'],
-  homeLocationId: 'cut-station',
-  mtbfMs: 600000,
-  mttrMs: 60000,
-  window: { startHour: 6, endHour: 22 },
-  workCalendar: [{ id: 'day', entryType: 'production', startTime: '06:00', endTime: '22:00' }],
-  properties: [{ id: 'speed', value: '1.2', uom: 'MTS' }],
-  testSpecificationIds: ['weld-cert'],
-  testResults: [{ specId: 'weld-cert', result: 'pass', expiresAt: '2099-01-01T00:00:00.000Z' }],
-  effectiveStart: '2020-01-01T00:00:00.000Z',
-  effectiveEnd: '2099-01-01T00:00:00.000Z',
-  personnelClassIds: ['welder-op'],
-  assetClassIds: ['euro-pallet']
-}
-
-interface Case {
-  /** 선언 인터페이스 이름 */
-  iface: string
-  /** 모델의 배열 이름 */
-  bucket: 'locations' | 'equipment' | 'persons' | 'assets'
-  id: string
-}
-
-const CASES: Case[] = [
-  { iface: 'RefLocation', bucket: 'locations', id: 'cut-station' },
-  { iface: 'RefEquipment', bucket: 'equipment', id: 'cutter-1' },
-  { iface: 'RefPerson', bucket: 'persons', id: 'cutter-op-1' },
-  { iface: 'RefAsset', bucket: 'assets', id: 'pallet-1' }
-]
-
-/** 그 인터페이스의 모든 필드에 값을 실은 항목. */
-function build(c: Case): any {
-  const o: any = {}
-  for (const f of fieldsOf(c.iface)) {
-    assert.ok(
-      f in VALUE,
-      `픽스처가 "${c.iface}.${f}" 에 실을 값을 모른다 — VALUE 에 하나 적어라.\n` +
-        '알리지 않고 건너뛰면 그 필드는 아무도 안 보는 필드가 되고, 그것이 이 하네스가 막으려는 실패다.'
-    )
-    o[f] = f === 'id' ? c.id : VALUE[f]
-  }
-  return o
-}
-
-function master(): any {
-  return {
-    source: 'decl-conformance',
-    system: 'mes' as const,
-    siteName: '선언 적합성 공장',
-    space: { spaceId: 'decl-site', width: 100, depth: 60, unit: 'm' },
-    locations: [build(CASES[0])],
-    equipment: [build(CASES[1])],
-    persons: [build(CASES[2])],
-    assets: [build(CASES[3])]
-  }
-}
-
-test('검사할 필드가 비어 있지 않다 — 비면 이 하네스는 아무것도 지키지 않는다', () => {
-  for (const c of CASES) assert.ok(fieldsOf(c.iface).length > 2, `${c.iface}: 필드를 못 읽었다(파서가 낡았다)`)
-})
-
-for (const c of CASES) {
-  test(`${c.iface} 의 사실이 하나도 잃지 않고 모델까지 간다`, () => {
-    const src = build(c)
-    const { model } = masterToTwin(master())
-    const bucket = (model as any)[c.bucket]
-    assert.ok(Array.isArray(bucket), `모델에 ${c.bucket} 이 없다`)
-    const got = bucket.find((x: any) => x?.id === c.id)
-    assert.ok(got, `선언한 ${c.iface} "${c.id}" 이 모델에 없다 — 사실 하나가 아니라 개체가 사라졌다`)
-
-    const lost: string[] = []
-    const mangled: string[] = []
-    for (const f of Object.keys(src)) {
-      if (f in ELSEWHERE) continue
-      const key = RENAMED[f] ?? f
-      if (got[key] === undefined) { lost.push(f); continue }
-      try {
-        assert.deepEqual(got[key], src[f])
-      } catch {
-        mangled.push(`${f}→${key}`)
-      }
-    }
-    assert.deepEqual(
-      { lost, mangled },
-      { lost: [], mangled: [] },
-      `${c.iface}: 잃은 사실=[${lost}] · 옮기다 값이 바뀐 사실=[${mangled}]\n` +
-        '원본이 말한 것을 문에서 버리면 아무도 모른다 — 화면은 알리지 않고 id 를 보인다.\n' +
-        '일부러 다른 길로 보내는 것이면 ELSEWHERE 에 그 길을 적어라(이름만 바뀌는 것은 RENAMED).'
-    )
-  })
-}
-
-/*
- * ── 공간의 시각 기준도 모델까지 간다 (2026-09-07) ────────────────────────────
- *
- * 위 검사는 **자원**의 필드만 본다. `space` 는 안 보고 있었고, 그래서 실제로 하나가 새고 있었다 —
- * `space.timezone` 이 오프셋으로만 풀려 모델에 실리고 **이름은 버려졌다.**
- *
- * 이름이 없으면 소비처가 순간마다 다시 풀 수 없다. 지난 구간을 교대별로 접을 때 그 구간 안의
- * 일광절약시간 전환이 사실을 한 시간 밀어 **다른 교대로** 세게 하고, 오류는 나지 않는다.
- * `America/Tijuana`(PST −480 / PDT −480 아닌 −420)가 이미 자료에 있다.
- *
- * 그리고 이 새는 자리를 잡은 것은 타입 검사도, 위 하네스도 아니라 **다른 레인의 물음**이었다
- * ("자료를 채운 뒤 이미 세워진 모델이 따라가나"). 그래서 여기 검사로 남긴다.
- */
-const withSpace = (space: Record<string, unknown>) => masterToTwin({ ...master(), space: { ...master().space, ...space } })
-
-test('공간의 시간대 이름이 모델까지 간다 — 오프셋만 실으면 계절이 바뀔 때 틀린다', () => {
-  const { model } = withSpace({ timezone: 'America/Tijuana' })
-
-  assert.equal((model as any).timezone, 'America/Tijuana', '이름이 모델에 없다 — 소비처가 순간마다 풀 수 없다')
-  assert.equal(typeof (model as any).utcOffsetMinutes, 'number', '오프셋도 함께 실려야 한다 — 이름을 안 보는 소비처가 그 값으로 돈다')
-})
-
-test('시간대를 선언하지 않으면 두 칸 다 만들지 않는다 — 0 은 「UTC 라고 선언했다」는 주장이다', () => {
-  const { model } = withSpace({})
-
-  assert.equal((model as any).timezone, undefined)
-  assert.equal((model as any).utcOffsetMinutes, undefined)
-})
-
-test('풀리지 않는 이름은 싣지 않고 경고로 말한다 — 실어 두면 소비처가 믿고 매번 실패한다', () => {
-  const { model, warnings } = withSpace({ timezone: 'Mars/Olympus_Mons' })
-
-  assert.equal((model as any).timezone, undefined)
-  assert.equal((model as any).utcOffsetMinutes, undefined)
-  assert.ok(
-    (warnings ?? []).some((w: any) => JSON.stringify(w).includes('Mars/Olympus_Mons')),
-    '모르는 시간대를 조용히 버리지 않는다'
-  )
-})

package/test/declared-location-types.test.ts

@@ -1,89 +0,0 @@
-/*
- * ★ 자리 타입을 **누구에게 묻는가** — 원본이 선언했으면 그 선언이 정본이다.
- *
- * ── 무엇이 틀렸나 (2026-08-20) ──────────────────────────────────────────────
- * 호스트는 「이 자리 타입을 아는가」를 **내장 카탈로그**에게만 물었다(`DOMAIN_CATALOG[system]`).
- * 그런데 원본은 자기 `DomainDefinition.locationTypes` 를 함께 보낼 수 있고, 그러면 **그 선언이
- * 정본**이다 — 카탈로그는 우리가 아는 도메인들의 기본 어휘일 뿐이다.
- *
- * 상대가 틀렸으니 결과가 이랬다: 자기 어휘를 선언한 원본(예: F&B 라인 — 배합·가열·세척·금속검출·
- * 소분·포장)은 **정상적인 자리마다 경고를 하나씩** 받는다. 경고가 소음이 되면 사람은 그것을 읽지 않게
- * 되고, 그때 **진짜 경고도 함께 죽는다.**
- *
- * ── 지키는 것 ───────────────────────────────────────────────────────────────
- * ① 선언이 있으면 선언에 대조한다 ② 선언이 없으면 카탈로그로 떨어진다 ③ 선언을 **못 읽은 것**과
- * 「아무것도 선언하지 않은 것」을 가른다(못 읽었으면 카탈로그로 떨어진다 — 빈 목록으로 읽으면 모든
- * 자리가 경고를 받는다) ④ 아무 데도 없는 타입은 여전히 경고한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-
-const req = createRequire(import.meta.url)
-const { masterToTwin, declaredLocationTypes } = req('../dist-server/service/reference/reference-master.js')
-
-/** F&B 라인 — 내장 MES 카탈로그(트레일러 제조)에는 없는 어휘. */
-const FNB = ['mixing', 'cooking', 'washing', 'metal-detect', 'portioning', 'packing']
-
-const CATALOG = { mes: { locationTypes: ['raw-store', 'cut-station', 'fg-store'] } }
-
-const master = (types: string[], productionSpec?: unknown) => ({
-  source: 'chef-1',
-  system: 'mes',
-  siteName: '식품 공장',
-  /* `masterToTwin` 이 공간에서 spaceId 를 꺼낸다 — 최소 모양을 준다. */
-  space: { spaceId: 'chef-site', width: 60, depth: 30, unit: 'm' },
-  locations: types.map((t, i) => ({ id: `loc-${i}`, type: t, role: 'location' as const })),
-  equipment: [],
-  ...(productionSpec ? { productionSpec } : {})
-})
-
-const specWith = (keys: string[]) => ({ definition: { locationTypes: keys.map(k => ({ key: k, label: k })) } })
-
-const unknownWarnings = (r: any) => (r.warnings ?? []).filter((w: any) => w.code === 'unknown-location-type')
-
-test('원본이 선언했으면 그 선언에 대조한다 — 정상적인 자리에 경고를 주지 않는다', () => {
-  const r = masterToTwin(master(FNB, specWith(FNB)), CATALOG)
-
-  assert.deepEqual(unknownWarnings(r), [], 'F&B 여섯 자리 모두 선언돼 있다')
-})
-
-test('선언이 없으면 카탈로그로 떨어진다 — 예전 거동 그대로', () => {
-  const r = masterToTwin(master(['raw-store', 'mixing']), CATALOG)
-  const w = unknownWarnings(r)
-
-  assert.equal(w.length, 1, '카탈로그에 없는 하나만')
-  assert.equal(w[0].params.type, 'mixing')
-})
-
-test('선언에도 카탈로그에도 없으면 경고한다 — 진짜 경고는 죽이지 않는다', () => {
-  const r = masterToTwin(master([...FNB, 'ghost-station'], specWith(FNB)), CATALOG)
-  const w = unknownWarnings(r)
-
-  assert.equal(w.length, 1)
-  assert.equal(w[0].params.type, 'ghost-station')
-})
-
-test('선언을 못 읽으면 카탈로그로 떨어진다 — 빈 목록으로 읽지 않는다', () => {
-  /*
-   * 「없는 것」과 「못 읽은 것」은 다르다. 못 읽은 것을 빈 목록으로 읽으면 **모든 자리가 경고**를 받고,
-   * 그것이 바로 이 시험이 막으려는 소음이다.
-   */
-  for (const broken of [{}, { definition: {} }, { definition: { locationTypes: [] } }, { definition: { locationTypes: 'nope' } }]) {
-    assert.equal(declaredLocationTypes(broken), undefined, `못 읽은 모양: ${JSON.stringify(broken)}`)
-  }
-
-  const r = masterToTwin(master(['raw-store', 'mixing'], { definition: { locationTypes: [] } }), CATALOG)
-  assert.equal(unknownWarnings(r).length, 1, '카탈로그 기준으로 하나만 경고한다')
-})
-
-test('선언 목록의 모양을 너그럽게 읽는다 — 문자열 목록도 받는다', () => {
-  assert.deepEqual(declaredLocationTypes({ definition: { locationTypes: ['mixing', 'packing'] } }), ['mixing', 'packing'])
-  assert.deepEqual(declaredLocationTypes({ definition: { locationTypes: [{ key: 'mixing' }, { nope: 1 }] } }), ['mixing'])
-})
-
-test('카탈로그도 선언도 없으면 아무 경고도 하지 않는다 — 모르는 것을 문제로 만들지 않는다', () => {
-  const r = masterToTwin(master(FNB), undefined)
-
-  assert.deepEqual(unknownWarnings(r), [], '견줄 상대가 없으면 판단하지 않는다')
-})

package/test/declared-stimulus.test.ts

@@ -1,88 +0,0 @@
-/*
- * 자극은 **원본이 선언한다** — 그리고 재기동에도 살아 있다.
- *
- * ── 무엇이 났나 (2026-08-19) ────────────────────────────────────────────────
- * 데모의 시나리오는 시드 코드가 **메모리에만** 실었다(`runtime.scenario.load`). 그래서 트윈을 재기동하면
- * 자극이 사라지고 구조만 서 있는 트윈이 남았다 — 작업 0·오더 0. 「살아 있는 데모」가 첫 재기동까지만
- * 살았고, 오늘 서버를 여러 번 띄우는 동안 데모 트윈들이 실제로 그 상태였다.
- *
- * ── 집을 트윈이 아니라 원본으로 (ADR-0029 · plans/simulator-as-source.md §4) ─
- * 무엇이 들어오고 무슨 주문이 나는지는 **시뮬레이터(원본)가 정하는 사실**이고 트윈은 반영한다. 트윈에
- * 축을 만들면 ADR-0029 가 나중에 걷어내야 하고, 원본(`TwinReference.connectionConfig`)에 두면 그 계획의
- * 첫 조각(`openLiveFeed`)이 같은 선언을 그대로 읽는다.
- *
- * 이 시험이 지키는 것:
- *  ① 선언이 없으면 알리지 않고 지난다(정적 구조만 반영하는 트윈이 정상이다).
- *  ② **미러에는 싣지 않는다** — 외부 실물이 진실인 트윈에 도착을 지어 주면 그것은 현실이 아니다.
- *  ③ 검사를 통과하지 못한 선언은 **태우지 않고** 이유를 남긴다(잘못된 선언 하나가 서버를 내린 이력이 있다).
- *  ④ 검사기가 없으면 싣지 않는다 — 검사할 수 없는 선언을 태우는 것이 가장 비싼 선택이다.
- *  ⑤ 선언을 얹을 때 **옆 설정을 지우지 않는다**(접속 정보가 같은 자리에 산다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { planStimulus, withStimulus } from '../server/engine/declared-stimulus.ts'
-
-const scenario = { seed: 1, generators: [{ kind: 'inbound-arrival', rate: { distribution: 'constant', meanPerHour: 60 }, content: {} }] }
-const ok = () => ({ ok: true as const })
-const bad = () => ({ ok: false as const, errorCode: 'scenario-sku-mix-required' })
-const sim = { hasScenarioEngine: true, mode: 'sim' as const }
-
-test('선언이 없으면 알리지 않고 지난다 — 구조만 반영하는 트윈이 정상이다', () => {
-  assert.deepEqual(planStimulus(undefined, sim, ok), { action: 'skip', reason: 'none' })
-  assert.deepEqual(planStimulus({ endpoint: 'x' }, sim, ok), { action: 'skip', reason: 'none' })
-  /* 시나리오 자리에 객체가 아닌 것이 오면 선언이 아니다(문자열을 시나리오로 읽지 않는다). */
-  assert.deepEqual(planStimulus({ scenario: 'daily' }, sim, ok), { action: 'skip', reason: 'none' })
-})
-
-test('관측으로 도는 트윈에는 싣지 않는다 — 현실을 지어내지 않는다', () => {
-  const plan = planStimulus({ scenario }, { hasScenarioEngine: true, mode: 'live' }, ok)
-  assert.deepEqual(plan, { action: 'skip', reason: 'observed' })
-})
-
-test('시나리오 엔진이 없으면 싣지 않는다 — 알리지 않고 아무 일도 없게 두지 않는다', () => {
-  const plan = planStimulus({ scenario }, { hasScenarioEngine: false, mode: 'sim' }, ok)
-  assert.deepEqual(plan, { action: 'skip', reason: 'no-engine' })
-})
-
-test('검사를 통과하지 못한 선언은 태우지 않는다 — 사유를 든다', () => {
-  const plan = planStimulus({ scenario }, sim, bad)
-  assert.deepEqual(plan, { action: 'skip', reason: 'invalid', detail: 'scenario-sku-mix-required' })
-})
-
-test('검사기가 없으면 싣지 않는다 — 검사할 수 없는 선언이 가장 위험하다', () => {
-  const plan = planStimulus({ scenario }, sim, undefined)
-  assert.equal(plan.action, 'skip')
-  assert.equal((plan as any).reason, 'invalid')
-})
-
-test('통과한 선언은 그대로 싣는다 — 값을 손대지 않는다', () => {
-  const plan = planStimulus({ scenario }, sim, ok)
-  assert.deepEqual(plan, { action: 'load', scenario })
-})
-
-test('선언을 얹으면서 접속 정보를 지우지 않는다', () => {
-  const merged = withStimulus({ endpoint: 'https://sim', token: 't' }, scenario)
-  assert.deepEqual(merged, { endpoint: 'https://sim', token: 't', scenario })
-  /* 설정이 없던 원본에도 얹힌다(빈 객체에서 시작). */
-  assert.deepEqual(withStimulus(undefined, scenario), { scenario })
-})
-
-/*
- * ── 배선 (소스로 지킨다) ────────────────────────────────────────────────────
- * 판정은 순수 함수가 하지만, 그것을 **기동 때 부르지 않으면** 아무 일도 일어나지 않는다. 그리고 못 실은
- * 이유는 말해야 한다 — 「선언했는데 안 실렸다」를 말하지 않으면 사용자는 트윈이 고장 난 줄로 읽는다.
- */
-test('두 기동 경로에서 부른다 — 시뮬은 싣고, 미러는 그 사실을 말한다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const calls = src.match(/this\.installStimulus\(domainId, id, inst\)/g) ?? []
-  assert.equal(calls.length, 2, `기동 경로 둘에서 불러야 한다(발견 ${calls.length})`)
-  assert.match(src, /planStimulus\(config, \{ hasScenarioEngine/, '판정은 순수 함수에 맡긴다')
-  assert.match(src, /validateScenario/, '커널 검사기를 그대로 쓴다(규칙을 두 벌로 만들지 않는다)')
-  assert.match(src, /a stimulus is declared on its source but was not loaded/, '못 실은 이유를 말한다')
-  /* 선언을 적는 문도 있어야 한다 — 읽기만 있으면 아무도 선언할 수 없다. */
-  assert.match(src, /static async declareStimulus/)
-  assert.match(src, /no source reference — a stimulus has nowhere to be declared/, '원본이 없으면 지어 만들지 않는다')
-})

package/test/dedupe-transformation.test.ts

@@ -1,112 +0,0 @@
-/*
- * 변환·담김의 정체가 **무엇이 무엇으로 되었나**로 갈리나.
- *
- * ── 왜 필요한가 (2026-09-07) ────────────────────────────────────────────────
- * 이 자리가 없어서 **사실 하나가 없어졌습니다.** 거절이 아니라 되풀이로 세어져서 경고도 없었습니다.
- *
- * ```
- * plant outbox seq 37   in LOT-CT-SIDE-001 24개  →  out LOT-CT-MAIN-003 12개
- * plant outbox seq 42   in LOT-CT-SIDE-001 18개  →  out LOT-CT-MAIN-004  9개
- *                       transformationID · bizStep · 초까지 전부 같다
- * 저널에 남은 것        LOT-CT-MAIN-003 하나
- * ```
- *
- * `LOT-CT-MAIN-004` 를 어느 패널로 만들었는지 트윈이 답하지 못했습니다. 인티그레이션 레인이
- * 원본과 저널의 건수를 맞춰 보다 찾았습니다 — 4건이 나갔고 3건이 앉았습니다.
- *
- * 아래 값은 그 두 봉투에서 온 것입니다. 지어낸 모양이 아닙니다.
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { factIdentity } from '../server/engine/ingest-dedupe.js'
-
-const AT = '2026-09-05T05:00:00.000Z'
-
-const transformation = (inQty: number, outClass: string, outQty: number) => ({
-  eventId: `evt-${outClass}-${outQty}`,
-  eventType: 'epcis.TransformationEvent',
-  eventTime: AT,
-  data: {
-    type: 'TransformationEvent',
-    bizStep: 'urn:epcglobal:cbv:bizstep:commissioning',
-    transformationID: 'WO-20260831-001',
-    inputQuantityList: [{ epcClass: 'LOT-CT-SIDE-001', quantity: inQty }],
-    outputQuantityList: [{ epcClass: outClass, quantity: outQty }]
-  }
-})
-
-test('산출 로트가 다르면 다른 사실이다 — 이것이 실제로 없어진 자리다', () => {
-  const a = factIdentity(transformation(24, 'LOT-CT-MAIN-003', 12))
-  const b = factIdentity(transformation(18, 'LOT-CT-MAIN-004', 9))
-
-  assert.ok(a, '정체를 만들지 못하면 dedupe 밖이다')
-  assert.notEqual(a, b, '같은 오더·같은 공정·같은 초라도 산출이 다르면 다른 변환이다')
-})
-
-test('똑같은 봉투가 두 번 오면 한 사실이다 — 갈라 놓기만 하면 되풀이를 못 막는다', () => {
-  assert.equal(
-    factIdentity(transformation(24, 'LOT-CT-MAIN-003', 12)),
-    factIdentity(transformation(24, 'LOT-CT-MAIN-003', 12))
-  )
-})
-
-test('산출 이름이 같고 수량만 다르면 다른 사실이다 — 분할이 그 모양이다', () => {
-  const a = factIdentity(transformation(24, 'LOT-CT-MAIN-003', 12))
-  const b = factIdentity(transformation(24, 'LOT-CT-MAIN-003', 6))
-
-  assert.notEqual(a, b)
-})
-
-test('입력 수량만 다르면 다른 사실이다 — 산출이 같아도 소비가 다르다', () => {
-  const a = factIdentity(transformation(24, 'LOT-CT-MAIN-003', 12))
-  const b = factIdentity(transformation(18, 'LOT-CT-MAIN-003', 12))
-
-  assert.notEqual(a, b)
-})
-
-test('오더가 다르면 다른 사실이다 — 같은 공정을 두 오더로 같은 초에 돌릴 수 있다', () => {
-  const withTx = (tx: string) => {
-    const e = transformation(24, 'LOT-CT-MAIN-003', 12) as any
-    e.data.bizTransactionList = [{ type: 'urn:epcglobal:cbv:btt:prodorder', bizTransaction: tx }]
-    return factIdentity(e)
-  }
-
-  assert.notEqual(withTx('urn:x:bt:WO-A'), withTx('urn:x:bt:WO-B'))
-})
-
-test('담김의 자식이 다르면 다른 사실이다 — 한 종류만 고치면 나머지에 같은 결함이 남는다', () => {
-  const aggregation = (child: string) => ({
-    eventId: `agg-${child}`,
-    eventType: 'epcis.AggregationEvent',
-    eventTime: AT,
-    data: {
-      type: 'AggregationEvent',
-      action: 'ADD',
-      bizStep: 'urn:epcglobal:cbv:bizstep:packing',
-      parentID: 'urn:epc:id:sscc:0614141.1234567890',
-      childQuantityList: [{ epcClass: child, quantity: 10 }]
-    }
-  })
-
-  assert.notEqual(factIdentity(aggregation('LOT-A')), factIdentity(aggregation('LOT-B')))
-})
-
-test('수량 목록 전체를 본다 — 첫 원소만 보면 뒤가 다른 둘이 뭉친다', () => {
-  const twoLines = (second: string) => ({
-    eventId: `evt-${second}`,
-    eventType: 'epcis.TransformationEvent',
-    eventTime: AT,
-    data: {
-      type: 'TransformationEvent',
-      bizStep: 'urn:epcglobal:cbv:bizstep:commissioning',
-      transformationID: 'WO-20260831-001',
-      outputQuantityList: [
-        { epcClass: 'LOT-SAME', quantity: 1 },
-        { epcClass: second, quantity: 1 }
-      ]
-    }
-  })
-
-  assert.notEqual(factIdentity(twoLines('LOT-X')), factIdentity(twoLines('LOT-Y')))
-})

package/test/discovery-result.test.ts

@@ -1,75 +0,0 @@
-/*
- * 사이트 발견 결과 — **"못 찾았다" 를 "없다" 로 말하지 않게.**
- *
- * 실 시스템을 연결해 트윈을 만드는 경로에서, 발견이 실패하면 화면이 "사이트를 찾지 못했습니다" 라고만
- * 말했다. 레퍼런스 미등록·어댑터 미상·조회 실패·정말 0건이 그 한 문장에 섞여 있었다 — 자격이
- * 틀렸는지 주소가 틀렸는지 알 수 없었다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  discovered, failed, detailOf,
-  referenceNotFound, adapterUnknown, discoveryFailed, discoveryTimedOut
-} from '../server/service/reference/discovery-result.ts'
-
-test('사이트가 없는 것은 실패가 아니다 — 사유 없는 빈 목록이 "없다" 를 뜻한다', () => {
-  /* 권한이 좁거나 아직 등록되지 않아 공장이 하나도 없는 시스템은 있을 수 있다. 그것은 사실이므로
-     실패로 뭉개면 사용자가 있지도 않은 문제를 찾는다. */
-  const r = discovered([])
-  assert.deepEqual(r, { sites: [] })
-  assert.equal(r.error, undefined, '사유가 없다 = 성공')
-})
-
-test('찾은 것을 그대로 돌려주되 입력을 붙들지 않는다', () => {
-  const src = [{ siteId: 'PL1' }, { siteId: 'PL2' }]
-  const r = discovered(src)
-  assert.deepEqual(r.sites, src)
-  src.push({ siteId: 'PL3' })
-  assert.equal(r.sites.length, 2, '나중에 바뀐 원본이 결과를 바꾸지 않는다')
-})
-
-test('없는 목록·null 도 견딘다', () => {
-  assert.deepEqual(discovered(null), { sites: [] })
-  assert.deepEqual(discovered(undefined), { sites: [] })
-})
-
-test('실패는 사유와 함께, 사이트는 비워서 — 반쪽 목록을 성공처럼 보이지 않게', () => {
-  const r = failed(referenceNotFound('sap-ewm-1710'))
-  assert.deepEqual(r.sites, [])
-  assert.equal(r.error?.code, 'reference-not-found')
-  assert.equal(r.error?.params?.source, 'sap-ewm-1710')
-  assert.match(r.error!.message, /not registered/, '영어 canonical 문장이 로그·폴백으로 남는다')
-})
-
-test('네 가지 사유가 서로 구별된다 — 이것이 이 작업의 요점이다', () => {
-  const codes = [
-    referenceNotFound('s').code,
-    adapterUnknown('sap-ewm', 's').code,
-    discoveryFailed('s', '401 Unauthorized').code,
-    discoveryTimedOut('s', 15).code
-  ]
-  assert.deepEqual(codes, ['reference-not-found', 'adapter-unknown', 'discovery-failed', 'discovery-timeout'])
-  assert.equal(new Set(codes).size, 4, '넷이 한 코드로 합쳐지지 않는다')
-})
-
-test('원 시스템이 준 사유를 감추지 않는다 — 사용자가 관리자에게 물어볼 수 있게', () => {
-  const e = discoveryFailed('sap-ewm-1710', '401 Unauthorized')
-  assert.equal(e.params?.detail, '401 Unauthorized')
-  assert.match(e.message, /401 Unauthorized/)
-})
-
-test('타임아웃은 초 단위로 알린다 — 얼마를 기다렸는지 알 수 있게', () => {
-  const e = discoveryTimedOut('s', 15)
-  assert.equal(e.params?.seconds, 15)
-  assert.match(e.message, /15s/)
-})
-
-test('어댑터가 낸 오류에서 사유를 뽑는다 — 형태를 가정하지 않는다', () => {
-  assert.equal(detailOf(new Error('ECONNREFUSED')), 'ECONNREFUSED')
-  assert.equal(detailOf('404 Not Found'), '404 Not Found')
-  /* 무엇이 왔는지 모르면 그렇게 말한다 — 빈 문장으로 "이유 없음" 처럼 보이게 하지 않는다. */
-  for (const weird of [undefined, null, {}, 0, new Error('')]) {
-    assert.match(detailOf(weird), /without a message/, `이상한 입력: ${JSON.stringify(weird)}`)
-  }
-})