@things-factory/headless-twin 10.1.277 → 10.1.279

package/test/log-stamp.test.ts

@@ -1,59 +0,0 @@
-/*
- * 로그에 **시각이 있다** — 그리고 어떤 인자도 버리지 않는다 (2026-08-22).
- *
- * 루프가 55초 막힌 것을 계기로 알아냈는데 그 시각에 무슨 일이 있었는지 로그에서 찾을 수 없었다.
- * 트윈의 줄이 `console.log` 로 나가 시각이 없었기 때문이다. 이 시험이 지키는 것:
- *  ① 형식 — 프레임워크 줄과 같은 모양, **밀리초까지**(계기의 값이 epoch ms 다)
- *  ② 지역 시각 — 프레임워크의 다른 줄과 같은 기준(UTC 로 찍으면 나란히 읽을 수 없다)
- *  ③ 인자를 버리지 않는다 — 오류는 스택까지(`console.error(msg, err)` 로 쓰던 자리가 많다)
- *  ④ 트윈 소스에 `console.` 직접 호출이 남지 않는다 — 하나라도 남으면 그 줄만 시각이 없다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync, readdirSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { line, stamp } from '../server/engine/log.ts'
-
-test('시각은 밀리초와 오프셋까지 적는다 — 같은 초 안의 순서를 가릴 수 있게', () => {
-  const s = stamp(new Date(2026, 7, 22, 5, 54, 12, 345))
-  assert.match(s, /^2026-08-22T05:54:12\.345[+-]\d\d:\d\d$/, `형식이 다르다: ${s}`)
-})
-
-test('지역 시각으로 적는다 — 프레임워크의 다른 줄과 같은 기준', () => {
-  const at = new Date(2026, 0, 2, 3, 4, 5, 6)
-  const s = stamp(at)
-  assert.ok(s.startsWith('2026-01-02T03:04:05.006'), `지역 시각이 아니다: ${s}`)
-})
-
-test('오류는 스택까지 남는다 — 「어디서 났나」를 잃지 않게', () => {
-  const err = new Error('불이 났다')
-  const out = line(['[twin-engine] 저장 실패', err])
-  assert.ok(out.includes('[twin-engine] 저장 실패'))
-  assert.ok(out.includes('불이 났다'))
-  assert.ok(out.includes('log-stamp.test'), '스택이 있어야 어느 자리에서 났는지 알 수 있다')
-})
-
-test('값이 없어도 있었다는 사실은 남긴다 — 알리지 않고 지우지 않는다', () => {
-  assert.equal(line(['a', undefined, null, 0]), 'a undefined null 0')
-  const circular: any = { name: 'ㄱ' }
-  circular.self = circular
-  assert.ok(line(['보고', circular]).startsWith('보고 '), '순환 참조에도 줄이 남아야 한다')
-})
-
-test('트윈 소스에 console 직접 호출이 남아 있지 않다 — 한 줄이라도 남으면 그 줄만 시각이 없다', () => {
-  const root = fileURLToPath(new URL('../server/', import.meta.url))
-  const offenders: string[] = []
-  const walk = (dir: string) => {
-    for (const e of readdirSync(dir, { withFileTypes: true })) {
-      const p = dir + e.name
-      if (e.isDirectory()) walk(p + '/')
-      else if (e.name.endsWith('.ts') && e.name !== 'log.ts') {
-        const src = readFileSync(p, 'utf-8')
-        for (const m of src.matchAll(/console\.(log|warn|error)\(/g)) offenders.push(`${p.slice(root.length)}  console.${m[1]}`)
-      }
-    }
-  }
-  walk(root)
-  assert.deepEqual(offenders, [], `시각 없는 로그가 남아 있다 — twinLog·twinWarn·twinError 를 쓴다:\n  ${offenders.join('\n  ')}`)
-})

package/test/loop-lag.test.ts

@@ -1,82 +0,0 @@
-/*
- * 루프 지체 계기 — **원인을 지어내지 않기 위한 값**이 정확한지 본다 (2026-08-21).
- *
- * 지키는 것:
- *  ① 늦게 깨어난 만큼만 지체다 — 제때 깨어난 표본은 0 이고, 0 을 정체로 세지 않는다.
- *  ② 창이 닫히기 전에는 `recent` 가 **null** 이다(채우는 중인 창을 「지금」으로 읽으면 과소 집계다).
- *  ③ 가장 길게 막힌 **시각**을 든다 — 언제였는지가 원인을 가리는 근거다.
- *  ④ 문턱 이하의 흔들림은 정체로 세지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { LoopLagSampler } from '../server/engine/loop-lag.ts'
-
-/** 시계를 손으로 밀어 넣는다 — 실제 타이머로 재면 기계 상태가 결과를 정한다. */
-function sampler(sampleMs = 500, stallMs = 200, windowMs = 10_000) {
-  let now = 1_000_000
-  const s = new LoopLagSampler(sampleMs, stallMs, windowMs, () => now)
-  return { s, advance: (ms: number) => (now += ms), at: () => now }
-}
-
-test('제때 깨어난 표본은 지체가 0 이고 정체로 세지 않는다', () => {
-  const { s, advance, at } = sampler()
-  for (let i = 0; i < 4; i++) {
-    advance(500)
-    assert.equal(s.sample(at()), 0)
-  }
-  assert.equal(s.view().total.stalls, 0)
-  assert.equal(s.view().total.maxMs, 0)
-  assert.equal(s.view().total.samples, 4)
-})
-
-test('늦게 깨어난 만큼이 지체다 — 그 초과분만', () => {
-  const { s, advance, at } = sampler()
-  advance(500)
-  s.sample(at())
-  advance(4_600) // 예정보다 4,100ms 늦게
-  assert.equal(s.sample(at()), 4_100)
-  assert.equal(s.view().total.maxMs, 4_100)
-  assert.equal(s.view().total.stalls, 1)
-})
-
-test('문턱 이하의 흔들림은 정체가 아니다 — 값은 남기고 세지는 않는다', () => {
-  const { s, advance, at } = sampler(500, 200)
-  advance(650) // 150ms 지체 — 문턱 200 미만
-  s.sample(at())
-  const v = s.view()
-  assert.equal(v.total.maxMs, 150)
-  assert.equal(v.total.stalls, 0, '문턱 이하를 세면 정상 상태가 정체로 보인다')
-})
-
-test('창이 닫히기 전에는 recent 가 null 이다 — 채우는 중인 창을 「지금」으로 읽지 않는다', () => {
-  const { s, advance, at } = sampler(500, 200, 2_000)
-  advance(500)
-  s.sample(at())
-  assert.equal(s.view().recent, null)
-
-  /* 창 길이를 넘기면 그 창이 닫혀 `recent` 가 된다. */
-  advance(2_000)
-  s.sample(at())
-  const v = s.view()
-  assert.ok(v.recent, '창 길이를 넘겼으면 닫힌 창이 있어야 한다')
-  assert.equal(v.recent!.stalls, 1, '1,500ms 지체는 정체 한 번이다')
-})
-
-test('가장 길게 막힌 시각을 든다 — 언제였는지가 원인을 가린다', () => {
-  const { s, advance, at } = sampler()
-  advance(500)
-  s.sample(at())
-  advance(3_000)
-  const worst = at()
-  s.sample(worst)
-  advance(500)
-  s.sample(at())
-  assert.equal(s.view().worstAtMs, worst)
-})
-
-test('한 번도 재지 않았으면 정체 시각은 null 이다 — 0 으로 적지 않는다', () => {
-  const { s } = sampler()
-  assert.equal(s.view().worstAtMs, null)
-  assert.equal(s.view().recent, null)
-})

