@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/model-vocabulary.test.ts

@@ -1,114 +0,0 @@
-/*
- * 저장된 모델의 어휘 세대 흡수 — **빈 공장으로 읽히지 않게.**
- *
- * ── 계기 (2026-08-06, 사용자 신고) ───────────────────────────────────────────
- * 모델러의 엔티티 목록이 통째로 비어 있었다. **오류는 없었다.** 저장된 모델가 옛 어휘(`nodes`/`movers`)
- * 인데 화면과 호스트가 새 어휘를 읽었기 때문이다. 같은 원인이 구조 서명(`N[]M[]` — 서로 다른 두 공장이
- * 같아 보인다)·주행 추정기·설비 동기까지 알리지 않고 망가뜨리고 있었다.
- *
- * 그래서 **DB에서 읽는 순간** 한 번 정규화한다. 이 테스트가 지키는 것은 그 정규화가 ① 세 세대를 다
- * 흡수하고 ② 나머지 속성을 하나도 잃지 않고 ③ 새 모델에는 아무 일도 하지 않는 것이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { readFileSync } from 'node:fs'
-
-import { modelColumnTransformer, canonicalModel } from '../server/engine/model-vocabulary.ts'
-
-const LOC = [{ id: 'dock', type: 'dock', capacity: 10 }]
-const EQ = [{ id: 'fk-1', kind: 'forklift', homeLocation: 'dock' }]
-
-test('가장 오래된 세대(nodes·movers)를 흡수한다 — 사용자가 본 증상의 원인', () => {
-  const out = canonicalModel({ nodes: LOC, movers: EQ, spaceId: 'site-1' })
-
-  assert.deepEqual(out.locations, LOC)
-  assert.deepEqual(out.equipment, EQ)
-})
-
-test('중간 세대(equipmentList)도 흡수한다 — 세 세대가 저장돼 있다', () => {
-  const out = canonicalModel({ nodes: LOC, equipmentList: EQ })
-
-  assert.deepEqual(out.equipment, EQ)
-})
-
-test('옛 키를 **내보내지 않는다** — 소비처가 두 어휘를 다시 보지 않게', () => {
-  const out: any = canonicalModel({ nodes: LOC, movers: EQ, equipmentList: [] })
-
-  for (const k of ['nodes', 'movers', 'equipmentList']) assert.equal(k in out, false, `${k} 가 남았다`)
-})
-
-test('나머지 속성을 하나도 잃지 않는다 — 곁가지로 보이는 값이 전제다', () => {
-  /* 이 도메인에서 사소한 속성은 없다: 좌표·시각기준·명세는 소요시간·교대·생산의 전제다. */
-  const model = {
-    nodes: LOC,
-    movers: EQ,
-    spaceId: 'site-1',
-    areaId: 'zone-a',
-    layout: { dock: { x: 1, y: 2 } },
-    utcOffsetMinutes: 540,
-    unit: 'm',
-    productionSpec: { definition: { operations: [] } },
-    operations: [{ id: 'op-1' }]
-  }
-  const out: any = canonicalModel(model)
-
-  for (const k of ['spaceId', 'areaId', 'layout', 'utcOffsetMinutes', 'unit', 'productionSpec', 'operations']) {
-    assert.deepEqual(out[k], (model as any)[k], `${k} 가 사라졌다`)
-  }
-})
-
-test('새 어휘 모델에는 아무 일도 하지 않는다 — 멱등', () => {
-  const model = { locations: LOC, equipment: EQ, spaceId: 'site-1' }
-
-  const once: any = canonicalModel(model)
-  const twice: any = canonicalModel(once)
-
-  assert.deepEqual(once, model)
-  assert.deepEqual(twice, once)
-})
-
-test('컬렉션이 없으면 빈 배열이 된다 — 소비처가 `?? []` 를 다시 적지 않게', () => {
-  const out = canonicalModel({ spaceId: 'site-1' })
-
-  assert.deepEqual(out.locations, [])
-  assert.deepEqual(out.equipment, [])
-})
-
-test('모델이 아닌 것은 그대로 통과시킨다 — 모양을 짐작해 고치지 않는다', () => {
-  for (const v of [null, undefined, 0, '', 'board', [1, 2]]) {
-    assert.deepEqual(canonicalModel(v as any), v as any, JSON.stringify(v))
-  }
-})
-
-test('변환기는 **읽을 때만** 정규화한다 — 쓰기는 준 그대로', () => {
-  const old = { nodes: LOC, movers: EQ }
-
-  assert.deepEqual(modelColumnTransformer.from(old).equipment, EQ)
-  /* 쓰기를 손대면 "저장된 것" 과 "준 것" 이 달라져 추적이 어려워진다. 읽기가 정규화되므로 다음 저장에서
-     자연히 새 어휘가 된다. */
-  assert.equal(modelColumnTransformer.to(old), old)
-})
-
-test('두 옛 모델이 구조적으로 구별된다 — 서명이 빈 문자열로 축약되지 않는다', () => {
-  /* 정규화 전에는 둘 다 `locations: undefined` 라 서명이 `N[]M[]` 로 같았다(변경 감지가 죽는다). */
-  const a = canonicalModel({ nodes: [{ id: 'a', type: 'dock', capacity: 1 }], movers: [] })
-  const b = canonicalModel({ nodes: [{ id: 'b', type: 'storage', capacity: 9 }], movers: [] })
-
-  assert.notDeepEqual(a.locations, b.locations)
-  assert.equal(a.locations.length, 1)
-  assert.equal(b.locations.length, 1)
-})
-
-test('보드를 저장하는 엔티티가 **변환기를 달고 있다** — 결선이 빠지면 순수 모듈은 그린인데 화면은 빈다', () => {
-  /* 이 결함이 정확히 그랬다: 리더는 커널에 있었고 목록만 그것을 거쳤다. 결선은 알리지 않고 빠질 수 있으므로
-     기계가 지킨다. 새 엔티티가 보드를 담게 되면 여기 함께 올린다. */
-  const owners = ['server/service/twin-instance/twin-instance.ts', 'server/service/twin-structure/twin-structure.ts']
-
-  for (const rel of owners) {
-    const src = readFileSync(new URL('../' + rel, import.meta.url).pathname, 'utf-8')
-    const boardColumn = src.split('\n').find(l => l.includes('@Column') && l.includes('transformer'))
-    assert.ok(boardColumn, `${rel}: model 컬럼에 transformer 가 없다`)
-    assert.match(boardColumn as string, /modelColumnTransformer/, `${rel}: 다른 변환기가 달려 있다`)
-  }
-})

