@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/kpi-query-bench.test.ts

@@ -1,130 +0,0 @@
-/*
- * 구간 성과 질의 비용 측정 — **브로드캐스팅이냐 질의냐를 숫자로 정한다.**
- *
- * ── 왜 재는가 (2026-08-06) ─────────────────────────────────────────────────
- * 성과 카드를 여러 단계(공간·트윈·구역·자리·설비)에 붙이려 한다. 두 방법이 있다.
- *
- *  · 브로드캐스팅 — 서버가 주기마다 전 단계를 계산해 밀어 준다. 자리가 트윈당 최대 200개고 지표가 6개라
- *    태그가 1,200개가 된다. **모델에 카드를 하나도 안 놓아도 계산은 돈다.**
- *  · 질의 — 카드가 필요할 때 묻는다. **모델에 놓인 카드 수만큼만** 든다. 시각(`toTime`)도 물을 수 있어
- *    타임라인과 맞고, 공간 단위 합산(여러 트윈을 한 번에 계산)은 질의에만 있다.
- *
- * 질의로 정하려면 **한 번의 비용**을 알아야 한다. 카드 20장이 30초마다 물으면 감당되는지가 결정을
- * 가른다. 짐작하지 않고 잰다.
- *
- * 빌드 산출물을 실행한다 — **소스를 고친 뒤에는 `npm run build:server` 를 먼저 돌린다.**
- */
-import { test, before, after } from 'node:test'
-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 = 'kpi-bench'
-const TO = Date.parse('2026-03-10T10:00:00.000Z')
-const WINDOW_MIN = 60
-
-/** 자리 200개 — 실측한 최대 규모(트윈당 자리 최대 200, 평균 19). */
-const LOCATIONS = 200
-/** 창 안의 완료 작업 수 — 한 건이 두 줄(시작·완료)이라 이벤트는 두 배가 된다. */
-const TASK_COUNTS = [500, 2_000, 10_000]
-
-function taskRows(count: number, revBase: number) {
-  const rows: any[] = []
-  for (let i = 0; i < count; i++) {
-    const done = TO - 60_000 - (i % (WINDOW_MIN * 60)) * 1000
-    const started = done - 30_000
-    const at = `loc-${i % LOCATIONS}`
-    rows.push(
-      {
-        domain: { id: domainId },
-        instanceId: INSTANCE,
-        revision: revBase + i * 2,
-        eventType: 'task.status',
-        eventTime: new Date(started).toISOString(),
-        payload: { data: { taskId: `t-${i}`, status: 'in-progress', resourceRef: 'fk-1', locationRef: at } }
-      },
-      {
-        domain: { id: domainId },
-        instanceId: INSTANCE,
-        revision: revBase + i * 2 + 1,
-        eventType: 'task.status',
-        eventTime: new Date(done).toISOString(),
-        payload: { data: { taskId: `t-${i}`, status: 'completed', resourceRef: 'fk-1', locationRef: at } }
-      }
-    )
-  }
-  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: 'kpi-bench', subdomain: 'kpi-bench' } as any)
-  domainId = d.id
-
-  /* 자리 계층 — 자리 200개를 구역 4개에 나눠 붙인다(구역 단위 계산 비용도 재려면 부모가 있어야 한다). */
-  const locations = Array.from({ length: LOCATIONS }, (_, i) => ({
-    id: `loc-${i}`,
-    type: 'storage',
-    capacity: 10,
-    parentId: `area-${i % 4}`
-  }))
-  await ds.getRepository(TwinInstance).save({
-    domain: { id: domainId },
-    instanceId: INSTANCE,
-    kind: 'wms',
-    restartPolicy: 'reset', /* 선언은 이제 필수 — 비워 두면 읽는 자리마다 기본값을 고른다 */
-    purpose: 'operational',
-    status: 'stopped',
-    model: { locations, equipment: [{ id: 'fk-1', kind: 'forklift', homeLocation: 'loc-0' }] }
-  } as any)
-})
-
-after(async () => {
-  await ds?.destroy()
-})
-
-const ms = async (fn: () => Promise<any>) => {
-  const t = process.hrtime.bigint()
-  await fn()
-  return Number(process.hrtime.bigint() - t) / 1e6
-}
-
-test('bench: 구간 성과 폴드 한 번의 비용 vs 창 안의 작업 수', async () => {
-  let seeded = 0
-  for (const count of TASK_COUNTS) {
-    await ds.getRepository(TwinEvent).save(taskRows(count - seeded, seeded * 2 + 1000))
-    seeded = count
-
-    const args = { domainId, instanceId: INSTANCE, toTime: new Date(TO).toISOString(), windowMinutes: WINDOW_MIN }
-    await computeTwinKpi(args) // 워밍업(연결·스키마 캐시)
-
-    const plain = await ms(() => computeTwinKpi(args))
-    const byArea = await ms(() => computeTwinKpi({ ...args, groupBy: 'area' }))
-
-    console.log(`  작업 ${count.toLocaleString()}건(이벤트 ${(count * 2).toLocaleString()}줄) · 자리 ${LOCATIONS}개`)
-    console.log(`    폴드 1회        ${plain.toFixed(1)}ms`)
-    console.log(`    구역별 폴드 1회 ${byArea.toFixed(1)}ms`)
-    console.log(`    카드 20장 동시  ${(plain * 20).toFixed(0)}ms (직렬 상한 — 실제로는 한 번 계산해 나눠 쓸 수 있다)`)
-  }
-})