package/test/master-to-twin.test.ts

@@ -1,279 +0,0 @@
-/*
- * masterToTwin — 모델→model 토폴로지 변환 시임. 템플릿/레퍼런스 master → model{locations,equipment,layout,spaceId}+space.
- * 스트림라인의 "모델링→board" 연결부: 템플릿(build)이 낸 master 를 커널이 소비할 TwinModelDef 로 바꾼다.
- * role(location/area/both) 분기·footprint→layout·spaceId 파생·미지 타입 경고를 고정.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-import { DOMAIN_CATALOG } from '@operato/ops-contract'
-
-/** WMS 단위적재 템플릿이 내는 것과 동형인 현실적 master(coordinate-free). */
-const wmsMaster = () => ({
-  source: 'wh-seoul',
-  system: 'wms' as const,
-  siteName: '서울 창고',
-  space: { width: 90, depth: 40, unit: 'm', geo: { lat: 37.5, lon: 127.0, rotation: 0 } },
-  locations: [
-    { id: 'a-dc', type: 'warehouse', role: 'area' as const, name: '창고' },
-    { id: 'dock-recv', type: 'dock', role: 'location' as const, name: '입고 도크', capacity: 100 },
-    { id: 'rack-1', type: 'storage', role: 'location' as const, name: '랙1', parentId: 'a-dc', capacity: 60 },
-    { id: 'rack-2', type: 'storage', role: 'location' as const, name: '랙2', parentId: 'a-dc', capacity: 60 },
-    { id: 'dock-ship', type: 'dock-ship', role: 'location' as const, name: '출고 도크', capacity: 100 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv' }]
-})
-
-test('locations role → 노드/영역 분기, equipment → 무버', () => {
-  const { model, spaceContent } = masterToTwin(wmsMaster())
-  assert.deepEqual(model.locations.map((n: any) => n.id).sort(), ['dock-recv', 'dock-ship', 'rack-1', 'rack-2'], '노드=role location')
-  assert.equal(spaceContent.areas.length, 1, '영역=role area')
-  assert.equal(spaceContent.areas[0].id, 'a-dc')
-  assert.deepEqual(model.equipment, [{ id: 'fk-1', kind: 'forklift', homeLocation: 'dock-recv', mtbfMs: undefined, mttrMs: undefined }], '마스터 equipment→보드 equipment(homeLocationId→homeLocation, identity 통과)')
-  assert.equal(model.locations.find((n: any) => n.id === 'rack-1').capacity, 60, 'capacity 전달')
-  assert.equal(model.locations.find((n: any) => n.id === 'dock-recv').parentId, undefined, 'parentId 없으면 undefined')
-})
-
-test('coordinate-free: footprint 없으면 layout 비어있음(미배치 → A2)', () => {
-  const { model } = masterToTwin(wmsMaster())
-  assert.deepEqual(model.layout, {}, '좌표 없는 master → layout {}')
-})
-
-test('footprint 있으면 layout = 중심좌표', () => {
-  const m = wmsMaster()
-  ;(m.locations[1] as any).footprint = { x: 10, y: 20, w: 4, h: 6 } // dock-recv
-  const { model } = masterToTwin(m)
-  assert.deepEqual(model.layout['dock-recv'], { x: 12, y: 23 }, '중심 = x+w/2, y+h/2')
-  assert.equal(model.layout['rack-1'], undefined, 'footprint 없는 노드는 layout 없음')
-})
-
-test('spaceId: 명시 시 참조, 없으면 source 파생 (공동배치 시임)', () => {
-  assert.equal(masterToTwin(wmsMaster()).model.spaceId, 'wh-seoul-site', '없으면 {source}-site')
-  const shared = wmsMaster()
-  ;(shared.space as any).spaceId = 'rosarito-site'
-  assert.equal(masterToTwin(shared).model.spaceId, 'rosarito-site', '명시 시 공유(다시스템 co-location)')
-})
-
-test('미지 노드 타입 경고 — 카탈로그 있으면 검증(버리진 않음)', () => {
-  const m = wmsMaster()
-  ;(m.locations as any).push({ id: 'weird', type: '__unknown__', role: 'location', capacity: 1 })
-  const withCat = masterToTwin(m, DOMAIN_CATALOG)
-  /* 경고는 프로즈가 아니라 **코드+파라미터**다(화면이 다섯 언어로 렌더한다) — 문구가 아니라 계약을 본다. */
-  assert.ok(
-    withCat.warnings.some(w => w.code === 'unknown-location-type' && w.params?.type === '__unknown__'),
-    `미지 타입 경고: ${JSON.stringify(withCat.warnings)}`
-  )
-  assert.ok(withCat.model.locations.some((n: any) => n.id === 'weird'), '경고해도 노드는 유지(반영 우선)')
-  // 정상 타입만이면 경고 0
-  assert.equal(masterToTwin(wmsMaster(), DOMAIN_CATALOG).warnings.length, 0, '알려진 타입만 → 경고 0')
-  // 카탈로그 없으면 검증 생략
-  assert.equal(masterToTwin(m).warnings.length, 0, '카탈로그 미제공 → 경고 생략')
-})
-
-test("role 'both' 는 노드·영역 양쪽에 등장(도크 도어 등)", () => {
-  const m = wmsMaster()
-  ;(m.locations as any).push({ id: 'dock-door-1', type: 'dock-door', role: 'both', name: '도어1', capacity: 1 })
-  const { model, spaceContent } = masterToTwin(m)
-  assert.ok(model.locations.some((n: any) => n.id === 'dock-door-1'), 'both → 노드')
-  assert.ok(spaceContent.areas.some((a: any) => a.id === 'dock-door-1'), 'both → 영역')
-})
-
-test('space content: 크기·geo·표현 전달', () => {
-  const { spaceContent } = masterToTwin(wmsMaster())
-  assert.equal(spaceContent.width, 90)
-  assert.equal(spaceContent.depth, 40)
-  assert.equal(spaceContent.unit, 'm')
-  assert.equal(spaceContent.geo.lat, 37.5)
-})
-
-test('현장 물질화(#4): 표현 없고 geo 있으면 기본 map 표현 합성 — "알아볼 현장" 보장', () => {
-  const { spaceContent } = masterToTwin(wmsMaster()) // wmsMaster = geo 있고 representations 없음
-  assert.equal(spaceContent.representations.length, 1, '기본 표현 1개 합성')
-  const r = spaceContent.representations[0]
-  assert.equal(r.type, 'map', 'map 표현')
-  assert.equal(r.primary, true)
-  assert.deepEqual(r.center, { lat: 37.5, lon: 127.0 }, 'geo 로 센터')
-  assert.equal(spaceContent.primaryId, r.id, 'primaryId = 합성 표현')
-})
-
-test('현장 물질화(#4): master 가 표현을 주면 보존(합성 안 함)', () => {
-  const m: any = wmsMaster()
-  m.space.representations = [{ id: 'r-board', type: 'board', primary: true, boardId: 'b1' }]
-  const { spaceContent } = masterToTwin(m)
-  assert.equal(spaceContent.representations.length, 1)
-  assert.equal(spaceContent.representations[0].type, 'board', '주어진 표현 보존(덮어쓰지 않음)')
-})
-
-test('현장 물질화(#4): 표현도 geo 도 없으면 빈 표현 + 경고(정직)', () => {
-  const m: any = wmsMaster()
-  m.space.geo = undefined
-  const { spaceContent, warnings } = masterToTwin(m)
-  assert.equal(spaceContent.representations.length, 0, '합성 불가')
-  assert.ok(
-    warnings.some(w => w.code === 'no-viewable-representation'),
-    '뷰 없는 공간 경고 표면화'
-  )
-})
-
-/* ── 공정 명세 통과 (ISA-95 OperationsSegment) ──────────────────────────────
- *
- * 시뮬레이션의 소요·수율이 커널 상수였던 것을 데이터로 옮기는 경로의 마지막 한 칸: 마스터가 명세를
- * 말하면 model 를 통해 커널까지 **손대지 않고** 간다. 기간은 표준 표기(ISO 8601)로 그대로 흐른다 —
- * 여기서 밀리초로 바꾸면 표준과 어긋나고, 커널이 다시 해석할 기회를 잃는다.
- */
-const mesMaster = () => ({
-  source: 'plant-1',
-  system: 'mes' as const,
-  siteName: '공장',
-  space: { width: 100, depth: 50, geo: { lat: 32.3, lon: -117.0 } },
-  locations: [
-    { id: 'a-prod', type: 'factory', role: 'area' as const, name: '생산' },
-    { id: 'cut-1', type: 'cut-station', role: 'location' as const, name: '절단', capacity: 4 }
-  ],
-  equipment: [{ id: 'mch-1', kind: 'cutter', homeLocationId: 'cut-1' }],
-  operations: [
-    {
-      key: 'cut', label: 'cutting', intent: 'process' as const, locationType: 'cut-station', resourceType: 'cutter',
-      duration: 'PT25M',
-      variability: { distribution: 'triangular' as const, min: 'PT20M', max: 'PT35M', mode: 'PT24M' },
-      parameters: [{ id: 'yield', value: '0.995' }]
-    }
-  ]
-})
-
-test('공정 명세가 model 로 그대로 통과한다 — 표준 표기 유지, 값 변형 없음', () => {
-  const { model, warnings } = masterToTwin(mesMaster(), DOMAIN_CATALOG)
-  assert.equal((model as any).operations.length, 1)
-  const op = (model as any).operations[0]
-  assert.equal(op.duration, 'PT25M', 'ISO 8601 기간을 밀리초로 바꾸지 않는다')
-  assert.deepEqual(op.variability, { distribution: 'triangular', min: 'PT20M', max: 'PT35M', mode: 'PT24M' })
-  assert.deepEqual(op.parameters, [{ id: 'yield', value: '0.995' }])
-  assert.equal(warnings.length, 0)
-})
-
-test('명세를 전달하지 않으면 키를 만들지 않는다 — 빈 배열을 "선언했다" 로 보고하지 않는다', () => {
-  const { model } = masterToTwin(wmsMaster(), DOMAIN_CATALOG)
-  assert.equal('operations' in (model as any), false)
-})
-
-test('내용 없는 명세는 경고한다 — 선언했는데 아무 말도 하지 않는 명세는 침묵하지 않는다', () => {
-  const m: any = mesMaster()
-  m.operations = [{ key: 'cut', label: 'cutting', intent: 'process' }]
-  const { warnings } = masterToTwin(m, DOMAIN_CATALOG)
-  assert.ok(
-    warnings.some(w => w.code === 'operation-without-duration' && w.params?.operation === 'cut'),
-    `기본값으로 굴러갈 것을 알린다: ${JSON.stringify(warnings)}`
-  )
-})
-
-/* ── 처리 능력·교대 통과 ─────────────────────────────────────────────────
- *
- * `capacity` 한 필드가 저장 용량과 처리 능력을 겸하던 것을 갈랐다. 인제스트도 두 축을 따로 실어야
- * 커널이 "20개를 쌓아 두지만 한 번에 한 대만 깎는다" 를 표현할 수 있다. 교대도 같다.
- */
-test('처리 능력과 교대가 model 로 통과한다 — 저장 용량과 섞이지 않는다', () => {
-  const m: any = mesMaster()
-  m.locations[1].parallelism = 1 // cut-1: 저장 4, 동시 처리 1
-  m.equipment[0].window = { startHour: 8, endHour: 18 }
-  const { model } = masterToTwin(m, DOMAIN_CATALOG)
-  const location = (model as any).locations.find((n: any) => n.id === 'cut-1')
-  assert.equal(location.capacity, 4, '저장 용량')
-  assert.equal(location.parallelism, 1, '처리 능력 — 다른 축')
-  assert.deepEqual((model as any).equipment[0].window, { startHour: 8, endHour: 18 })
-})
-
-test('선언하지 않으면 키를 만들지 않는다 — 미지정과 0 을 같게 다루지 않는다', () => {
-  const { model } = masterToTwin(mesMaster(), DOMAIN_CATALOG)
-  const location = (model as any).locations.find((n: any) => n.id === 'cut-1')
-  assert.equal('parallelism' in location, false)
-  assert.equal('window' in (model as any).equipment[0], false)
-})
-
-/*
- * ★ **이름이 첫 문에서 사라지고 있었다.**
- *
- * 인제스트가 자리·설비·사람·자산을 보드로 옮길 때 `name` 을 빼고 있었다. 그러면 모델에도 없고,
- * 모델에서 그리는 투영 행에도 없으므로 **어떤 화면도 이름을 만들 수 없다** — 목록·표·관계 그림이
- * 전부 `cut-station` 같은 id 를 찍었다. 표면마다 따로 나타나지만 결함은 이 한 자리다.
- *
- * 업무키를 따로 두는 설계(식별자는 원본이 정한다)에서는 **이름을 함께 싣는 것이 그 설계의 절반**이다.
- * 나누기만 하고 이름을 빼면 화면에 남는 것은 id 뿐이다.
- */
-test('이름이 보드로 통과한다 — 업무키를 나눈 설계의 나머지 절반', () => {
-  const m: any = mesMaster()
-  m.locations[1].name = '프레임 절단'
-  m.equipment[0].name = '절단기 1호'
-  const { model } = masterToTwin(m, DOMAIN_CATALOG)
-  const location = (model as any).locations.find((n: any) => n.id === 'cut-1')
-  assert.equal(location.name, '프레임 절단', '자리 이름이 모델에 실려야 한다')
-  assert.equal((model as any).equipment[0].name, '절단기 1호', '설비 이름이 모델에 실려야 한다')
-})
-
-test('이름 없는 원본은 이름 없이 통과한다 — id 를 이름으로 베끼지 않는다', () => {
-  const m: any = mesMaster()
-  delete m.locations[1].name // 이름을 말하지 않는 원본
-  const { model } = masterToTwin(m, DOMAIN_CATALOG)
-  const location = (model as any).locations.find((n: any) => n.id === 'cut-1')
-  /* 키 자체를 만들지 않는다: id 를 넣어 두면 "이름이 있다" 가 거짓이 되고, 화면은 이름 없음을
-     알아볼 수 없게 된다(그러면 "이름을 지어 주세요" 라고 말할 수도 없다). */
-  assert.equal('name' in location, false, '원본이 이름을 말하지 않았으면 키가 없어야 한다')
-})
-
-/*
- * ★ 검사 명세가 모델로 통과한다 — **참조가 가리킬 대상이 실린다.**
- *
- * 자원은 예전부터 `testSpecificationIds` 로 시험을 가리킬 수 있었지만 가리켜지는 대상이 없었다. 인제스트가
- * 명세를 흘리면 축이 서 있어도 여전히 허공을 가리킨다 — 그래서 이 문에서 통과를 못 박는다.
- *
- * 표시명은 `name` 으로 옮긴다(등급과 같은 규칙) — 그러지 않으면 화면의 "설명" 열에 이름이 앉는다.
- */
-test('검사 명세가 모델로 통과한다 — 표시명은 name 으로', () => {
-  const m: any = mesMaster()
-  m.testSpecifications = [{ id: 'weld-cert', description: 'twin.x.test.weld', version: '2026.1' }]
-  const { model } = masterToTwin(m, DOMAIN_CATALOG) as any
-  const specs = (model as any).testSpecifications
-  assert.equal(specs?.length, 1, '명세가 모델에 실려야 한다')
-  assert.equal(specs[0].id, 'weld-cert')
-  assert.equal(specs[0].name, 'twin.x.test.weld', '표시명은 name 자리에 온다(어휘를 하나로)')
-  assert.equal('description' in specs[0], false, '두 자리에 같은 값을 두지 않는다')
-  assert.equal(specs[0].version, '2026.1', '버전이 남아야 한다 — 어느 버전으로 검증했나')
-})
-
-test('선언하지 않으면 키를 만들지 않는다 — 빈 배열을 "선언했다" 로 보고하지 않는다', () => {
-  const { model } = masterToTwin(mesMaster(), DOMAIN_CATALOG) as any
-  assert.equal('testSpecifications' in (model as any), false)
-})
-
-/*
- * ── 자리의 속성이 커널까지 간다 (2026-08-14, EMS 4단계) ─────────────────────
- *
- * 에너지 커널은 계약전력을 **자리 속성**(`contract.kW`)에서 읽고, 없으면 계약 대비 판정을 아예
- * 하지 않는다. 그래서 이 통과가 끊기면 결과가 「오류 없이 판정만 사라지는」 모양이 된다 — 화면에는
- * 트윈이 정상으로 보이고 피크 경고만 영원히 오지 않는다. 눈으로는 보이지 않는 부류다.
- *
- * 실제로 처음에는 끊겨 있었다(타입만 열고 변환을 잇지 않았다).
- */
-test('자리의 속성을 모델로 통과시킨다 — 계약전력이 커널에 닿는 유일한 길', () => {
-  const m = {
-    source: 'ems-1',
-    system: 'ems' as const,
-    siteName: '공장',
-    space: { width: 10, depth: 10 },
-    locations: [
-      {
-        id: 'incoming-1',
-        type: 'incoming',
-        role: 'location' as const,
-        capacity: 0,
-        properties: [{ id: 'contract.kW', value: '4000', dataType: 'xs:double', uom: 'KWT' }]
-      },
-      { id: 'feeder-1', type: 'feeder', role: 'location' as const, capacity: 0 }
-    ]
-  }
-  const { model } = masterToTwin(m as any)
-  const incoming = model.locations.find((l: any) => l.id === 'incoming-1') as any
-  assert.deepEqual(incoming.properties, m.locations[0].properties, '손대지 않고 나른다')
-  const feeder = model.locations.find((l: any) => l.id === 'feeder-1') as any
-  assert.equal('properties' in feeder, false, '없는 것을 빈 배열로 만들지 않는다(모름과 없음을 섞지 않는다)')
-})

package/test/measured-yield.test.ts

@@ -1,90 +0,0 @@
-/*
- * 실측 양품률 — **이력에서 배운 수율이 선언값·상수를 이긴다.**
- *
- * ── 왜 (2026-08-19) ─────────────────────────────────────────────────────────
- * 소요시간에는 이력 층이 있었는데 수율에는 없었다. 양품률 기본값은 커널 소스의 상수(0.8)였고 **그 상수가
- * 불량 과다 주목 신호까지 만들었다.** 이제 커널이 판정을 작업 완료에 적고(`outcome`), 폴드가 축으로 들고,
- * KPI 가 종류별로 세고(`quality`), 이 모듈이 비율로 바꿔 커널 시임에 넣는다.
- *
- * 이 시험이 지키는 것:
- *  ① 분모는 **판정된 것만** — 이동·체류를 섞으면 양품률이 낮게 나온다.
- *  ② 표본이 모자라면 **배우지 않는다** — 비율은 드문 사건을 재는 값이라 작은 표본이 잡음을 만든다.
- *  ③ 0 도 사실이다 — 전량 불량이면 0 을 배운다(「값이 없다」와 다르다).
- *  ④ 모르는 종류에는 `undefined` — 그러면 커널이 선언값·상수로 내려간다.
- *  ⑤ 배우지 못한 것을 **밝힌다** — 알리지 않고 일부만 반영하지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { buildYieldEstimator, DEFAULT_YIELD_MIN_SAMPLES } from '../server/engine/measured-yield.ts'
-
-const group = (key: string, good: number, scrap: number) => ({ key, quality: { good, scrap } })
-
-test('판정된 것만 분모다 — 이동·체류가 섞이지 않는다', () => {
-  /* tasks 는 1000 건이어도 판정은 40 건뿐인 종류가 정상이다(중간 스테이션은 품질을 가리지 않는다). */
-  const r = buildYieldEstimator([{ key: 'assembly', tasks: 1000, quality: { good: 36, scrap: 4 } } as any])
-  assert.equal(r.learned.assembly, 0.9, '36/40 = 0.9')
-  assert.deepEqual(r.samples.assembly, { good: 36, scrap: 4 })
-})
-
-test('표본이 모자라면 배우지 않고 그 사실을 낸다 — 세 건 중 한 건 불량은 33% 가 아니다', () => {
-  const r = buildYieldEstimator([group('weld', 2, 1)])
-  assert.deepEqual(r.learned, {})
-  assert.deepEqual(r.skipped, [{ kind: 'weld', judged: 3 }])
-  assert.equal(r.estimator, undefined, '배운 것이 없으면 시임을 만들지 않는다')
-  assert.equal(r.minSamples, DEFAULT_YIELD_MIN_SAMPLES)
-})
-
-test('하한은 소요보다 높다 — 비율은 드문 사건을 재는 값이다', () => {
-  /* 불량률 5% 인 공정은 20건에서 불량이 한 건이다 — 그 아래로 내려가면 이력이 잡음이 된다. */
-  assert.ok(DEFAULT_YIELD_MIN_SAMPLES >= 20, `하한이 ${DEFAULT_YIELD_MIN_SAMPLES} 이면 비율에 너무 낮다`)
-})
-
-test('전량 불량은 0 을 배운다 — 「값이 없다」와 구별한다', () => {
-  const r = buildYieldEstimator([group('paint', 0, 25)])
-  assert.equal(r.learned.paint, 0)
-  assert.equal(r.estimator!.estimate({ kind: 'paint' }), 0, '0 을 답한다(undefined 로 뭉개지 않는다)')
-})
-
-test('판정이 아예 없는 종류는 건너뛴 것이 아니다 — 품질을 가리지 않는 공정이 정상이다', () => {
-  const r = buildYieldEstimator([{ key: 'putaway', tasks: 500 } as any])
-  assert.deepEqual(r.learned, {})
-  assert.deepEqual(r.skipped, [], '표본 부족으로 세지 않는다')
-})
-
-test('모르는 종류에는 undefined — 커널이 선언값·상수로 내려갈 수 있게', () => {
-  const r = buildYieldEstimator([group('weld', 30, 2)])
-  assert.equal(r.estimator!.estimate({ kind: 'weld' }), 30 / 32)
-  assert.equal(r.estimator!.estimate({ kind: 'paint' }), undefined)
-})
-
-test("'unknown' 축은 쓰지 않는다 — 종류를 모르는 기록을 특정 종류의 근거로 삼지 않는다", () => {
-  const r = buildYieldEstimator([group('unknown', 100, 5)])
-  assert.deepEqual(r.learned, {})
-})
-
-test('빈 입력에도 답을 만든다 — 부르는 쪽이 조건문을 두 벌 갖지 않게', () => {
-  for (const input of [undefined, []]) {
-    const r = buildYieldEstimator(input as any)
-    assert.deepEqual(r.learned, {})
-    assert.equal(r.estimator, undefined)
-  }
-})
-
-/*
- * ── 사슬이 이어져 있나 (소스로 지킨다) ──────────────────────────────────────
- * 이 층은 넷이 이어져야 뜻이 있다: 커널이 판정을 적고 → 폴드가 축으로 들고 → KPI 가 세고 → 여기서 비율.
- * 한 칸만 빠져도 화면은 「이력에서 배운 값」이라고 말하면서 상수로 돈다. 실 앱에서 관측하려면 라인이
- * 한 바퀴 돌아야 하므로(판정은 완료에서 일어난다), 경로는 여기서 지킨다.
- */
-test('사슬 넷이 이어져 있다 — 판정→축→집계→비율', () => {
-  const hostSrc = (f: string) => readFileSync(fileURLToPath(new URL(`../server/${f}`, import.meta.url)), 'utf-8')
-  assert.match(hostSrc('engine/kpi-fold.ts'), /facets\.outcome/, 'KPI 가 판정 축을 읽는다')
-  assert.match(hostSrc('engine/kpi-fold.ts'), /quality\?: \{ good: number; scrap: number \}/, '종류별로 센다')
-  const engine = hostSrc('engine/twin-engine.ts')
-  assert.match(engine, /buildYieldEstimator\(kpi\?\.groups\?\.items/, '같은 폴드에서 배운다(두 번 계산하지 않는다)')
-  assert.match(engine, /kernel\.yieldEstimator = yields\.estimator/, '커널 시임에 넣는다')
-  assert.match(engine, /yieldOf missing/, '옛 커널이면 그 사실을 말한다')
-})

package/test/merge-streams.test.ts

@@ -1,70 +0,0 @@
-/*
- * ★ 나눠 묻고 합치는 규율 — 갈래마다 상한까지 받아야 합친 결과가 정확하다.
- *
- * ── 왜 이 시험이 있나 (2026-08-28) ──────────────────────────────────────────
- * 「종류 IN + 시각순」은 색인을 못 쓴다. 그래서 종류를 하나씩 정확일치로 묻고 합치는데, 그때 함정이
- * 하나 있다 — UX 레인이 구현 전에 짚어 주었다.
- *
- *   「갈래마다 상한을 걸면 합친 결과가 시각순으로 온전하지 않다.
- *     종류 A 의 마지막이 종류 B 의 첫째보다 이를 수 있다.」
- *
- * 그 지적은 **갈래마다 상한보다 적게 받을 때** 참이다. 상한까지 받으면 성질이 선다: 어떤 갈래에서 빠진
- * 행은 그 갈래의 상한 번째보다 뒤이고, 우리는 전체에서 상한 개만 취하므로 그 행이 이 페이지에 들어올 수
- * 없다. 이 시험이 그 성질을 못박는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { mergeStreams } from '../server/service/twin-journal/event-type-split-shape.js'
-
-const byN = (a: { n: number }, b: { n: number }) => a.n - b.n
-const seq = (from: number, count: number) => Array.from({ length: count }, (_, i) => ({ n: from + i }))
-
-test('★ 한 갈래가 앞을 다 차지해도 전체에서 앞 limit 개가 나온다 — 짚어 준 그 경우다', () => {
-  /*
-   * A 가 1~5, B 가 100~104. limit 3 이면 답은 A 의 1,2,3 이다. B 는 한 건도 들어오지 않는 것이 맞다.
-   */
-  const r = mergeStreams([seq(1, 5), seq(100, 5)], 3, byN)
-  assert.deepEqual(r.items.map(x => x.n), [1, 2, 3])
-  assert.equal(r.capped, true, '더 있었다는 사실을 말해야 한다')
-})
-
-test('★ 갈래를 섞어도 시각순이 유지된다', () => {
-  const a = [{ n: 1 }, { n: 4 }, { n: 7 }]
-  const b = [{ n: 2 }, { n: 5 }, { n: 8 }]
-  const c = [{ n: 3 }, { n: 6 }, { n: 9 }]
-  const r = mergeStreams([a, b, c], 9, byN)
-  assert.deepEqual(r.items.map(x => x.n), [1, 2, 3, 4, 5, 6, 7, 8, 9])
-  assert.equal(r.capped, false, '상한에 닿지 않았으면 잘리지 않았다')
-})
-
-test('★ 상한에 닿은 갈래가 있으면 잘렸다고 말한다 — 숫자가 알리지 않고 작아지지 않게', () => {
-  /* 한 갈래가 정확히 상한만큼 받아 왔으면 그 갈래에 더 있었을 수 있다. */
-  const r = mergeStreams([seq(1, 3), seq(10, 1)], 3, byN)
-  assert.equal(r.items.length, 3)
-  assert.equal(r.capped, true)
-})
-
-test('상한에 못 닿았고 합쳐도 상한 미만이면 잘리지 않았다', () => {
-  const r = mergeStreams([seq(1, 2), seq(10, 2)], 10, byN)
-  assert.deepEqual(r.items.map(x => x.n), [1, 2, 10, 11])
-  assert.equal(r.capped, false)
-})
-
-test('빈 갈래가 섞여도 답이 같다 — 그 종류가 그 구간에 없는 것은 정상이다', () => {
-  const r = mergeStreams([[], seq(5, 2), []], 10, byN)
-  assert.deepEqual(r.items.map(x => x.n), [5, 6])
-  assert.equal(r.capped, false)
-})
-
-test('★ 갈래가 상한보다 많이 받아 오면 그 사실을 말한다 — 있을 수 없는 일이다', () => {
-  /* 부르는 쪽이 상한을 잘못 걸었다는 뜻이고, 그 상태로 답하면 합친 결과를 믿을 수 없다. */
-  const r = mergeStreams([seq(1, 5)], 3, byN)
-  assert.equal(r.underfilled, true)
-})
-
-test('갈래가 하나면 그냥 앞에서 자른 것과 같다', () => {
-  const r = mergeStreams([seq(1, 5)], 5, byN)
-  assert.deepEqual(r.items.map(x => x.n), [1, 2, 3, 4, 5])
-  assert.equal(r.underfilled, false)
-})