package/test/move-space.test.ts

@@ -1,149 +0,0 @@
-/*
- * 기존 트윈을 다른 현장으로 가져오기 — 판정이 잃을 것을 말하는지 본다.
- *
- * 엔진 본체는 DB 를 물고 있어 단위테스트로 부를 수 없다. 그래서 **결정만** 순수 모듈로 떼어 놓고
- * 여기서 본다(엔진은 사실을 조회해 넘기는 일만 한다 — `ingest-space` 와 같은 구조).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { judgeMoveTwinSpace, judgeDetachTwinSpace } from '../server/service/twin-space/move-space.ts'
-
-/** 잃을 것이 없는 가장 단순한 이전 — 같은 시간대, 구역 참조 없음, 옛 표현 없음. */
-const CLEAN = {
-  instanceId: 'wms-a',
-  fromSpaceId: 'wms-a-site',
-  toSpaceId: 'rosarito-site',
-  toSpaceExists: true,
-  fromTimezone: 'America/Los_Angeles',
-  toTimezone: 'America/Los_Angeles'
-}
-
-test('잃을 것이 없으면 경고도 없다 — 정상 경로를 시끄럽게 만들지 않는다', () => {
-  const j = judgeMoveTwinSpace(CLEAN)
-  assert.equal(j.refusal, undefined)
-  assert.deepEqual(j.warnings, [])
-})
-
-test('없는 현장으로는 옮기지 않는다 — 알리지 않고 새 공간을 만들지 않는다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, toSpaceExists: false })
-  assert.equal(j.refusal?.code, 'space-not-found')
-  assert.equal(j.refusal?.params?.spaceId, 'rosarito-site')
-})
-
-test('같은 현장으로 옮기는 것은 거절한다 — 할 일이 없는데 쓴 것처럼 답하지 않는다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, toSpaceId: 'wms-a-site' })
-  assert.equal(j.refusal?.code, 'same-space')
-})
-
-test('없는 트윈은 거절한다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, instanceId: undefined })
-  assert.equal(j.refusal?.code, 'twin-not-found')
-})
-
-test('벤치 사본은 옮기지 않는다 — 무엇의 측정인지 말할 수 없게 된다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, purpose: 'bench' })
-  assert.equal(j.refusal?.code, 'bench-copy')
-})
-
-test('현장이 없던 트윈도 옮길 수 있다 — 옛 트윈을 고칠 길을 막지 않는다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, fromSpaceId: undefined, fromTimezone: undefined, toTimezone: undefined })
-  assert.equal(j.refusal, undefined)
-})
-
-test('새 공간에 없는 구역을 가리키는 로케이션은 소속이 끊긴다고 말한다', () => {
-  const j = judgeMoveTwinSpace({
-    ...CLEAN,
-    areaRefs: ['bldg-1', 'floor-2', undefined, 'bldg-1', ''],
-    toAreaIds: ['floor-2']
-  })
-  const w = j.warnings.find(x => x.code === 'areas-left-behind')
-  assert.ok(w, '끊기는 소속을 말해야 한다')
-  assert.equal(w.params?.count, 1, '중복·빈 값은 세지 않는다')
-  assert.equal(w.params?.areas, 'bldg-1')
-  assert.equal(j.refusal, undefined, '막지는 않는다 — 새 공간에서 구역을 다시 그리는 것이 정상이다')
-})
-
-test('구역이 모두 새 공간에 있으면 그 경고는 없다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, areaRefs: ['bldg-1'], toAreaIds: ['bldg-1', 'floor-2'] })
-  assert.equal(j.warnings.find(x => x.code === 'areas-left-behind'), undefined)
-})
-
-test('시간대가 다르면 말한다 — 같은 저널이 다른 시각으로 읽힌다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, fromTimezone: 'Asia/Seoul', toTimezone: 'America/Los_Angeles' })
-  const w = j.warnings.find(x => x.code === 'timezone-differs')
-  assert.ok(w)
-  assert.equal(w.params?.from, 'Asia/Seoul')
-  assert.equal(w.params?.to, 'America/Los_Angeles')
-})
-
-test('시간대를 선언하지 않은 공간도 다름으로 센다 — 모르는 것을 같다고 하지 않는다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, fromTimezone: 'Asia/Seoul', toTimezone: undefined })
-  assert.ok(j.warnings.find(x => x.code === 'timezone-differs'))
-})
-
-test('옛 공간의 표현은 남는다고 말한다 — 그 화면에서 이 트윈이 사라진다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, fromRepresentationCount: 3 })
-  const w = j.warnings.find(x => x.code === 'representations-left-behind')
-  assert.ok(w)
-  assert.equal(w.params?.count, 3)
-  assert.equal(w.params?.spaceId, 'wms-a-site')
-})
-
-test('실행 중 + 시간대 변화면 재기동 뒤에 적용된다고 말한다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, running: true, fromTimezone: 'Asia/Seoul', toTimezone: 'UTC' })
-  assert.ok(j.warnings.find(x => x.code === 'running'))
-})
-
-test('실행 중이지만 시간대가 같으면 말할 것이 없다 — 없는 걱정을 만들지 않는다', () => {
-  const j = judgeMoveTwinSpace({ ...CLEAN, running: true })
-  assert.equal(j.warnings.find(x => x.code === 'running'), undefined)
-})
-
-test('거절이면 경고를 함께 내지 않는다 — 일어나지 않을 일을 설명하지 않는다', () => {
-  const j = judgeMoveTwinSpace({
-    ...CLEAN,
-    toSpaceExists: false,
-    areaRefs: ['bldg-1'],
-    toAreaIds: [],
-    fromRepresentationCount: 2,
-    fromTimezone: 'Asia/Seoul',
-    toTimezone: 'UTC'
-  })
-  assert.ok(j.refusal)
-  assert.deepEqual(j.warnings, [])
-})
-
-/* ── 현장에서 떼기 ─────────────────────────────────────────────────────────── */
-
-test('현장이 없는 트윈은 뗄 것이 없다 — 아무 일도 없는데 했다고 답하지 않는다', () => {
-  const j = judgeDetachTwinSpace({ instanceId: 'wms-a', fromSpaceId: undefined })
-  assert.equal(j.refusal?.code, 'no-space')
-})
-
-test('벤치 사본은 떼지 않는다 — 무엇의 측정인지 말할 수 없게 된다', () => {
-  const j = judgeDetachTwinSpace({ instanceId: 'bench-1', fromSpaceId: 'rosarito-site', purpose: 'bench' })
-  assert.equal(j.refusal?.code, 'bench-copy')
-})
-
-test('떼면 볼 무대가 없어진다고 반드시 말한다 — 사용자가 고장으로 읽지 않게', () => {
-  const j = judgeDetachTwinSpace({ instanceId: 'wms-a', fromSpaceId: 'rosarito-site' })
-  assert.equal(j.refusal, undefined)
-  assert.ok(j.warnings.find(w => w.code === 'no-stage'), '무대가 없어진다는 말은 언제나 있다')
-})
-
-test('옛 현장의 표현과 시간 기준을 말한다 — 남는 것을 밝힌다', () => {
-  const j = judgeDetachTwinSpace({
-    instanceId: 'wms-a',
-    fromSpaceId: 'rosarito-site',
-    fromRepresentationCount: 2,
-    fromTimezone: 'America/Los_Angeles'
-  })
-  assert.equal(j.warnings.find(w => w.code === 'representations-left-behind')?.params?.count, 2)
-  assert.equal(j.warnings.find(w => w.code === 'timebase-kept')?.params?.timezone, 'America/Los_Angeles')
-})
-
-test('시간대를 선언하지 않은 현장이면 시간 기준을 말하지 않는다 — 없는 사실을 만들지 않는다', () => {
-  const j = judgeDetachTwinSpace({ instanceId: 'wms-a', fromSpaceId: 'rosarito-site' })
-  assert.equal(j.warnings.find(w => w.code === 'timebase-kept'), undefined)
-})