package/test/lens-own-places.test.ts

@@ -1,50 +0,0 @@
-/*
- * **렌즈는 자기 영역의 자리만 세운다** — ADR-0081 보탬(수석 아키텍트 판정 2026-09-24).
- *
- * 사람이 보는 장면: 창고 트윈 miratek-wms 를 불러오면 「종류를 모르는 자리 assembly-line (…00007.0)」 경고가 떴다. 그 자리는 plant 의
- * 조립 라인 자리다. 이제 창고 렌즈는 그 자리를 참조로만 들고 경고하지 않는다. 같은 기준정보를 plant 렌즈로 불러오면 도크가 참조다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-
-const req = createRequire(import.meta.url)
-const { masterToTwin } = req('../dist-server/service/reference/reference-master.js')
-
-const CATALOG = { wms: { locationTypes: ['dock', 'storage'] }, mes: { locationTypes: ['assembly-line'] } }
-const LINE = 'urn:epc:id:sgln:0614141.00007.0'
-
-const master = (system: string) => ({
-  source: `ops-${system}`,
-  system,
-  siteName: 'miratek',
-  space: { spaceId: 'miratek', width: 60, depth: 30, unit: 'm' },
-  locations: [
-    { id: 'dock-recv', type: 'dock', role: 'location' as const, system: 'wms' },
-    { id: 'bin-1', type: 'storage', role: 'location' as const, system: 'wms' },
-    { id: LINE, type: 'assembly-line', role: 'location' as const, system: 'mes' },
-    { id: 'legacy', type: 'storage', role: 'location' as const }
-  ],
-  equipment: []
-})
-const unknown = (r: any) => (r.warnings ?? []).filter((w: any) => w.code === 'unknown-location-type')
-
-test('★ 창고 렌즈는 조립 라인 자리를 참조로 들고 경고하지 않는다', () => {
-  const r = masterToTwin(master('wms'), CATALOG)
-  assert.deepEqual(unknown(r), [], '종류 모르는 자리 경고 0')
-  assert.deepEqual(r.model.locations.map((l: any) => l.id), ['dock-recv', 'bin-1', 'legacy'])
-  assert.deepEqual(r.model.referencedLocations, [{ id: LINE, system: 'mes' }])
-})
-
-test('★ plant 렌즈로 보면 도크와 보관 자리가 참조다', () => {
-  const r = masterToTwin(master('mes'), CATALOG)
-  assert.deepEqual(r.model.locations.map((l: any) => l.id), [LINE, 'legacy'])
-  assert.deepEqual(r.model.referencedLocations.map((x: any) => x.id), ['dock-recv', 'bin-1'])
-})
-
-test('영역을 말하지 않은 원본은 지금처럼 선다 — 참조 칸을 만들지 않는다', () => {
-  const m = { ...master('wms'), locations: master('wms').locations.map(({ system, ...l }: any) => l) }
-  const r = masterToTwin(m, CATALOG)
-  assert.equal(r.model.locations.length, 4)
-  assert.equal('referencedLocations' in r.model, false)
-})

package/test/lineage-survives-restart.test.ts

@@ -1,234 +0,0 @@
-/*
- * ★ 재기동을 건너도 **계보에 입력이 남는다** — 호스트의 웜스타트 경로로 확인한다.
- *
- * ── 무엇이 잘못돼 있었나 ──────────────────────────────────────────────────────
- * 오더의 진행 중 할당(`allocated`)과 거래번호(`bizTransaction`)가 상태 계약에 없어서, 웜스타트가
- * 오더를 되살릴 때 둘 다 비운 채로 세웠다. 그 오더의 진행 중 작업이 완료되면
- * `TransformationEvent` 가 **입력 없이** 나간다 — "무엇이 무엇으로 바뀌었나" 에서 "무엇이" 가
- * 통째로 빠지고, 계보를 거슬러 올라갈 수 없다.
- *
- * 실 앱에서 변환 36건 중 35건이 입력 0 이었고 모든 이벤트의 거래번호가 빈값이었다.
- *
- * ── 왜 커널 검사만으로 충분하지 않나 ──────────────────────────────────────────
- * 커널 검사는 `hydrateObserved` 로 직접 심어 확인한다. 호스트는 **저널을 재생해서** 그 씨앗을
- * 만든다(`recover` → `replay`). 그 경로에서 한 번 더 떨어질 수 있으므로 여기서 실제로 걷는다.
- */
-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 { TwinEngine } = req('../dist-server/engine/index.js')
-const { TwinEvent } = req('../dist-server/service/twin-event/twin-event.js')
-const { TwinLineageQuery } = req('../dist-server/service/twin-model/twin-lineage-query.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const INSTANCE = 'lineage-probe'
-const CP = '0614141'
-const pat = (ref: string) => `urn:epc:idpat:sgtin:${CP}.${ref}.*`
-
-/** 원자재 하나로 완제품 하나를 만드는 2단 라인 — 실제 트레일러 템플릿의 축소판. */
-const master = (): any => ({
-  source: INSTANCE,
-  system: 'mes',
-  siteName: '계보 공장',
-  space: { width: 60, depth: 30, unit: 'm' },
-  locations: [
-    { id: 'raw-store', type: 'raw-store', role: 'location', capacity: 500 },
-    { id: 'cut-station', type: 'cut-station', role: 'location', capacity: 50 },
-    { id: 'weld-station', type: 'weld-station', role: 'location', capacity: 50 },
-    { id: 'fg-store', type: 'fg-store', role: 'location', capacity: 500 }
-  ],
-  equipment: [
-    { id: 'cutter-1', kind: 'cutter', homeLocationId: 'cut-station' },
-    { id: 'welder-1', kind: 'welder', homeLocationId: 'weld-station' }
-  ],
-  productionSpec: {
-    companyPrefix: CP,
-    binding: { steel: '077101', frame: '078101' },
-    /*
-     * 작업지시의 문서 식별자를 **이 현장이 선언한다** — 커널은 문서 타입을 정하지 않습니다(0.7.43).
-     * GDTI 는 「회사 프리픽스 + 문서 타입 + 일련번호」이고, 그 타입은 프리픽스를 배정받은 회사가
-     * 자기 번호 용량에서 배정합니다. 그러니 픽스처도 그 선언을 해야 합니다.
-     */
-    identity: { documentTypes: { workorder: '403' } },
-    definition: {
-      /* 자재는 **자기 보관 자리를 선언한다** — 커널이 자재가 놓이는 자리를 지어내지 않습니다(0.7.43). */
-      materials: [
-        { key: 'steel', label: '강재', locationType: 'raw-store' },
-        { key: 'frame', label: '프레임', locationType: 'fg-store' }
-      ],
-      locationTypes: [
-        { key: 'raw-store', label: '자재 보관' },
-        { key: 'cut-station', label: '절단' },
-        { key: 'weld-station', label: '용접' },
-        { key: 'fg-store', label: '완제품 보관' }
-      ],
-      routes: [{ key: 'frame-route', steps: ['cut', 'weld'] }],
-      recipes: [{ key: 'frame-recipe', label: 'f', route: 'frame-route', inputs: [{ material: 'steel', qty: 2 }], outputs: [{ material: 'frame', qty: 1 }] }],
-      operations: [
-        { key: 'cut', label: '절단', intent: 'process', locationType: 'cut-station', resourceType: 'cutter', duration: 'PT1M' },
-        { key: 'weld', label: '용접', intent: 'process', locationType: 'weld-station', resourceType: 'welder', duration: 'PT1M' }
-      ]
-    }
-  }
-})
-
-const SCENARIO = {
-  seed: 9,
-  generators: [
-    { kind: 'inbound-arrival', stimulus: 'arrival', rate: { distribution: 'constant', meanPerHour: 3600 },
-      content: { skuMix: [{ gtin: pat('077101'), weight: 1 }], qtyPerLine: { min: 1, max: 1 } } },
-    { kind: 'production-order', stimulus: 'order', rate: { distribution: 'constant', meanPerHour: 120 },
-      content: { skuMix: [{ gtin: pat('078101'), weight: 1 }], qtyPerLine: { min: 1, max: 1 } } }
-  ]
-}
-
-/** 저널에 남은 변환 이벤트들 — 계보가 실제로 무엇을 기록했나. */
-async function transforms(): Promise<{ inputs: number; outputs: number; tx: string }[]> {
-  const rows: any[] = await ds.getRepository(TwinEvent).find({ where: { domain: { id: domainId } as any, instanceId: INSTANCE } as any })
-  return rows
-    .filter(r => r.eventType === 'epcis.TransformationEvent')
-    .map(r => ({
-      inputs: (r.payload?.data?.inputEPCList ?? []).length,
-      outputs: (r.payload?.data?.outputEPCList ?? []).length,
-      tx: r.payload?.data?.bizTransactionList?.[0]?.bizTransaction ?? ''
-    }))
-}
-
-/**
- * 틱과 자극은 **런타임**에 있다 — `startFromRegistry` 가 돌려주는 것은 호스트의 인스턴스 기록이고
- * 커널 런타임은 그 안에 있다(둘을 같은 것으로 보면 `scenario` 가 없다고 나온다).
- */
-const runtime = () => TwinEngine.runtime(domainId, INSTANCE)
-
-function tick(n: number): void {
-  const rt = runtime()
-  for (let i = 0; i < n; i++) rt.tick(1000)
-}
-
-/**
- * 상태는 런타임의 `resync()` 로 얻는다 — `{ revision, state }` 를 돌려주므로 축은 그 **안에** 있다.
- * (`TwinEngine.snapshot` 도 이것을 그대로 넘겨 주므로 축이 한 겹 안에 들어 있다.)
- */
-const orders = () => ((runtime().resync().state?.orders ?? []) as any[])
-
-function drive(): void {
-  const rt = runtime()
-  rt.scenario.load(SCENARIO)
-  rt.scenario.start()
-}
-
-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: 'lineage-test', subdomain: 'lineage-test' } as any)
-  domainId = d.id
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-after(async () => {
-  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('재기동을 건너도 계보에 입력이 실린다 — 웜스타트가 확보분을 잃지 않는다', async () => {
-  /* ① 한 번 굴려 진행 중 할당을 만든다. */
-  await TwinEngine.startFromRegistry(domainId, INSTANCE, 'resume')
-  drive()
-  tick(200)
-  const workingBefore = orders().filter(o => (o.allocated ?? []).length)
-  assert.ok(workingBefore.length, '진행 중 확보분이 있어야 이 검사가 뜻이 있다')
-
-  /* ② 멈추고 **저널을 재생해** 다시 세운다 — 호스트의 웜스타트 경로 그대로. */
-  await TwinEngine.stop(domainId, INSTANCE)
-  await TwinEngine.startFromRegistry(domainId, INSTANCE, 'resume')
-
-  const revived = orders().filter(o => (o.allocated ?? []).length)
-  assert.ok(revived.length, '되살아난 오더가 확보분을 들고 있어야 한다 — 잃으면 계보의 입력이 빈다')
-
-  /* ③ 되살아난 작업이 끝날 만큼 더 굴린다. */
-  drive()
-  tick(300)
-
-  const all = await transforms()
-  assert.ok(all.length, '변환이 저널에 남아야 이 검사가 뜻이 있다')
-  const withInputs = all.filter(t => t.inputs > 0)
-  assert.ok(withInputs.length, '입력이 실린 변환이 하나도 없다 — 계보의 "어디서 왔나" 가 통째로 빈다')
-
-  /* 거래번호도 함께 — 계보가 **무슨 거래로** 일어났는지 잇는 축이다. */
-  assert.ok(all.some(t => t.tx), '거래번호가 전부 빈값이다 — 계보를 거래로 이을 수 없다')
-})
-
-test('계보를 거슬러 올라가 선언과 나란히 놓는다 — 그 차이가 진단이다', async () => {
-  const q = new TwinLineageQuery()
-  const ctx = { state: { domain: { id: domainId } } } as any
-
-  /* 완제품 하나를 고른다 — 저널이 그것을 산출로 실은 변환이 있어야 계보가 있다. */
-  const rows: any[] = await ds.getRepository(TwinEvent).find({ where: { domain: { id: domainId } as any, instanceId: INSTANCE } as any })
-  /* **완제품**을 고른다. 변환에는 중간 산물(WIP)을 내는 것도 있어서 아무거나 집으면 WIP 이 잡히고,
-     WIP 은 선언된 자재가 아니라 라우트의 내부 산물이므로 견줄 대상이 아니다. */
-  const made = rows
-    .filter(r => r.eventType === 'epcis.TransformationEvent' && (r.payload?.data?.inputEPCList ?? []).length)
-    .flatMap(r => r.payload.data.outputEPCList ?? [])
-    .filter((e: string) => e.includes(`.078101.`))
-  assert.ok(made.length, '완제품을 낸 변환이 있어야 이 검사가 뜻이 있다')
-
-  const lin = await q.twinItemLineage(INSTANCE, made[0], ctx)
-  assert.ok(lin, '계보가 나와야 한다')
-  assert.equal(lin.epc, made[0])
-  assert.ok(lin.items.length > 1, '거슬러 올라간 것이 있어야 한다 — 하나면 아무것도 안 찾은 것이다')
-  assert.ok(lin.edges.some((e: any) => e.from === made[0]), '이 개체를 만든 직접 투입이 보여야 한다')
-
-  /* 근거를 밝힌다 — 창을 넘겨 끊겼으면 계보가 실제보다 얕게 보인다. */
-  assert.equal(lin.basis.source, 'journal')
-  assert.equal(typeof lin.basis.transformationsRead, 'number')
-
-  /* **겹쳐 보기** — 선언(레시피)과 관측(실제 투입)을 자재별로 나란히. */
-  assert.equal(lin.conformance.comparable, true, `견줄 수 없으면 이유를 말한다: ${lin.conformance?.reason}`)
-  const steel = lin.conformance.lines.find((l: any) => l.material === 'steel')
-  assert.ok(steel, '레시피가 선언한 자재가 줄로 나와야 한다')
-  assert.equal(steel.declared, 2, '레시피는 강재 2개를 요구한다')
-  assert.equal(steel.observed, 2, '실제로도 2개를 먹었다 — 설계대로다')
-  assert.equal(steel.matches, true)
-})
-
-test('★ 만든 것을 관측하지 못했으면 「다르다」고 하지 않는다 — 안 본 것과 어긋난 것은 다른 사실이다', async () => {
-  const q = new TwinLineageQuery()
-  const ctx = { state: { domain: { id: domainId } } } as any
-  /*
-   * 완제품 클래스의 개체이지만 저널에 그것을 낸 변환이 없다 — 자재로도 이어지고 레시피도 하나다.
-   * 예전에는 여기서 셈이 그대로 돌아 관측을 전부 0 으로 적고 「레시피와 다릅니다」를 냈다
-   * (2026-09-18 :3000 에서 카메라 로트 23 줄이 그렇게 보였다).
-   */
-  const lin = await q.twinItemLineage(INSTANCE, `urn:epc:id:sgtin:${CP}.078101.999999`, ctx)
-  assert.equal(lin.conformance.comparable, false, `관측이 없는데 견주었다: ${JSON.stringify(lin.conformance?.lines?.slice(0, 2))}`)
-  assert.equal(lin.conformance.reason, 'made-not-observed')
-  assert.ok(lin.conformance.recipe, '어느 레시피와 견주려 했는지는 말한다 — 사람이 다음 걸음을 안다')
-  assert.equal(lin.basis.transformationsRead >= 0, true)
-})
-
-test('바인딩이 없으면 비교하지 않고 이유를 알린다 — 짐작으로 이으면 거짓 진단이 된다', async () => {
-  const q = new TwinLineageQuery()
-  const ctx = { state: { domain: { id: domainId } } } as any
-  /* 개체이긴 하지만 바인딩에 없는 품목 — 짐작으로 자재에 붙이면 "설계와 다르다" 는 거짓이 나온다. */
-  const lin = await q.twinItemLineage(INSTANCE, `urn:epc:id:sgtin:${CP}.099999.1`, ctx)
-  assert.equal(lin.conformance.comparable, false)
-  assert.equal(lin.conformance.reason, 'item-not-bound')
-})

package/test/live-cadence.test.ts

@@ -1,170 +0,0 @@
-/*
- * ★ **원천마다 시간의 결이 다르다** — 밤마다 나던 거짓 빨강의 나머지 반쪽.
- *
- * 판정은 이미 두 값을 받을 수 있다(`syncVerdictOf` 의 `expectedSilenceMs`·`quietNow`). 없던 것은
- * **원천이 그것을 말할 자리**였다. 인티그레이션 레인이 다섯을 재 왔다.
- *
- *   ppms 발전      일몰에 멈춘다 — 두 사이트가 같은 분 19:25 에 함께
- *   ppms 계측      밤에도 온다 · 15분마다
- *   ppms 가격      화·목만 거래된다 · 그 날 하루 한 번
- *   plant         근무시간 창 · 훅이라 「보내면 온다」
- *   chef          조업시간 창 · 같음
- *
- * 셋이 다 다르다 — 해에 매인 것, 사람 근무에 매인 것, 거래일에 매인 것. 그런데 **두 축으로
- * 덮인다**: 「지금이 활동 시각인가」와 「그 안에서 얼마나 뜸한가」.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { cadenceOf, ingestExpectation, type LiveCadence } from '../server/service/reference/live-cadence.js'
-
-const NOW = 1_800_000_000_000
-
-/* ── 축을 찾는다 ──────────────────────────────────────────────────────────── */
-
-test('★ 선언한 축을 찾는다', () => {
-  const cadences: LiveCadence[] = [
-    { axis: 'equipment.status', windowKind: 'daylight' },
-    { axis: 'quality.output', expectedSilenceMs: 900_000 }
-  ]
-
-  assert.equal(cadenceOf(cadences, 'quality.output')?.expectedSilenceMs, 900_000)
-  assert.equal(cadenceOf(cadences, 'equipment.status')?.windowKind, 'daylight')
-})
-
-test('★ 선언하지 않은 축은 없다고 답한다 — 옛 거동으로 견주게', () => {
-  assert.equal(cadenceOf([{ axis: 'quality.output' }], 'order.status'), undefined)
-  assert.equal(cadenceOf(undefined, 'quality.output'), undefined)
-})
-
-/* ── 판정에 넘길 두 값으로 옮긴다 ───────────────────────────────────────── */
-
-test('★ 선언이 없으면 아무것도 답하지 않는다 — 「모른다」를 「안 와도 된다」로 접지 않는다', () => {
-  /*
-   * 여기서 `quietNow: true` 를 내면 **선언 안 한 원천이 전부 조용해진다.** 정말 끊긴 것도
-   * 조용해지고, 그러면 이 축을 만든 목적을 잃는다.
-   */
-  assert.deepEqual(ingestExpectation(undefined, { nowMs: NOW }), {})
-})
-
-test('★ 15분마다 긷는 원천 — 주기만 넘긴다', () => {
-  const out = ingestExpectation({ axis: 'quality.output', expectedSilenceMs: 900_000 }, { nowMs: NOW })
-
-  assert.equal(out.expectedSilenceMs, 900_000)
-  assert.equal(out.quietNow, undefined, '창을 선언하지 않았는데 시각을 단언했다')
-})
-
-test('0이나 음수 주기는 선언이 아니다', () => {
-  for (const bad of [0, -1, NaN]) {
-    const out = ingestExpectation({ axis: 'a', expectedSilenceMs: bad }, { nowMs: NOW })
-    assert.equal(out.expectedSilenceMs, undefined, `${bad} 를 주기로 받았다`)
-  }
-})
-
-/* ── 「보내면 온다」 ──────────────────────────────────────────────────────── */
-
-test('★ 훅으로 미는 축은 침묵으로 판정하지 않는다 — plant 가 그렇다', () => {
-  /*
-   * 보낼 것이 없으면 안 보내는 것이 정상이다. 「주기가 없다」와 「모른다」를 가르는 값이다.
-   */
-  const out = ingestExpectation({ axis: 'order.status', pushed: true }, { nowMs: NOW })
-
-  assert.equal(out.quietNow, true)
-})
-
-test('★ 미는 축은 창 판정을 기다리지 않는다 — 판정 수단이 없어도 답한다', () => {
-  const out = ingestExpectation(
-    { axis: 'order.status', pushed: true, window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
-    { nowMs: NOW } /* inWindow 를 주지 않았다 */
-  )
-
-  assert.equal(out.quietNow, true)
-})
-
-/* ── 창 ──────────────────────────────────────────────────────────────────── */
-
-test('★ 활동 시각 안이면 조용할 때가 아니다', () => {
-  const out = ingestExpectation(
-    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
-    { nowMs: NOW, inWindow: () => true }
-  )
-
-  assert.equal(out.quietNow, false)
-})
-
-test('★ 활동 시각 밖이면 조용할 때다', () => {
-  const out = ingestExpectation(
-    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
-    { nowMs: NOW, inWindow: () => false }
-  )
-
-  assert.equal(out.quietNow, true)
-})
-
-test('★ 판정 수단을 안 받았으면 시각을 단언하지 않는다 — 지어낸 값을 만들지 않는다', () => {
-  /*
-   * 부르는 쪽이 달력 판정 함수를 주지 않았는데 우리가 「활동 시각이다」로 답하면, 창을 선언한
-   * 원천이 **창이 없는 것과 같아진다.** 그것은 조용한 실패다.
-   */
-  const out = ingestExpectation(
-    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
-    { nowMs: NOW }
-  )
-
-  assert.equal(out.quietNow, undefined)
-})
-
-test('빈 창은 창이 아니다', () => {
-  assert.equal(ingestExpectation({ axis: 'a', window: [] }, { nowMs: NOW, inWindow: () => false }).quietNow, undefined)
-})
-
-/* ── 두 축이 함께 온다 ──────────────────────────────────────────────────── */
-
-test('★ 주기와 창을 같이 선언할 수 있다 — 인증서 가격이 그 모양이다', () => {
-  /*
-   * 화·목만 거래되고 그 날 하루 한 번 온다. 「매일 와야 한다」로 재면 주 5일 중 3일이 빨갛고,
-   * 「주 2회」로 재면 이어 쓴 날을 못 본다. 두 축이면 둘 다 답한다.
-   */
-  const out = ingestExpectation(
-    {
-      axis: 'quality.output',
-      expectedSilenceMs: 26 * 3_600_000,
-      window: [
-        { id: 'tue', entryType: 'production', startTime: '00:00', endTime: '23:59' },
-        { id: 'thu', entryType: 'production', startTime: '00:00', endTime: '23:59' }
-      ]
-    },
-    { nowMs: NOW, inWindow: () => false }
-  )
-
-  assert.equal(out.expectedSilenceMs, 26 * 3_600_000)
-  assert.equal(out.quietNow, true, '거래일이 아니면 조용한 것이 정상이다')
-})
-
-/* ── 「해 있는 동안」은 호스트가 채운다 ──────────────────────────────────── */
-
-test('★ 종류만 선언한 것으로는 창 판정을 하지 않는다 — 호스트가 채워야 한다', () => {
-  /*
-   * 커널은 일출·일몰을 계산하지 않는다(굴절·고위도·박명 정의가 다 선택이고, 정하면 방언이다).
-   * 원천은 종류만 말하고, 좌표를 아는 호스트가 날마다 구체적인 구간을 채운다.
-   *
-   * 그러니 `windowKind` 만 있고 `window` 가 비어 있으면 **아직 채워지지 않은 것**이고, 그때
-   * 판정하지 않는다. `false` 로 접으면 태양광이 밤에도 활동 시각인 것이 된다.
-   */
-  const out = ingestExpectation({ axis: 'equipment.status', windowKind: 'daylight' }, { nowMs: NOW, inWindow: () => true })
-
-  assert.equal(out.quietNow, undefined)
-})
-
-test('★ 호스트가 채우면 그것으로 판정한다', () => {
-  const out = ingestExpectation(
-    {
-      axis: 'equipment.status',
-      windowKind: 'daylight',
-      window: [{ id: 'today', entryType: 'production', startTime: '06:12', endTime: '19:25' }]
-    },
-    { nowMs: NOW, inWindow: () => false }
-  )
-
-  assert.equal(out.quietNow, true)
-})