@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/journal-write-door.test.ts

@@ -1,110 +0,0 @@
-/*
- * **저널을 쓰는 문은 하나다** — 그리고 멈출 때 남은 것을 흘린다 (ingest-scale §7.1, 2026-08-20).
- *
- * ── 무엇이 관측됐나 ─────────────────────────────────────────────────────────
- * 데모 자극을 켠 트윈 23개가 도는 서버에서 프로세스가 CPU 81~112% 를 계속 쓰고, 아무 일도 하지 않는
- * 질의가 `twinLoad` 8초 · `twinInstanceList` 14초였다. `sample` 프로파일은 `JSON.parse`·대형 GC·
- * 스레드풀을 가리켰고, 계기는 **틱의 몫이 16%** 라고 말했다 — 틱이 아니었다.
- *
- * 코드가 이유였다: 기록 경로가 둘인데 **배치는 라이브만**이었다.
- *  · 라이브 — 200ms 마다 모아 벌크 저장
- *  · 시뮬  — 커널이 낸 **델타 하나마다** 행 하나 저장(그리고 그 안에서 구조 리비전을 물었다)
- *
- * 같은 파일이 **브로드캐스팅**에서 같은 함정을 이미 겪고 고쳤다(틱 하나가 35초). 쓰기만 단건으로 남아 있었다.
- * ADR-0030 이 *"기록 경로가 둘인 것은 시뮬만 옆문으로 들어오기 때문"* 이라 예고한 그 자리다.
- *
- * ── 성능을 사려고 사실을 팔지 않는다 ────────────────────────────────────────
- * 배치로 옮기면 주기 사이에 멈출 때 그 구간이 사라진다 — **라이브도 이미 그랬다**(최대 200ms). 그래서
- * 정지 때 남은 것을 흘리는 자리를 함께 만들었다. 상태만 남기고 저널을 잃으면 「왜 그렇게 됐나」가 빈다.
- *
- * 이 시험은 소스로 규율을 지킨다(DB 없이 도는 스위트다). 정량화는 들어온 것이 없는 서버의 `journalRate` 가 답한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-const engine = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-
-/**
- * 메서드 본문만 — 다른 자리의 같은 낱말에 걸리지 않게.
- *
- * **다음 메서드 선언에서 끊는다.** 길이로 자르면 옆 메서드가 딸려 와, 「이 메서드가 몇 번 부르나」를
- * 세는 단정이 오류 없이 틀린 값을 낸다(실제로 그렇게 2를 세었다).
- */
-function methodOf(src: string, name: string): string {
-  const at = src.indexOf(`${name}(`)
-  assert.ok(at >= 0, `${name} 가 없다`)
-  const rest = src.slice(at + name.length)
-  const next = rest.search(/\n  (static|private static|async|[a-zA-Z]+\()/)
-  return rest.slice(0, next > 0 ? next : 3000)
-}
-
-test('시뮬이 델타마다 행을 쓰지 않는다 — 모아서 한 문으로 보낸다', () => {
-  const at = engine.indexOf("if (msg.kind === 'delta')")
-  const body = engine.slice(at, at + 2600)
-  assert.match(body, /pendingJournal/, '델타는 버퍼에 담긴다')
-  assert.equal(/this\.persist\(domainId, id, msg\)/.test(body), false, '단건 저장으로 되돌아갔다')
-})
-
-test('단건 저장 경로가 아예 없다 — 남겨 두면 다시 부를 자리가 된다', () => {
-  assert.equal(/static async persist\(domainId/.test(engine), false, '`persist` 가 되살아났다')
-  /* 쓰는 문은 둘이지만 **부르는 자리는 하나**다(`flushJournal`). */
-  /* 약속을 돌려준다 — 정지가 기다릴 수 있어야 한다(기다리지 않으면 웜스타트가 빈 저널을 읽는다). */
-  assert.match(engine, /private static flushJournal\(inst: InstanceRuntime\): Promise<void>/)
-  assert.match(engine, /await this\.flushJournal\(i\)/, '정지는 흘리기를 기다린다')
-  assert.match(engine, /static async persistBatch\(/)
-  assert.match(engine, /static async persistCarried\(/)
-  /* 넣기만 한다 — `save` 는 행마다 SELECT 를 한 번 더 한다(시험 로그에서 그 질의가 보였다). */
-  assert.match(engine, /private static async insertRows\(/)
-  assert.equal(/repo\.save\(rows, \{ chunk: 500 \}\)/.test(engine), false, '저널을 save 로 넣는 모양으로 되돌아갔다')
-})
-
-test('커널이 매긴 리비전을 호스트가 다시 번호 붙이지 않는다 — 시간여행이 그것을 딛는다', () => {
-  const flush = methodOf(engine, 'private static flushJournal')
-  /* 시뮬은 자기 리비전을 들고 오고(`{ event, revision }`), 라이브는 flush 에서 이어 붙인다. */
-  assert.match(flush, /typeof b\.revision === 'number'/, '들고 온 리비전을 가려낸다')
-  assert.match(flush, /inst\.revision = start \+ plain\.length/, '라이브만 이어 붙인다')
-  const carried = methodOf(engine, 'static async persistCarried')
-  assert.match(carried, /it\.revision/, '들고 온 리비전을 그대로 쓴다')
-  /* 구조 리비전은 배치에 **한 번**만 묻는다 — 행마다 묻던 것이 문제였다. */
-  assert.equal((carried.match(/structureRevOf/g) ?? []).length, 1)
-})
-
-test('멈출 때 남은 것을 흘린다 — 성능을 사려고 사실을 팔지 않는다', () => {
-  const stop = methodOf(engine, 'static async stop')
-  assert.match(stop, /this\.flushJournal\(i\)/, '정지 경로가 버퍼를 흘린다')
-  const flushAt = stop.indexOf('this.flushJournal(i)')
-  const dropAt = stop.indexOf('delete this.instances')
-  assert.ok(flushAt >= 0 && dropAt >= 0 && flushAt < dropAt, '런타임을 버리기 전에 흘려야 한다')
-})
-
-test('두 구동이 같은 계기를 든다 — 세지 않는 개선은 되돌려도 아무도 모른다', () => {
-  /*
-   * 계기(`inst.metrics`)가 `startLive` 에만 있었다. 그래서 도는 트윈 22개가 시뮬인 서버에서 「초당 몇 행을
-   * 쓰나」·「밀린 게 있나」를 물을 자리가 없었고, 모니터 목록에서도 시뮬이 알리지 않고 빠졌다(계기가 null 이라
-   * 걸러졌다) — 부하가 거의 없는 것처럼 보였다.
-   */
-  assert.match(engine, /private static newMetrics\(\): TwinMetrics/, '계기 한 벌을 한 곳에서 만든다')
-  const sim = engine.slice(engine.indexOf("mode: 'sim'"), engine.indexOf("mode: 'sim'") + 1200)
-  assert.match(sim, /metrics: this\.newMetrics\(\)/, '시뮬도 계기를 든다')
-  /* 비율 갱신이 라이브만 보면 시뮬 칸은 영원히 0 이다. */
-  assert.equal(/const m = isLive \? inst\.metrics : undefined/.test(engine), false, '비율 갱신이 시뮬을 다시 잘라 냈다')
-})
-
-test('적은 것을 장부에 남긴다 — 계기는 지금만 답하고 재기동에 0 으로 돌아간다', () => {
-  const flush = methodOf(engine, 'private static flushJournal')
-  /* 실패한 배치를 「남았다」고 세지 않으려면 **쓴 뒤에** 적어야 한다. */
-  assert.match(flush, /this\.recordJournalWrite\(inst\.domainId, inst\.id, written\)/)
-  const thenAt = flush.indexOf('.then(')
-  const recAt = flush.indexOf('this.recordJournalWrite')
-  assert.ok(thenAt >= 0 && recAt > thenAt, '약속이 풀린 뒤에 적는다 — 터진 배치를 세지 않게')
-})
-
-test('구조 리비전은 「없다」도 기억한다 — 없는 트윈이 부를 때마다 질의하지 않게', () => {
-  const body = methodOf(engine, 'static async structureRevOf')
-  assert.match(body, /this\.structureRevCache\[key\] = latest \? latest\.rev : null/, '미스를 기억한다')
-  assert.equal(/if \(latest\) this\.structureRevCache/.test(body), false, '미스를 흘려버리는 모양으로 되돌아갔다')
-  /* 캐시가 `null` 을 담으므로 「모름」과 구별된다 — 형이 그 사실을 말해야 다음 사람이 0 으로 읽지 않는다. */
-  assert.match(engine, /structureRevCache: Record<string, number \| null>/)
-})

package/test/journal-write-trend.test.ts

@@ -1,115 +0,0 @@
-/*
- * **적은 것도 추이로 남는다** — 「저널이 얼마나 쓰이고 있나」를 나중에도 물을 수 있게 (2026-08-20).
- *
- * ── 왜 필요한가 ─────────────────────────────────────────────────────────────
- * 계기(`journalRate`·`journaledTotal`)는 **지금**만 답한다. 프로세스를 다시 띄우면 0 에서 시작하므로
- * 「어제 이 시각에도 이랬나」·「고친 뒤로 정말 줄었나」를 물을 자리가 없었다. 그런데 2026-08-20 에 고친
- * 것이 바로 쓰기 경로(델타마다 한 행 → 창당 한 번)다. 세지 않는 개선은 되돌아가도 아무도 모른다.
- *
- * ── 왜 새 장부를 만들지 않았나 ──────────────────────────────────────────────
- * 유입 창은 「닫힌 창만 최근」·「0 과 없음을 가른다」·「밀려난 것을 세어 드러낸다」를 이미 지키고, 닫힐 때
- * 행으로 남는다. 같은 규율을 두 벌 만들면 한 벌만 고쳐진다. 그래서 그 창에 칸을 더했다.
- *
- * ── 이 시험이 지키는 것 ─────────────────────────────────────────────────────
- *  ① 유입이 한 번도 없어도 쓰기가 창을 넘긴다 — 시뮬 트윈이 추이에서 사라지지 않게.
- *  ② 행과 왕복을 **따로** 센다 — 행당 왕복이 1 로 되돌아가면 그것이 보인다.
- *  ③ 쓰기는 **「마지막 유입」을 갱신하지 않는다** — 섞으면 끊긴 피드가 옛 창으로 초록을 낸다.
- *  ④ 없는 것을 0 건 쓰기로 만들지 않는다.
- *  ⑤ 쓰기만 있는 장부의 시각이 1969년으로 뜨지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  INGEST_WINDOW_MS,
-  STALE_AFTER_MS,
-  ingestHealth,
-  newIngestLedger,
-  recordIngest,
-  recordJournalWrite
-} from '../server/engine/ingest-health.ts'
-
-const T0 = 1_700_000_000_000
-
-/* ── ① 유입 없이도 추이가 생긴다 ──────────────────────────────────────────── */
-
-test('받는 것 없이 적기만 하는 트윈도 추이에 남는다 — 시뮬이 오류 없이 빠지지 않게', () => {
-  const l = newIngestLedger()
-  const closed: any[] = []
-
-  recordJournalWrite(l, 40, T0, w => closed.push(w))
-  recordJournalWrite(l, 60, T0 + 1000, w => closed.push(w))
-  /* 창 길이를 넘긴 뒤의 쓰기가 앞 창을 닫는다. */
-  recordJournalWrite(l, 10, T0 + INGEST_WINDOW_MS + 1, w => closed.push(w))
-
-  assert.equal(closed.length, 1, '창이 닫혀 영속 훅까지 불린다')
-  assert.equal(closed[0].rows, 100)
-  assert.equal(closed[0].offered, 0, '유입은 0 이다 — 그것도 사실이다')
-
-  const view = ingestHealth(l, 'not-applicable', undefined, T0 + INGEST_WINDOW_MS + 2)
-  assert.equal(view.trend.length, 1, '유입 시각이 없다는 이유로 빈 화면을 내지 않는다')
-  assert.equal(view.trend[0].rows, 100)
-  assert.equal(view.total.rows, 110, '누적은 열린 창까지 센다')
-})
-
-/* ── ② 행과 왕복을 따로 센다 ──────────────────────────────────────────────── */
-
-test('행과 왕복을 따로 센다 — 행당 왕복이 1 로 되돌아가면 그것이 보인다', () => {
-  const batched = newIngestLedger()
-  recordJournalWrite(batched, 500, T0)
-  recordJournalWrite(batched, 500, T0 + 200)
-  assert.equal(batched.rows, 1000)
-  assert.equal(batched.flushes, 2, '모아 보낸 것은 두 번이다')
-
-  /* 되돌아간 모양 — 같은 1,000행에 왕복 1,000번. 행 수만 세면 두 장부가 똑같이 보인다. */
-  const perDelta = newIngestLedger()
-  for (let i = 0; i < 1000; i++) recordJournalWrite(perDelta, 1, T0 + i)
-  assert.equal(perDelta.rows, batched.rows, '행 수는 같다 — 그래서 행만으로는 가려낼 수 없다')
-  assert.ok(perDelta.flushes > batched.flushes * 100, '왕복 수가 그 차이를 드러낸다')
-})
-
-/* ── ③ 축을 섞지 않는다 ───────────────────────────────────────────────────── */
-
-test('쓰기가 「마지막 유입」을 갱신하지 않는다 — 끊긴 피드가 초록으로 보이지 않게', () => {
-  const l = newIngestLedger()
-  /* 건강한 유입이 한동안 있었고, 그 뒤 피드가 끊겼다. */
-  recordIngest(l, 100, [], T0)
-  recordIngest(l, 100, [], T0 + INGEST_WINDOW_MS + 1) /* 앞 창을 닫아 「최근」을 만든다 */
-
-  const muchLater = T0 + INGEST_WINDOW_MS + STALE_AFTER_MS + 60_000
-  /* 그 사이에도 트윈은 틱이 만든 델타를 계속 적는다 — 라이브에서 실제로 그렇다. */
-  for (let t = T0 + 60_000; t < muchLater; t += 60_000) recordJournalWrite(l, 5, t)
-
-  const view = ingestHealth(l, 'attached', undefined, muchLater)
-  /*
-   * 판정이 초록이 아니어야 한다. 어떤 말로 부르는지는 창의 모양에 달렸다(마지막 닫힌 창이 유입 0 이면
-   * 「유입 없음」, 창이 아직 안 닫혔으면 「끊긴 피드」) — 둘 다 「받고 있지 않다」다. 못 박는 것은 **적고
-   * 있다는 사실이 「받고 있다」로 번역되지 않는다**는 것이다.
-   */
-  assert.notEqual(view.verdict, 'healthy', '적고 있다는 사실이 「받고 있다」로 번역되지 않는다')
-  assert.equal(view.lastAt, new Date(T0 + INGEST_WINDOW_MS + 1).toISOString(), '마지막 유입 시각이 쓰기로 밀리지 않는다')
-  assert.equal(view.lastWriteAt, new Date(muchLater - 60_000).toISOString(), '적은 시각은 따로 낸다')
-})
-
-/* ── ④⑤ 없는 것과 0 ──────────────────────────────────────────────────────── */
-
-test('없는 것을 0 건 쓰기로 만들지 않는다', () => {
-  const l = newIngestLedger()
-  for (const bad of [0, -3, NaN, Infinity]) recordJournalWrite(l, bad as number, T0)
-  assert.equal(l.flushes, 0, '아무 일도 없었으면 왕복도 없다')
-  assert.equal(l.rows, 0)
-  assert.equal(l.lastWriteAtMs, -1, '적지 않았으면 적은 시각도 없다')
-  assert.equal(ingestHealth(l, 'not-applicable', undefined, T0).lastWriteAt, null)
-})
-
-test('쓰기만 있는 장부의 시각이 1969년으로 뜨지 않는다 — `-1` 을 시각으로 읽지 않는다', () => {
-  const l = newIngestLedger()
-  recordJournalWrite(l, 7, T0)
-  recordJournalWrite(l, 7, T0 + INGEST_WINDOW_MS + 1)
-
-  const view = ingestHealth(l, 'not-applicable', undefined, T0 + INGEST_WINDOW_MS + 2)
-  assert.equal(view.lastAt, null, '받은 적이 없으면 유입 시각은 **없다**(0 이 아니다)')
-  for (const w of [...view.trend, view.recent!]) {
-    assert.ok(new Date(w.to).getUTCFullYear() >= 2023, `창 끝 시각이 ${w.to} 로 떴다`)
-  }
-})

package/test/kernel-kind-guard.test.ts

@@ -1,98 +0,0 @@
-/*
- * 커널 선택 가드 — **모르는 종류로는 뜨지 않는다.**
- *
- * ── 무엇이 있었나 (2026-08-08) ───────────────────────────────────────────────
- * 커널을 고르는 자리 셋이 모두 이랬다:
- *
- *     const Kernel = KERNELS[reg.kind ?? 'wms'] ?? WmsKernel
- *
- * 폴백이 둘 겹쳐 있었다. ①은 컬럼이 비었을 때, ②는 표에 없는 값일 때. 그리고 `kind` 는
- * 검증 없는 자유 문자열이다(`@Arg('kind') kind: string` — enum 도 화이트리스트도 없다).
- * 그래서 오타 하나·대소문자 하나로 **야드/생산 트윈이 오류 없이 창고 커널로 돌았다.**
- * 오류가 없으니 화면에는 트윈이 정상으로 보이고, 안에서 도는 규칙만 다른 도메인의 것이다.
- * 예측 경로가 가장 나빴다 — 야드의 미래를 창고 규칙으로 굴려 놓고 숫자만 뜬다.
- *
- * ── 왜 검사로 남기나 ────────────────────────────────────────────────────────
- * 자리를 고치는 것만으로는 부족하다. 커널 종류가 늘 때(다음은 TMS 든 무엇이든) 새 자리가
- * 생기고, `?? WmsKernel` 은 "안전한 기본값" 처럼 보여서 다시 자란다. 실제로 세 자리에
- * 똑같이 자라 있었다. 틀린 공장을 알리지 않고 띄우는 것보다 뜨지 않는 편이 낫다.
- *
- * 이 검사가 막는 것은 **표를 밖에서 직접 색인하는 것**이다. 종류→커널 해소는 `kernelFor`
- * 하나만 한다. 새 자리를 쓸 때 이 검사가 걸리면, 폴백을 붙이지 말고 `kernelFor` 를 부를 것.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { guardRoots } from './guard-roots.ts'
-
-const ENGINE = new URL('../server/engine/twin-engine.ts', import.meta.url).pathname
-const MUTATION = new URL('../server/service/twin-lifecycle/twin-lifecycle-mutation.ts', import.meta.url).pathname
-
-/*
- * 종류 폴백은 **한 패키지에 갇혀 있지 않다.** 처음에 twin-engine 두 자리만 고쳤더니, 라이브 미러를
- * 띄우는 호출자 넷(operato-twin 의 벤치·부하시험·프리셋 프로비저닝, headless 의 reference-live)이
- * `det.kind ?? 'wms'` 로 **엔진이 오류를 내기 전에 먼저 값을 정하고** 있었다. 커넥터 spec 도 마찬가지였다.
- * 그래서 두 패키지의 서버 코드를 함께 훑는다.
- */
-const ROOTS = guardRoots(import.meta.url, ['../server'])
-
-/**
- * 코드만 본다 — 주석은 **과거를 설명하느라 옛 코드를 그대로 인용한다**(바로 위 머리말이 그렇다).
- * 줄 단위로 `*`·`//` 만 걸러내면 여러 줄 주석의 둘째 줄부터 새어 나오므로 블록을 통째로 지운다.
- */
-function codeOf(path: string): string[] {
-  return readFileSync(path, 'utf-8')
-    .replace(/\/\*[\s\S]*?\*\//g, '') // 블록 주석
-    .split('\n')
-    .map(l => l.replace(/\/\/.*$/, '')) // 줄 주석
-    .filter(l => l.trim())
-}
-
-test('커널 폴백이 없다 — 모르는 종류는 창고로 떨어지지 않는다', () => {
-  const offenders = codeOf(ENGINE).filter(l => /\?\?\s*WmsKernel|\|\|\s*WmsKernel/.test(l))
-  assert.deepEqual(offenders, [], '커널 선택에 폴백이 다시 생겼다 — kernelFor 가 오류를 내게 할 것')
-})
-
-test('종류→커널 해소는 kernelFor 한 곳만 한다', () => {
-  /* 표를 직접 색인하는 줄. 정의부(`const KERNELS: Record…`)와 kernelFor 내부는 제외. */
-  const indexing = codeOf(ENGINE).filter(l => /KERNELS\[/.test(l) && !/const K = KERNELS\[kind\]/.test(l))
-  assert.deepEqual(indexing, [], 'KERNELS 를 밖에서 색인하고 있다 — kernelFor(kind) 를 쓸 것')
-})
-
-test('kernelFor 는 모르는 종류에 오류를 낸다 — 알리지 않고 고르지 않는다', () => {
-  const src = readFileSync(ENGINE, 'utf-8')
-  const fn = src.slice(src.indexOf('function kernelFor'))
-  assert.match(fn.slice(0, 300), /throw new Error/, 'kernelFor 가 오류를 내지 않으면 이 계약이 무너진다')
-})
-
-test("board 를 주는 기동은 kind 를 요구한다 — `kind ?? 'wms'` 로 메우지 않는다", () => {
-  const offenders = codeOf(MUTATION).filter(l => /kind\s*\?\?\s*['"]/.test(l))
-  assert.deepEqual(offenders, [], '종류를 빠뜨린 프로비저닝이 다시 창고로 기동한다')
-})
-
-/** 두 패키지의 서버 .ts 전부. */
-function serverFiles(): string[] {
-  const out: string[] = []
-  const walk = (dir: string) => {
-    for (const e of readdirSync(dir)) {
-      const p = join(dir, e)
-      if (statSync(p).isDirectory()) walk(p)
-      else if (p.endsWith('.ts') && !p.endsWith('.d.ts')) out.push(p)
-    }
-  }
-  for (const r of ROOTS) walk(r)
-  return out
-}
-
-test('어느 서버 코드도 커널 종류를 리터럴로 메우지 않는다 — 호출자가 엔진의 검증을 앞질렀다', () => {
-  /* 예시 JSON 안의 `system: 'wms'` 는 필드를 보여 주는 것이라 대상이 아니다 — 폴백 연산자만 본다. */
-  const offenders: string[] = []
-  for (const f of serverFiles()) {
-    codeOf(f).forEach(l => {
-      if (/(\?\?|\|\|)\s*['"](wms|yms|mes)['"]/.test(l)) offenders.push(`${f.split('/packages/')[1]}: ${l.trim().slice(0, 90)}`)
-    })
-  }
-  assert.deepEqual(offenders, [], '종류 폴백이 다시 생겼다 — 선언이 없으면 메우지 말고 던질 것')
-})

package/test/knob-defaults.test.ts

@@ -1,72 +0,0 @@
-/*
- * 노브 기본값 — **알리지 않고 아무것도 안 하는 트윈**이 만들어지지 않게.
- *
- * 기본값을 아는 곳은 노브 스키마(계약)인데 그것을 적용하는 곳이 위자드뿐이었다. 그래서 화면을 거치지
- * 않는 호출자가 파라미터를 일부만 주면 템플릿 안에서 발생률이 0 이 되고, 이벤트를 하나도 만들지 않는
- * 트윈이 아무 말 없이 생겼다(실제로 밟았고 템플릿이 깨진 것으로 오진했다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { applyKnobDefaults, filledKnobKeys } from '../server/service/reference/knob-defaults.ts'
-
-const KNOBS = [
-  { key: 'id', default: 'wms-new' },
-  { key: 'inboundRate', default: 40 },
-  { key: 'outboundRate', default: 30 },
-  { key: 'geo', default: { lat: 37.5, lon: 127.0 } },
-  { key: 'noDefault' } // 기본값을 선언하지 않은 노브
-]
-
-test('빠진 노브를 기본값으로 채운다 — 부분 파라미터 호출이 죽은 트윈을 만들지 않게', () => {
-  const out = applyKnobDefaults(KNOBS, { id: 'mine' })
-  assert.equal(out.id, 'mine', '준 값은 그대로')
-  assert.equal(out.inboundRate, 40)
-  assert.equal(out.outboundRate, 30)
-  assert.deepEqual(out.geo, { lat: 37.5, lon: 127.0 })
-  assert.ok(!('noDefault' in out), '기본값 없는 노브는 만들어 내지 않는다')
-})
-
-test('0 은 덮지 않는다 — "자극 없이 구조만" 이라는 선언을 뒤집지 않게', () => {
-  /* falsy 로 판정해 덮으면 발생률 0(도착 없음)이 40 으로 바뀐다. 없는 것과 0 은 다르다. */
-  const out = applyKnobDefaults(KNOBS, { inboundRate: 0, outboundRate: 0 })
-  assert.equal(out.inboundRate, 0)
-  assert.equal(out.outboundRate, 0)
-})
-
-test('빈 문자열·false 도 뜻 있는 값이라 덮지 않는다', () => {
-  const out = applyKnobDefaults([{ key: 'name', default: 'New site' }, { key: 'flag', default: true }], { name: '', flag: false })
-  assert.equal(out.name, '')
-  assert.equal(out.flag, false)
-})
-
-test('null 은 "주지 않음" 으로 본다 — JSON·GraphQL 경로가 그렇게 보낸다', () => {
-  const out = applyKnobDefaults(KNOBS, { inboundRate: null as any })
-  assert.equal(out.inboundRate, 40)
-})
-
-test('선언 밖 파라미터는 손대지 않는다 — 템플릿의 폴백 경로를 끊지 않게', () => {
-  /* 템플릿은 `geo` 대신 `lat`/`lon` 을 읽는 폴백을 가진다. 모르는 키를 걷어내면 그 경로가 끊긴다. */
-  const out = applyKnobDefaults(KNOBS, { lat: 1, lon: 2 })
-  assert.equal(out.lat, 1)
-  assert.equal(out.lon, 2)
-})
-
-test('입력을 바꾸지 않는다 — 호출자의 객체가 몰래 변하면 추적이 어렵다', () => {
-  const given = { id: 'mine' }
-  applyKnobDefaults(KNOBS, given)
-  assert.deepEqual(given, { id: 'mine' })
-})
-
-test('노브가 없거나 파라미터가 없어도 무너지지 않는다', () => {
-  assert.deepEqual(applyKnobDefaults(null, { a: 1 }), { a: 1 })
-  assert.deepEqual(applyKnobDefaults(KNOBS, null).inboundRate, 40)
-  assert.deepEqual(applyKnobDefaults(undefined, undefined), {})
-})
-
-test('무엇을 채웠는지 알린다 — 준 적 없는 값으로 만들어진 것을 밝히게', () => {
-  assert.deepEqual(filledKnobKeys(KNOBS, { id: 'mine', inboundRate: 0 }), ['outboundRate', 'geo'],
-    '준 것과 0 은 채운 목록에 없다')
-  assert.deepEqual(filledKnobKeys(KNOBS, null), ['id', 'inboundRate', 'outboundRate', 'geo'])
-  assert.deepEqual(filledKnobKeys(KNOBS, { id: 'a', inboundRate: 1, outboundRate: 2, geo: {} }), [], '다 주면 빈 목록')
-})

package/test/kpi-baseline-db.test.ts

@@ -1,216 +0,0 @@
-/*
- * ★ 여러 구간 동시 비교 — **실 DB로 배관을 넘어 본다.**
- *
- * 분포 산수는 `kpi-baseline.test.ts`(순수)가 지킨다. 여기서 지키는 것은 **호스트 배관**이다:
- * 창을 하루씩 뒤로 옮겨 **각 창을 따로 읽는가** · 그 창을 같은 규칙으로 계산하는가 · 지표 값을 정본 표
- * (`TWIN_METRIC`)로 꺼내는가 · 기록 없는 날을 결측으로 남기는가.
- *
- * 이 배관은 **경계를 넘어야만** 틀리는 것이 드러난다. 실제로 앱의 시뮬 트윈은 저널이 두 시간 남짓이라
- * "지난 7일" 을 물어도 과거 창이 모두 비어 있어(정직하게 자리를 거부한다) 분포 경로를 한 번도 밟지
- * 못했다. 그래서 여러 날에 걸친 저널을 손으로 심어 그 경로를 통과시킨다.
- *
- * 실 엔티티·실 네이밍 전략의 sqlite in-memory 스키마에 **빌드 산출물**을 실행한다.
- * **소스를 고친 뒤에는 `npm run build:server` 를 먼저 돌려야 반영된다.**
- */
-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 { computeTwinKpi } = req('../dist-server/engine/index.js')
-const { TwinEvent } = req('../dist-server/service/twin-event/twin-event.js')
-const { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const INSTANCE = 'baseline-probe'
-const MS_DAY = 24 * 60 * 60_000
-
-/** 창의 끝 — 고정 시각을 쓴다(테스트가 벽시계에 흔들리지 않게). */
-const TO = Date.parse('2026-03-10T10:00:00.000Z')
-const FROM = TO - 60 * 60_000
-
-/**
- * 완료 한 건 = 시작 + 완료 두 줄. 소요시간이 짝맞춤에서 나오므로 둘 다 필요하다.
- * 완료 시각이 창 안에 들면 그 창의 성과로 센다.
- */
-function taskRows(dayBack: number, count: number, workMs: number, revBase: number) {
-  const rows: any[] = []
-  const endBase = TO - dayBack * MS_DAY - 60_000 // 창 끝 1분 전에 완료
-  for (let i = 0; i < count; i++) {
-    const taskId = `t-${dayBack}-${i}`
-    const done = endBase - i * 1000
-    const started = done - workMs
-    rows.push(
-      {
-        domain: { id: domainId },
-        instanceId: INSTANCE,
-        revision: revBase + i * 2,
-        eventType: 'task.status',
-        eventTime: new Date(started).toISOString(),
-        payload: { data: { taskId, status: 'in-progress', resourceRef: 'fk-1' } }
-      },
-      {
-        domain: { id: domainId },
-        instanceId: INSTANCE,
-        revision: revBase + i * 2 + 1,
-        eventType: 'task.status',
-        eventTime: new Date(done).toISOString(),
-        /* 완료 어휘는 **커널이 소유한다**(`foldTaskRecords`) — 'done' 이 아니라 'completed' 다.
-           처음에 'done' 으로 심었더니 창은 잡히는데 건수가 0 이었다(이 DB 스펙이 그것을 잡았다). */
-        payload: { data: { taskId, status: 'completed', resourceRef: 'fk-1' } }
-      }
-    )
-  }
-  return rows
-}
-
-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: 'baseline-test', subdomain: 'baseline-test' } as any)
-  domainId = d.id
-
-  await ds.getRepository(TwinInstance).save({
-    domain: { id: domainId },
-    instanceId: INSTANCE,
-    kind: 'wms',
-    restartPolicy: 'reset', /* 선언은 이제 필수 — 비워 두면 읽는 자리마다 기본값을 고른다 */
-    purpose: 'operational',
-    status: 'stopped',
-    model: { locations: [{ id: 'dock', type: 'dock', capacity: 10 }], equipment: [{ id: 'fk-1', kind: 'forklift', homeLocation: 'dock' }] }
-  } as any)
-
-  /*
-   * 지금 창 20건 · 어제 40건 · 그제 60건 · **3일 전은 기록 없음** · 4일 전 80건.
-   * 3일 전을 비워 두는 것이 이 스펙의 요점이다 — 그 날이 결측으로 남고 분포에서 빠지는지 본다
-   * (알리지 않고 빼면 "지난 4일" 이 실제로는 3일이었다는 것을 아무도 모른다).
-   */
-  const rows = [
-    ...taskRows(0, 20, 30_000, 1000),
-    ...taskRows(1, 40, 40_000, 3000),
-    ...taskRows(2, 60, 50_000, 6000),
-    ...taskRows(4, 80, 60_000, 9000)
-  ]
-  await ds.getRepository(TwinEvent).save(rows)
-})
-
-after(async () => {
-  await ds?.destroy()
-})
-
-const kpi = (periods: number, stride?: 'day' | 'week') =>
-  computeTwinKpi({
-    domainId,
-    instanceId: INSTANCE,
-    fromTime: new Date(FROM).toISOString(),
-    toTime: new Date(TO).toISOString(),
-    baseline: { periods, ...(stride ? { stride } : {}) }
-  })
-
-test('과거 창을 하루씩 따로 읽어 분포를 만든다', async () => {
-  const out: any = await kpi(4)
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-
-  assert.equal(out.baseline.stride, 'day')
-  assert.equal(out.baseline.periods, 4)
-  assert.equal(tasks.current, 20, '지금 창')
-  /* 어제 40 · 그제 60 · 3일 전 없음 · 4일 전 80. */
-  assert.deepEqual([tasks.min, tasks.median, tasks.max], [40, 60, 80])
-})
-
-test('기록 없는 날을 **결측으로 남긴다** — 요청한 창 수와 측정된 수를 함께 답한다', async () => {
-  const out: any = await kpi(4)
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-
-  assert.equal(tasks.requested, 4)
-  assert.equal(tasks.measuredCount, 3, '3일 전은 기록이 없다')
-  assert.equal(tasks.samples.length, 4, '창 자체는 네 개 모두 돌려준다')
-  assert.deepEqual(tasks.samples.map((s: any) => s.measured), [true, true, false, true])
-  assert.deepEqual(tasks.samples.map((s: any) => s.value), [40, 60, undefined, 80])
-})
-
-test('처리량이 지난 며칠 중 가장 낮으면 worst — 이 축이 답하려던 질문', async () => {
-  /* 예전에는 "어제보다 나아졌나" 까지만 답할 수 있었다. 지금 창(20)은 어제(40)보다도 낮고
-     최근 어느 날보다도 낮다 — 그것을 한 번에 말할 수 있어야 한다. */
-  const out: any = await kpi(4)
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-
-  assert.equal(tasks.standing, 'worst')
-  assert.equal(tasks.rank, 1, '오름차순 첫째')
-  assert.equal(tasks.rankOf, 4, '표본 3 + 현재 1')
-})
-
-test('방향은 지표가 안다 — 작업시간이 가장 짧으면 best', async () => {
-  const out: any = await kpi(4)
-  const work = out.baseline.metrics.find((m: any) => m.metric === 'workTime.p50Ms')
-
-  assert.equal(work.current, 30_000)
-  assert.deepEqual([work.min, work.max], [40_000, 60_000])
-  assert.equal(work.standing, 'best', '짧을수록 좋다')
-})
-
-test('구간 수를 줄이면 그만큼만 본다 — 창을 지어내지 않는다', async () => {
-  const out: any = await kpi(1)
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-
-  assert.equal(tasks.requested, 1)
-  assert.equal(tasks.measuredCount, 1)
-  /* 표본 하나는 분포가 아니다. */
-  assert.equal(tasks.noPosition, 'too-few-samples')
-  assert.equal(tasks.standing, undefined)
-})
-
-test('주 단위는 같은 요일을 본다 — 하루 전 기록에 걸리지 않는다', async () => {
-  const out: any = await kpi(2, 'week')
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-
-  assert.equal(out.baseline.stride, 'week')
-  /* 심어 둔 기록은 최근 나흘뿐이라 지난주 같은 요일에는 아무것도 없다 — 지어내지 않는다. */
-  assert.equal(tasks.measuredCount, 0)
-  assert.equal(tasks.noPosition, 'too-few-samples')
-})
-
-test('요청하지 않으면 분포를 만들지 않는다 — 조회가 공짜가 아니다', async () => {
-  const out: any = await computeTwinKpi({
-    domainId,
-    instanceId: INSTANCE,
-    fromTime: new Date(FROM).toISOString(),
-    toTime: new Date(TO).toISOString()
-  })
-
-  assert.equal(out.baseline, undefined)
-})
-
-test('지금 창에 기록이 없어도 분포는 낸다 — 그때가 가장 알고 싶은 순간이다', async () => {
-  /* 심어 둔 기록이 없는 시각을 창으로 잡는다(3일 전). 평소엔 일이 있었는데 지금 없다 = 멈춘 신호. */
-  const quietTo = TO - 3 * MS_DAY
-  const out: any = await computeTwinKpi({
-    domainId,
-    instanceId: INSTANCE,
-    fromTime: new Date(quietTo - 60 * 60_000).toISOString(),
-    toTime: new Date(quietTo).toISOString(),
-    baseline: { periods: 2 }
-  })
-
-  assert.equal(out.measured, false, '지금 창에는 측정할 기록이 없다')
-  assert.ok(out.baseline, '그래도 분포는 낸다')
-  const tasks = out.baseline.metrics.find((m: any) => m.metric === 'throughput.tasks')
-  assert.equal(tasks.measuredCount, 1, '4일 전 하루만 걸린다(5일 전은 기록 없음)')
-  assert.equal(tasks.samples.find((s: any) => s.measured).value, 80)
-})