package/test/mutation-gate.test.ts

@@ -1,122 +0,0 @@
-/*
- * 뮤테이션 게이트 가드 — **트윈을 바꾸는 문은 전부 잠겨 있다.**
- *
- * ── 계기 (2026-08-06) ──────────────────────────────────────────────────────
- * 권한 모델을 손대며 세어 보니 트윈 뮤테이션 24개 중 **22개에 게이트가 없었다.** 인스턴스 삭제와
- * 레퍼런스 자격정보 저장까지 로그인만 하면 누구나 부를 수 있었다. 발견은 사람 눈이었다 — 즉
- * 25번째 뮤테이션이 게이트 없이 들어오면 아무것도 잡지 못한다. 그래서 기계가 센다.
- *
- * ── 왜 문자열을 그대로 비교하나 ─────────────────────────────────────────────
- * "게이트가 있나" 만 보면 `domainOwnerGranted: false` 로 약해지거나 category 가 다른 값으로 갈라져도
- * 통과한다. 게이트는 **한 문장이어야** 서버·클라·관리 화면이 같은 권한을 말한다. 그래서 정본 문장과
- * 글자까지 같은지 본다.
- *
- * ── 조회는 왜 검사하지 않나 (ADR-0027) ──────────────────────────────────────
- * 조회에는 게이트를 두지 않기로 했다 — `twinKpi` 가 같은 판정을 게이트 없이 이미 내주므로, 일부
- * 조회만 잠그면 보안이 아니라 화면 고장이 된다. 이 결정이 바뀌면 아래 "정본 문장" 검사가 먼저
- * 깨진다. 그때는 테스트를 고치지 말고 **ADR 을 먼저 고친다.**
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-/** 정본 게이트 — 트윈을 **바꾸는** 모든 작업이 요구하는 단 하나의 권한. */
-const GATE =
-  `@Directive('@privilege(category: "twin", privilege: "mutation", ` + `domainOwnerGranted: true, superUserGranted: true)')`
-
-/**
- * 두 번째 게이트 — **테넌트를 넘어 읽는 운영 계기판** (ADR-0027 예외, 2026-08-07).
- *
- * ADR-0027 의 전제는 "읽기의 경계는 테넌트 소속" 이라 조회에는 게이트를 붙이지 않는다. 그런데 프로세스
- * 부하 계기판(`twinLoad`)은 이벤트 루프가 프로세스 공유이므로 **일부러 전 테넌트를 합산한다** — 소속이
- * 경계가 되지 못한다. 그래서 시스템 소유만 본다. **권한 이름을 만들지 않았다**(category·privilege 없음).
- *
- * 늘리지 말 것. 조건은 ADR-0027 의 예외 절에 있고, 셋 중 하나라도 아니면 조회 무게이트가 그대로다.
- */
-const OPS_GATE = `@Directive('@privilege(superUserGranted: true)')`
-
-const ALLOWED = [GATE, OPS_GATE]
-
-const SERVER = new URL('../server', import.meta.url).pathname
-
-function walk(dir: string, out: string[] = []): string[] {
-  let entries: string[]
-  try {
-    entries = readdirSync(dir)
-  } catch {
-    return out
-  }
-  for (const e of entries) {
-    const p = join(dir, e)
-    if (statSync(p).isDirectory()) walk(p, out)
-    else if (p.endsWith('.ts') && !p.endsWith('.d.ts')) out.push(p)
-  }
-  return out
-}
-
-/**
- * `@Mutation` 위에 붙은 데코레이터·주석 덩이를 거꾸로 모은다.
- *
- * 데코레이터가 바로 붙어 있다고 가정하지 않는다 — 나중에 다른 데코레이터가 끼어들어도 게이트를
- * 찾아야 한다. 덩이의 끝은 코드(다른 메서드의 `}` 등)를 만나는 자리다.
- */
-function decoratorBlockAbove(lines: string[], at: number): string[] {
-  const block: string[] = []
-  for (let i = at - 1; i >= 0; i--) {
-    const t = lines[i].trim()
-    if (!t) continue /* 주석과 데코레이터 사이의 빈 줄은 덩이를 끊지 않는다 */
-    const isBlockPart = t.startsWith('@') || t.startsWith('*') || t.startsWith('/*') || t.startsWith('//')
-    if (!isBlockPart) break
-    block.push(t)
-  }
-  return block
-}
-
-const files = walk(SERVER)
-
-test('트윈을 바꾸는 뮤테이션은 전부 정본 게이트를 달고 있다', () => {
-  const ungated: string[] = []
-  let mutations = 0
-
-  for (const f of files) {
-    const lines = readFileSync(f, 'utf-8').split('\n')
-    lines.forEach((line, i) => {
-      if (!line.trim().startsWith('@Mutation')) return
-      mutations++
-      if (!decoratorBlockAbove(lines, i).some(l => l === GATE)) {
-        /* 어느 뮤테이션인지 이름으로 말한다 — 줄번호만 주면 고치는 사람이 다시 찾아야 한다. */
-        const name = (lines.slice(i, i + 6).join(' ').match(/async\s+(\w+)/) ?? [, '?'])[1]
-        ungated.push(`${f.split('/').slice(-2).join('/')}:${i + 1}  ${name}`)
-      }
-    })
-  }
-
-  /* 훑기가 망가져 0건이 되면 "위반 없음" 으로 보인다 — 그 거짓 통과를 막는다. */
-  assert.ok(mutations >= 20, `뮤테이션을 ${mutations}개만 찾았다 — 소스 훑기가 망가졌다`)
-  assert.deepEqual(
-    ungated,
-    [],
-    `게이트 없는 뮤테이션 ${ungated.length}건 — 로그인만 하면 누구나 부를 수 있다:\n${ungated.join('\n')}`
-  )
-})
-
-test('권한 문장이 하나로 통일되어 있다 — 약해지거나 서로 어긋나지 않았다', () => {
-  const odd: string[] = []
-  for (const f of files) {
-    readFileSync(f, 'utf-8')
-      .split('\n')
-      .forEach((line, i) => {
-        const t = line.trim()
-        if (!t.startsWith("@Directive('@privilege")) return
-        if (!ALLOWED.includes(t)) odd.push(`${f.split('/').slice(-2).join('/')}:${i + 1}  ${t}`)
-      })
-  }
-  assert.deepEqual(
-    odd,
-    [],
-    `정본과 다른 권한 문장 ${odd.length}건. 쓰기는 GATE 하나, 테넌트를 넘어 읽는 운영 계기판만 ` +
-      `OPS_GATE. 그 밖으로 늘리는 것이 의도라면 ADR-0027 을 먼저 고치고 이 검사의 정본을 함께 옮긴다:` +
-      `\n${odd.join('\n')}`
-  )
-})

package/test/oee-accumulator.test.ts

@@ -1,204 +0,0 @@
-/*
- * ★ OEE 이벤트 누적기 검증 — equipment.status 스트림으로 카운터 근사 생산 → computeOee.
- * live 가 실 텔레메트리 없이도 OEE 를 근사 산출하는 경로(face2-inbound-live §1.1 option ②).
- * 정확 검증: downMs(고장 시간) == sim, busyMs == sim(run+setup). 근사 한계 명시: quality=1(good/scrap 이벤트 부재).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { WmsKernel, StateProjector } from '@operato/twin-kernel'
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-import { buildEntityDeltas } from '../shared/entity-delta.ts'
-import { OeeAccumulator, withLiveOee } from '../server/engine/oee-accumulator.ts'
-
-const BASE_EPOCH = Date.parse('2026-01-01T00:00:00Z') // 커널 now() 고정 오프셋(flow-engine BASE_EPOCH)
-const GTIN = 'urn:epc:idpat:sgtin:0614141.099999.*'
-const TICK = 1000
-
-function runSimCollect() {
-  const m = {
-    source: 'oee', system: 'wms' as const, siteName: 'O',
-  /* 이 픽스처가 식별자를 만드는 이름공간 — **픽스처마다 다르게** 둔다(같은 접두 아래에서 서로 다른
-     시험의 번호가 부딪치면 표준의 유일성 요구를 깬다, CBV 2.0 §8.2.4). 커널은 선언 없이 팔레트·문서를
-     만들지 않는다(0.7.45 에서 날조 프리픽스를 지웠다). */
-    identity: { namespaces: ['https://twin.test/oee-accumulator'] },
-    space: { width: 90, depth: 40, unit: 'm' },
-    locations: [
-      { id: 'a', type: 'warehouse', role: 'area' as const },
-      { id: 'dock-recv', type: 'dock', role: 'location' as const, capacity: 100 },
-      { id: 'rack-1', type: 'storage', role: 'location' as const, capacity: 60 },
-      { id: 'staging', type: 'staging', role: 'location' as const, capacity: 80 },
-      { id: 'dock-ship', type: 'dock-ship', role: 'location' as const, capacity: 100 }
-    ],
-    equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv', mtbfMs: 5000, mttrMs: 8000 }]
-  }
-  const model = masterToTwin(m).model
-  const k = new WmsKernel('t')
-  const events: any[] = []
-  k.onEvent((e: any) => events.push(e))
-  k.loadTwinModel(model)
-  k.scenario.load({ seed: 9, generators: [{ kind: 'inbound-arrival', rate: { distribution: 'constant', meanPerHour: 300 }, content: { skuMix: [{ gtin: GTIN, weight: 1 }], qtyPerLine: { min: 1, max: 1 } } }] })
-  k.scenario.start()
-  for (let i = 0; i < 200; i++) k.tick(TICK)
-  return { events, snap: k.getSnapshot() as any, model }
-}
-
-test('★ OEE 누적기: downMs 정확 · busyMs=run+setup · 근사 OEE 유효', () => {
-  const { events, snap } = runSimCollect()
-  const simOee = snap.equipment.find((x: any) => x.id === 'fk-1')?.oee
-  assert.ok(simOee, 'sim fk-1 oee 존재')
-  assert.ok(simOee.downMs > 0, '시나리오가 고장(down) 유발 — 검증 의미 있음')
-
-  const acc = new OeeAccumulator()
-  for (const e of events) acc.apply(e)
-  const nowMs = BASE_EPOCH + snap.simClockMs
-  const c = acc.counters('fk-1', nowMs)
-
-  // 정확: downMs(고장 시간) — 이벤트 down 구간 합 == sim(tick 누적). availability 핵심 입력. tick 경계 오차 ≤ 1 tick.
-  assert.ok(Math.abs(c.downMs - simOee.downMs) <= TICK, `downMs 정확 (acc ${c.downMs} vs sim ${simOee.downMs})`)
-  // busyMs ≈ run+setup, 단 **진행중 task 작업분 포함**(runMs 는 완료분만 누적) → busyMs ≥ 완료 run+setup.
-  // 이벤트로 setup 분리 불가라 busy 를 run 으로 근사. 한 task 규모의 초과는 정상(진행중분).
-  const completed = simOee.runMs + simOee.setupMs
-  assert.ok(c.runMs >= completed - TICK, `busyMs ≥ 완료 run+setup (acc ${c.runMs} vs sim ${completed})`)
-  assert.ok(c.runMs - completed <= 30000, `초과분(진행중 task)이 task 규모 이내 (${c.runMs - completed})`)
-
-  // 근사 OEE 유효 + 한계 명시.
-  const oee = acc.oee('fk-1', nowMs)
-  /*
-   * 총합은 **없을 수 있다.** 표준 시간(PRI)이 없으면 성능률이 안 나오고, 그러면 곱도 안 나온다
-   * (계약 0.5.0, ISO 22400 대조). 누적기는 사건에서 표준 시간을 알 수 없으므로 여기서는 없는 것이 정상이다.
-   *
-   * 예전에는 근거 없이 1 을 내서 총합이 늘 값을 가졌다. 그때 이 단언은 아무것도 지키지 않았다.
-   */
-  if (oee.overall === undefined) {
-    assert.ok(oee.missing?.includes('planned-run-time-per-item'), `총합이 없으면 이유가 있어야 한다: ${JSON.stringify(oee.missing)}`)
-  } else {
-    assert.ok(oee.overall >= 0 && oee.overall <= 1, 'OEE overall ∈ [0,1]')
-  }
-  assert.ok((oee.availability as number) >= 0 && (oee.availability as number) <= 1, 'availability ∈ [0,1]')
-  /*
-   * WMS 는 품질 개념이 없어 산출을 기록하지 않는다. 만든 것이 없으면 양품률은 **모름**이다.
-   * 예전에는 1 을 냈고, 그래서 품질을 재지도 않는 창고 설비가 「품질 100%」로 보였다.
-   */
-  assert.equal(oee.quality, undefined, 'WMS 는 산출 기록이 없으므로 양품률은 모름이다')
-  assert.ok(oee.missing?.includes('produced-quantity'))
-})
-
-test('★ OEE 누적기: quality.output 델타 소비 → quality 정확 (good/scrap 도출)', () => {
-  const acc = new OeeAccumulator()
-  const T0 = Date.parse('2026-01-01T00:00:00Z')
-  const ev = (ms: number, type: string, data: any): any => ({ eventId: 'x', eventType: type, eventTime: new Date(T0 + ms).toISOString(), tenantId: 't', data })
-
-  acc.apply(ev(0, 'equipment.status', { moverId: 'w1', status: 'busy' }))
-  acc.apply(ev(1000, 'quality.output', { moverId: 'w1', good: false, goodCount: 0, nonconformingCount: 1 }))
-  acc.apply(ev(2000, 'quality.output', { moverId: 'w1', good: true, goodCount: 8, nonconformingCount: 2 })) // 누적값 최신화
-  acc.apply(ev(3000, 'equipment.status', { moverId: 'w1', status: 'idle' }))
-
-  const c = acc.counters('w1', T0 + 4000)
-  assert.equal(c.goodCount, 8, 'goodCount 추적(누적 최신)')
-  assert.equal(c.nonconformingCount, 2, 'nonconformingCount 추적')
-  const oee = acc.oee('w1', T0 + 4000)
-  assert.ok(Math.abs(oee.quality - 0.8) < 1e-9, 'quality = good/(good+scrap) = 0.8 (텔레메트리 없이 이벤트로 도출)')
-})
-
-test('★ withLiveOee: projector 미러(oee 없음) + 누적기 → live 설비 payload 에 oee 포함 (원 갭 종료)', () => {
-  const { events, model } = runSimCollect()
-  const proj = new StateProjector(model)
-  const acc = new OeeAccumulator()
-  for (const e of events) { proj.apply(e); acc.apply(e) }
-
-  const rawLive = proj.snapshot() as any
-  // 원 갭: projector 미러 설비엔 oee 없음.
-  assert.equal(rawLive.equipment.find((m: any) => m.id === 'fk-1')?.oee, undefined, 'projector 미러엔 oee 부재(원 갭)')
-
-  // withLiveOee 로 보강 → buildEntityDeltas payload 에 oee 포함(sim 과 동일 형상 = 보드 OEE 컴포넌트 live 렌더).
-  const enriched = withLiveOee(rawLive, acc)
-  const fk = buildEntityDeltas(enriched, 't1').find(d => d.tag === 'fk-1')!.data as any
-  assert.ok(fk.oee, 'withLiveOee 후 설비 data(tag) payload 에 oee 포함 — live OEE 갭 종료')
-  // buildEntityDeltas shapeOee = 정수 퍼센트(0-100), raw ms 제외.
-  assert.ok(fk.oee.overall >= 0 && fk.oee.overall <= 100, 'oee.overall ∈ [0,100] 정수 퍼센트')
-  assert.ok(fk.oee.availability < 100, 'availability < 100 (고장 시간 반영 — 누적기 downMs)')
-})
-
-/*
- * ── 되짚은 화면에도 가동 이력이 있어야 한다 (2026-08-05) ────────────────────
- * OEE 는 원 시스템이 누적을 보내 주지 않아 호스트가 상태 전이를 적분해 만든다. 그런데 그 누적기는
- * **라이브에서만** 돌았고, 저널을 계산하는 경로는 그 계산을 하지 않았다 — 과거를 되짚으면 모든 설비가
- * "가동 이력이 전혀 없음" 으로 보였다(실 저널: `rosarito-mes` 18대, `hatiolab-wms` 22대가 그랬다).
- *
- * 없는 것은 데이터가 아니라 계산이다: 입력은 저널에 다 있다. 그래서 같은 누적기에 같은 이벤트를
- * 태운다 — 이 테스트는 그 재계산이 라이브와 **같은 값**을 내는지, 그리고 시간여행에서 **그 시점까지만**
- * 세는지를 못 박는다.
- */
-test('★ 저널을 다시 태우면 라이브와 같은 계측이 나온다 — 규칙이 하나이므로', () => {
-  const T0 = Date.parse('2026-08-05T00:00:00.000Z')
-  const ev = (ms: number, id: string, status: string) => ({
-    eventId: `e${ms}`,
-    eventType: 'equipment.status',
-    eventTime: new Date(T0 + ms).toISOString(),
-    tenantId: 't',
-    data: { equipmentId: id, moverId: id, status }
-  })
-  const stream = [ev(0, 'fk-1', 'idle'), ev(10_000, 'fk-1', 'busy'), ev(40_000, 'fk-1', 'down'), ev(70_000, 'fk-1', 'idle')]
-
-  /* 라이브 — 이벤트가 도착하는 대로 누적. */
-  const live = new OeeAccumulator()
-  for (const e of stream) live.apply(e as any)
-
-  /* 되짚기 — 저널에서 같은 순서로 다시 태운다. */
-  const replayed = new OeeAccumulator()
-  for (const e of stream) replayed.apply(e as any)
-
-  const at = T0 + 70_000
-  assert.deepEqual(replayed.oee('fk-1', at), live.oee('fk-1', at), '같은 이벤트·같은 시점이면 같은 값이어야 한다')
-  assert.equal(replayed.oee('fk-1', at).downMs, 30_000, '고장 30초가 잡혀야 한다')
-})
-
-test('★ 시간여행은 그 시점까지만 센다 — 뒤에 일어난 고장이 과거 화면에 섞이지 않게', () => {
-  const T0 = Date.parse('2026-08-05T00:00:00.000Z')
-  const ev = (ms: number, status: string) => ({
-    eventId: `e${ms}`,
-    eventType: 'equipment.status',
-    eventTime: new Date(T0 + ms).toISOString(),
-    tenantId: 't',
-    data: { equipmentId: 'fk-1', moverId: 'fk-1', status }
-  })
-  const all = [ev(0, 'busy'), ev(30_000, 'down'), ev(60_000, 'idle')]
-
-  /* 30초 시점까지만 태운다(호스트가 잘라 낸 이벤트만 태우는 것과 같다). */
-  const past = new OeeAccumulator()
-  for (const e of all.slice(0, 2)) past.apply(e as any)
-  assert.equal(past.oee('fk-1', T0 + 30_000).downMs, 0, '아직 고장이 시작된 시점 — 고장 시간은 0 이다')
-
-  const now = new OeeAccumulator()
-  for (const e of all) now.apply(e as any)
-  assert.equal(now.oee('fk-1', T0 + 60_000).downMs, 30_000, '지금 화면에서는 고장 30초가 잡힌다')
-})
-
-test('★ 계측 시점을 벽시계로 재지 않는다 — 과거 화면의 가용률이 시간이 갈수록 떨어지지 않게', () => {
-  const T0 = Date.parse('2026-08-05T00:00:00.000Z')
-  const acc = new OeeAccumulator()
-  acc.apply({ eventId: 'e1', eventType: 'equipment.status', eventTime: new Date(T0).toISOString(), tenantId: 't', data: { equipmentId: 'fk-1', moverId: 'fk-1', status: 'busy' } } as any)
-  const atThen = acc.oee('fk-1', T0 + 10_000)
-  const atMuchLater = acc.oee('fk-1', T0 + 10_000_000)
-  assert.notDeepEqual(atThen, atMuchLater, '시점을 넘기면 값이 달라진다 — 그래서 그 화면의 시각을 넘겨야 한다')
-})
-
-/*
- * ★ 못 본 설비의 계측 창 — **없으면 없다고 한다.**
- *
- * 예전에는 `metricsSinceMs: 0` 을 돌려줬다. 시각이 epoch 밀리초라서 그 창은 곧 "1970년부터" 가 되고,
- * 공식의 분모가 지금 시각 전체가 된다 — 화면에 `idleMs 1767226603000`(약 56,000년) 유휴가 섰다.
- * 그 값은 availability·overall 의 분모이기도 해서 **성과 숫자 전체가 알리지 않고 거짓**이 됐다.
- */
-test('이벤트를 못 본 설비는 계측 창을 만들지 않는다 — epoch 를 창으로 삼지 않는다', () => {
-  const acc = new OeeAccumulator()
-  const c = acc.counters('never-seen', Date.parse('2026-01-01T00:00:00.000Z'))
-  assert.equal(c.metricsSinceMs, undefined, '모르는 창을 0 으로 메우면 1970년부터 쟀다는 말이 된다')
-
-  /*
-   * 그다음(창이 없을 때 유휴는 0)은 **공식의 책임**이고 공식은 커널에 있다 — 커널의
-   * `test/oee-window` 가 못 박는다. 여기서 그 결과까지 단정하면 이 검사는 커널 발행 시점에
-   * 묶이고, 남의 책임을 자기 검사에 넣은 것이 된다.
-   */
-})