@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/canonical-ingest-vocabularies.test.ts

@@ -1,451 +0,0 @@
-/*
- * 정규 인제스트 — **어휘가 둘이다**(물류 EPCIS · 에너지 계측).
- *
- * ── 왜 있나 (2026-08-14, EMS 5단계 준비) ────────────────────────────────────
- * 이 seam 은 무조건 `type: 'ObjectEvent'` 를 만들었다. 그래서 커넥터가 계측을 이 길로 보내면 둘 중
- * 하나가 됐다: `epc` 가 없어 거부되거나(그나마 나은 쪽), **엉뚱한 물품 관측**으로 읽혀 재고가 흔들린다.
- * 오류 없이 틀리는 쪽이 더 나쁘다.
- *
- * 이 시험이 지키는 것 둘:
- *  ① 한 배치에 두 어휘가 섞여 와도 각자의 봉투가 된다(커넥터가 나눠 보낼 의무를 지지 않는다).
- *  ② **거부분이 사라지지 않는다** — 예전에는 호출부가 `rejected` 를 받지도 않았다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ingestCanonicalRecords } from '../server/engine/canonical-ingest.ts'
-
-/*
- * 이 파일의 **시계**. 아래 픽스처들이 8월 말을 쓰는데 시계가 8월 14일이었다 — 자기 시계보다 뒤의
- * 사실을 표본으로 두고 있었다. 커널이 「아직 오지 않은 시각의 사실」을 거부하게 되면서 드러났다
- * (2026-08-30). 시계를 픽스처 뒤로 옮긴다.
- */
-const NOW = '2026-09-01T00:00:00.000Z'
-
-const epcisRecord = {
-  epc: 'urn:epc:id:sgtin:0614141.107346.2017',
-  action: 'OBSERVE',
-  bizStep: 'urn:epcglobal:cbv:bizstep:storing',
-  disposition: 'urn:epcglobal:cbv:disp:in_progress',
-  readPoint: 'rack-1'
-}
-const energyRecord = { meterId: 'meter-incoming', kW: 1200, at: '2026-08-14T09:00:30.000Z' }
-
-test('한 배치에 두 어휘가 섞여도 각자의 봉투가 된다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([epcisRecord, energyRecord] as any, 't', NOW)
-  assert.equal(rejected.length, 0, `거부 없음이어야 한다: ${JSON.stringify(rejected)}`)
-  const types = accepted.map(e => e.eventType).sort()
-  assert.deepEqual(types, ['energy.measured', 'epcis.ObjectEvent'])
-})
-
-test('계측을 물품 관측으로 만들지 않는다 — 이것이 이 갈림의 이유다', () => {
-  const { accepted } = ingestCanonicalRecords([energyRecord] as any, 't', NOW)
-  assert.equal(accepted.length, 1)
-  assert.equal(accepted[0].eventType, 'energy.measured')
-  /* EPCIS 페이로드의 흔적이 없어야 한다 — 있으면 미러가 물품을 지어낸다. */
-  assert.equal((accepted[0].data as any).epcList, undefined)
-  assert.equal((accepted[0].data as any).type, undefined)
-})
-
-test('거부분이 사라지지 않는다 — 커넥터 매핑이 틀린 것을 알 수 있어야 한다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [
-      energyRecord,
-      { meterId: 'm-2', kW: 10, at: '어제' }, // 시각 형식 오류
-      { epc: '', action: 'OBSERVE', bizStep: 'x' } // EPCIS 쪽 결손
-    ] as any,
-    't',
-    NOW
-  )
-  assert.equal(accepted.length, 1, '유효한 것은 통과한다')
-  assert.equal(rejected.length, 2)
-  for (const r of rejected) assert.ok(r.errors.length > 0, '이유 없는 거부가 없다')
-})
-
-test('빈 입력에서 모든 갈래가 들어온 것이 없다 — 없는 것을 만들지 않는다', () => {
-  /*
-   * 어휘가 다섯이다 — 사건 넷과 사건이 아닌 것 하나(마스터데이터). 어느 갈래도 값을 지어내지 않는다.
-   *
-   * `undated` 는 `masterData` 와 같은 규칙으로 언제나 있다(빈 것이면 빈 객체). 없을 때 칸을 빼면
-   * 읽는 쪽이 「이 버전이 그것을 안 센다」와 「셌는데 0이다」를 구별하지 못한다.
-   */
-  const none = { accepted: [], rejected: [], masterData: [], undated: {} }
-  assert.deepEqual(ingestCanonicalRecords([], 't', NOW), none)
-  assert.deepEqual(ingestCanonicalRecords(null, 't', NOW), none)
-})
-
-test('시각이 없는 계측은 호출자의 기준 시각을 쓴다 — 도착 시각이 근거다', () => {
-  const { accepted } = ingestCanonicalRecords([{ meterId: 'm-1', kW: 5 }] as any, 't', NOW)
-  assert.equal(accepted[0].eventTime, NOW)
-})
-
-/*
- * ── 세 번째 어휘: 설비 에너지 상태 (2026-08-15) ─────────────────────────────
- * 능력 계약은 태양광·축전지·감축 부하·차단기의 상태 필드를 선언해 두었는데 받는 길이 없었다.
- * 계량과 갈라 두는 이유는 커널에 적혀 있다 — 계량은 구간에 누적되고, 이것들은 그 설비의 지금이다.
- */
-test('설비 에너지 상태는 EPCIS 도 계량도 아닌 자기 어휘로 들어온다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [
-      { equipmentId: 'pv-1', at: '2026-08-15T09:00:00.000Z', generatedKW: 210 },
-      { meterId: 'm-1', kW: 800, at: '2026-08-15T09:00:00.000Z' },
-      { epc: 'urn:epc:id:sgtin:9521321.012345.3', action: 'OBSERVE', bizStep: 'urn:epcglobal:cbv:bizstep:storing' }
-    ] as any,
-    'tenant-1',
-    '2026-08-15T09:00:00.000Z'
-  )
-  assert.equal(rejected.length, 0, JSON.stringify(rejected))
-  const types = accepted.map(a => a.eventType).sort()
-  assert.deepEqual(types, ['energy.equipment', 'energy.measured', 'epcis.ObjectEvent'].sort(), '세 어휘가 각자 봉투로')
-})
-
-test('바꿀 상태가 없는 보고는 거부한다 — 이유와 함께', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ equipmentId: 'pv-1', at: '2026-08-15T09:00:00.000Z' }] as any,
-    'tenant-1',
-    '2026-08-15T09:00:00.000Z'
-  )
-  assert.equal(accepted.length, 0)
-  assert.match(rejected[0].errors.join(' '), /바꿀 상태/)
-})
-
-test('충전율이 백분율 범위를 벗어나면 거부한다 — 단위를 잘못 맞춘 커넥터를 통과시키지 않는다', () => {
-  const { rejected } = ingestCanonicalRecords(
-    [{ equipmentId: 'ess-1', at: '2026-08-15T09:00:00.000Z', soc: 380 }] as any,
-    'tenant-1',
-    '2026-08-15T09:00:00.000Z'
-  )
-  assert.equal(rejected.length, 1)
-  assert.match(rejected[0].errors.join(' '), /soc/)
-})
-
-test('개폐 위치는 표준의 네 값만 받는다 — 과도·불량을 열림/닫힘으로 반올림하지 않는다', () => {
-  const ok = ingestCanonicalRecords([{ equipmentId: 'cb-1', at: '2026-08-15T09:00:00.000Z', position: 'intermediate' }] as any, 't', '2026-08-15T09:00:00.000Z')
-  assert.equal(ok.accepted.length, 1)
-  const bad = ingestCanonicalRecords([{ equipmentId: 'cb-1', at: '2026-08-15T09:00:00.000Z', position: 'ON' }] as any, 't', '2026-08-15T09:00:00.000Z')
-  assert.equal(bad.rejected.length, 1)
-  assert.match(bad.rejected[0].errors.join(' '), /position/)
-})
-
-/*
- * ── 레코드가 말한 시각이 봉투의 시각이 된다 (2026-08-23) ────────────────────
- *
- * 이 경로는 `eventTimePath` 를 주지 않아 **언제나 폴링 시각**을 썼다. 그래서 커넥터가 이미 싣고 있던
- * `eventTime` 이 알리지 않고 무시됐다 — 어디에도 오류가 나지 않고, 커넥터를 붙인 쪽은 그것이 먹는다고
- * 믿고 있었다.
- *
- * 무엇이 걸렸나: **계보의 시각**이다. 4월에 만든 로트가 8월에 만들어진 것으로 저널에 남았다. 그리고
- * 실측 소요를 재는 폴드가 봉투 시각을 쓰므로(`kpi-fold`: `workMs = 완료 − 첫 착수`), 폴링 간격을
- * 작업시간으로 배울 수 있었다 — 못 배우는 것보다 나쁘다.
- */
-test('레코드가 시각을 말하면 그것이 봉투의 시각이다 — 폴링 시각으로 덮지 않는다', () => {
-  const POLLED = '2026-08-23T00:00:00.000Z'
-  const SAID = '2026-04-15T07:35:53.000Z'
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ ...epcisRecord, eventTime: SAID }] as any,
-    't',
-    POLLED
-  )
-  assert.deepEqual(rejected, [])
-  assert.equal(accepted[0].eventTime, SAID, '원본이 말한 시각이어야 한다')
-  assert.notEqual(accepted[0].eventTime, POLLED, '폴링 시각이 아니어야 한다')
-})
-
-test('레코드가 시각을 말하지 않으면 폴링 시각으로 떨어진다 — 이 한 줄이 기존 경로를 막지 않는다', () => {
-  /*
-   * 커널의 경로 해석은 없는 값을 **오류로 만들지 않는다**(§`resolve`). 그래서 시각을 말하지 않는
-   * 레코드는 예전처럼 기본값을 쓴다. 이 단정이 없으면 위 한 줄이 알리지 않고 대량 거부를 낼 수 있다.
-   */
-  const POLLED = '2026-08-23T00:00:00.000Z'
-  const { accepted, rejected } = ingestCanonicalRecords([epcisRecord] as any, 't', POLLED)
-  assert.deepEqual(rejected, [])
-  assert.equal(accepted[0].eventTime, POLLED)
-})
-
-/*
- * ── 다섯 번째 어휘 — 발전 적산 (2026-08-28, 커널 0.7.69) ──────────────────────
- *
- * 커널이 `energy.generated` 를 오래 선언만 하고 있었고, 그 문이 0.7.69 에 열렸다. 그런데 문이 열린
- * 것과 길이 난 것은 다르다 — 이 seam 이 발전 적산을 **설비 상태 문으로 보내고 있었다.**
- *
- * 두 판정이 겹치기 때문이다. `isEnergyEquipmentRecord` 는 `equipmentId` 만 보므로 발전 적산에도
- * 참이다. 그래서 순서를 정하지 않으면 적산이 설비 상태 문에 닿고, 그 문은 적산을 값으로 세지 않아
- * 「바꿀 상태가 하나도 없다」로 돌려보낸다.
- *
- * 이 저장소에서 가장 자주 나는 결함 부류다 — 자리는 선언되어 있고 거기까지 가는 길이 없다.
- */
-const generationRecord = {
-  equipmentId: 'inv-001',
-  kWh: 574.8,
-  kWhSince: '2026-08-13T15:00:00.000Z',
-  at: '2026-08-14T09:00:30.000Z'
-}
-
-test('발전 적산은 설비 상태가 아니라 자기 문으로 들어온다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([generationRecord] as any, 't', NOW)
-  assert.deepEqual(rejected, [], `거부 없음이어야 한다: ${JSON.stringify(rejected)}`)
-  assert.equal(accepted.length, 1)
-  assert.equal(accepted[0].eventType, 'energy.generated', '설비 상태 문으로 가면 여기서 거부됐을 것이다')
-})
-
-test('적산이 쌓이기 시작한 시각이 봉투까지 간다 — 이것이 없으면 자정이 계기 교체로 남는다', () => {
-  const { accepted } = ingestCanonicalRecords([generationRecord] as any, 't', NOW)
-  assert.equal((accepted[0].data as any).since, '2026-08-13T15:00:00.000Z')
-  assert.equal((accepted[0].data as any).kWh, 574.8)
-})
-
-test('기준점을 말하지 않는 원본도 그대로 통과한다 — 없는 칸을 만들지 않는다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ equipmentId: 'inv-002', kWh: 120.5, at: '2026-08-14T09:00:30.000Z' }] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(rejected, [])
-  assert.equal(accepted[0].eventType, 'energy.generated')
-  assert.equal((accepted[0].data as any).since, undefined, '말하지 않은 것을 지어내지 않는다')
-})
-
-test('한 배치에 설비 상태와 발전 적산이 섞여도 각자의 문으로 간다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ equipmentId: 'inv-001', generatedKW: 8.2, at: '2026-08-14T09:00:30.000Z' }, generationRecord] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.deepEqual(accepted.map(e => e.eventType).sort(), ['energy.equipment', 'energy.generated'])
-})
-
-test('★ 상태까지 걷는다 — 자정에 되돌아간 적산이 계기 교체로 남지 않는다', async () => {
-  /*
-   * 문이 열린 것과 길이 난 것은 다르다. 그래서 봉투에서 멈추지 않고 **상태까지** 걷는다.
-   *
-   * PPMS 인버터의 `acc` 는 하루 누적이다(수집 코드가 전날까지 총량을 빼고, 그 값을 하루 만에
-   * 만료되는 자리에 둔다). 그래서 자정마다 574.8 → 165.2 로 되돌아간다. 기준점을 말하지 않으면
-   * 커널이 그것을 계기 교체로 읽고, 「계기 교체가 하루에 한 번 일어난다」가 지난 기록에 남는다.
-   */
-  const { EmsKernel } = await import('@operato/twin-kernel')
-  const k = new EmsKernel('t')
-  k.loadTwinModel({
-    locations: [{ id: 'incoming', type: 'incoming', capacity: 0 }],
-    equipment: [{ id: 'inv-001', kind: 'pv-array', locationId: 'incoming' }]
-  } as any)
-
-  const send = (kWh: number, since: string | undefined, at: string) => {
-    const { accepted, rejected } = ingestCanonicalRecords(
-      [{ equipmentId: 'inv-001', kWh, ...(since ? { kWhSince: since } : {}), at }] as any,
-      't',
-      at
-    )
-    assert.deepEqual(rejected, [], JSON.stringify(rejected))
-    for (const e of accepted) k.apply(e as any)
-  }
-  const inverter = () => (k.getSnapshot() as any).equipment.find((e: any) => e.id === 'inv-001')
-
-  /* 첫날 저녁 — 그날 자정부터 574.8kWh */
-  send(574.8, '2026-08-26T15:00:00.000Z', '2026-08-27T14:37:00.000Z')
-  assert.equal(inverter().generatedKWh, 574.8, '적산이 상태에 선다')
-
-  /* 다음 날 아침 — 값이 줄었지만 기준점이 나아갔다 */
-  send(165.2, '2026-08-27T15:00:00.000Z', '2026-08-28T01:12:00.000Z')
-  const after = inverter()
-  assert.equal(after.generatedKWh, 165.2)
-  assert.equal(after.generatedKWhSince, '2026-08-27T15:00:00.000Z', '어느 구간의 적산인지 남는다')
-  assert.equal(after.generatedKWhResetAt, undefined, '구간이 새로 시작한 것은 계기의 이상이 아니다')
-})
-
-test('기준점 없이 값이 줄면 모른다고 표시한다 — 짐작을 사실로 적지 않는다', async () => {
-  const { EmsKernel } = await import('@operato/twin-kernel')
-  const k = new EmsKernel('t')
-  k.loadTwinModel({
-    locations: [{ id: 'incoming', type: 'incoming', capacity: 0 }],
-    equipment: [{ id: 'inv-002', kind: 'pv-array', locationId: 'incoming' }]
-  } as any)
-  const send = (kWh: number, at: string) => {
-    const { accepted } = ingestCanonicalRecords([{ equipmentId: 'inv-002', kWh, at }] as any, 't', at)
-    for (const e of accepted) k.apply(e as any)
-  }
-  send(574.8, '2026-08-27T14:37:00.000Z')
-  send(165.2, '2026-08-28T01:12:00.000Z')
-  const eq = (k.getSnapshot() as any).equipment.find((e: any) => e.id === 'inv-002')
-  assert.ok(eq.generatedKWhResetAt, '되돌아간 사실은 남긴다')
-  assert.equal(eq.generatedKWhBasis, 'inferred', '그 판정이 짐작이라는 것도 함께 남긴다')
-})
-
-/*
- * ── 여섯째·일곱째 어휘 — 사용 구간과 청구서 (2026-08-29, 커널 0.7.72) ──────────
- *
- * 커널이 문을 열었고, 이 seam 은 또 그 어휘를 몰랐다. 발전 적산 때와 같은 자리다.
- *
- * 이번 겹침이 더 나쁘다. `isEnergyRecord` 는 `meterId` 가 있으면 참이므로 사용 구간에도 참이다.
- * 순서를 정하지 않으면 시간별 사용량이 계량 표본으로 들어가는데, 그 문은 `kWh` 를 적산
- * 레지스터로 읽는다. 우리가 넣는 값은 이미 구간의 양이라 차분의 차분이 된다 — **거부되지 않고
- * 값만 틀린다.**
- */
-const usageRecord = {
-  meterId: 'incoming',
-  from: '2026-08-28T15:00:00.000Z',
-  to: '2026-08-28T16:00:00.000Z',
-  kWh: 474.48,
-  maxKW: 478.08,
-  unitPrice: 87.3,
-  currency: 'KRW',
-  basis: 'provider'
-}
-const billRecord = {
-  from: '2026-06-30T15:00:00.000Z',
-  to: '2026-07-31T15:00:00.000Z',
-  demandCharge: 13728000,
-  currency: 'KRW',
-  billingDemandKW: 1650
-}
-
-test('★ 사용 구간은 계량 표본이 아니라 자기 문으로 들어온다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([usageRecord] as any, 't', NOW)
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.equal(accepted.length, 1)
-  assert.notEqual(accepted[0].eventType, 'energy.measured', '계량 문으로 가면 kWh 가 적산으로 읽힌다')
-})
-
-test('청구서도 자기 문으로 들어온다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([billRecord] as any, 't', NOW)
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.equal(accepted.length, 1)
-  assert.notEqual(accepted[0].eventType, 'epcis.ObjectEvent', '물품 관측으로 만들지 않는다')
-})
-
-test('계량 표본은 그대로 계량 문으로 간다 — 이 갈림이 기존 경로를 막지 않는다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ meterId: 'incoming', kW: 1200, at: '2026-08-14T09:00:30.000Z' }] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(rejected, [])
-  assert.equal(accepted[0].eventType, 'energy.measured')
-})
-
-test('한 배치에 넷이 섞여도 각자의 문으로 간다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [energyRecord, generationRecord, usageRecord, billRecord] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.equal(accepted.length, 4, '넷 다 받아들인다')
-  assert.equal(new Set(accepted.map(e => e.eventType)).size, 4, '넷이 서로 다른 사건이다')
-})
-
-/*
- * ── 여덟째 어휘 — 요금 기준 (2026-08-29, 커널 0.7.76) ─────────────────────────
- *
- * 문이 열렸는데 유입 갈림이 또 몰랐다. 오늘 세 번째다.
- */
-const tariffBasisRecord = {
-  from: '2026-07-31T15:00:00.000Z',
-  to: '2026-08-31T15:00:00.000Z',
-  billingDemandKW: 1650,
-  demandChargePerKW: 8320,
-  currency: 'KRW'
-}
-
-test('★ 요금 기준이 자기 문으로 들어온다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([tariffBasisRecord] as any, 't', NOW)
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.equal(accepted.length, 1)
-  assert.equal(accepted[0].eventType, 'energy.tariff.basis')
-})
-
-test('요금 기준의 사건 시각은 기간의 시작이다 — 진행 중인 주기도 미래에 적히지 않는다', () => {
-  const { accepted } = ingestCanonicalRecords([tariffBasisRecord] as any, 't', NOW)
-  assert.equal(accepted[0].eventTime, '2026-07-31T15:00:00.000Z', '청구서와 달리 to 가 아니다')
-})
-
-test('요금 기준과 청구서를 섞어도 각자의 문으로 간다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords([tariffBasisRecord, billRecord] as any, 't', NOW)
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.deepEqual(accepted.map(e => e.eventType).sort(), ['energy.bill', 'energy.tariff.basis'])
-})
-
-test('설비의 전기 계측값은 설비 상태 문으로 간다 — 발전 출력이 없어도 받는다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    [{ equipmentId: '002', dcVoltage: 469.13, dcCurrent: 68.7, acVoltage: [377.8, 379.9, 377.7], acCurrent: [37, 37.2, 37] }] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(rejected, [], JSON.stringify(rejected))
-  assert.equal(accepted[0].eventType, 'energy.equipment')
-})
-
-/* ── 발전 단가가 지나갈 길 (2026-08-30) ────────────────────────────────────
- *
- * ★ 오늘 다섯 번째다. 커널에 문을 열고 이 갈림에 길을 내지 않으면, 레코드가 아무 문에도
- *   들어가지 못하고 조용히 사라진다 — 거부도 되지 않으므로 아무도 모른다.
- */
-test('발전 단가가 그 문으로 간다', () => {
-  const r = ingestCanonicalRecords(
-    [{ from: '2026-08-29T15:00:00.000Z', to: '2026-08-30T15:00:00.000Z', unitPrice: 148.61, currency: 'KRW' }] as any,
-    't',
-    NOW
-  )
-  assert.equal(r.rejected.length, 0, `거부되면 안 된다: ${JSON.stringify(r.rejected)}`)
-  assert.equal(r.accepted.length, 1)
-  assert.equal((r.accepted[0] as any).eventType, 'energy.generation.price')
-  assert.equal((r.accepted[0] as any).eventTime, '2026-08-29T15:00:00.000Z', '사건 시각은 기간의 시작이다')
-})
-
-test('★ 단가·사용 구간·요금 기준·청구서가 한 배치에 섞여 와도 각자의 문으로 간다', () => {
-  const r = ingestCanonicalRecords(
-    [
-      { from: '2026-08-29T15:00:00.000Z', to: '2026-08-30T15:00:00.000Z', unitPrice: 148.61, currency: 'KRW' },
-      { meterId: 'incoming', from: '2026-08-29T15:00:00.000Z', to: '2026-08-29T16:00:00.000Z', kWh: 474.48 },
-      { from: '2026-07-31T15:00:00.000Z', to: '2026-08-31T15:00:00.000Z', billingDemandKW: 1650, demandChargePerKW: 8320, currency: 'KRW' },
-      { from: '2026-06-30T15:00:00.000Z', to: '2026-07-31T15:00:00.000Z', demandCharge: 13_728_000, currency: 'KRW' }
-    ] as any,
-    't',
-    NOW
-  )
-  assert.equal(r.rejected.length, 0, JSON.stringify(r.rejected))
-  const types = (r.accepted as any[]).map(e => e.eventType).sort()
-  assert.deepEqual(types, ['energy.bill', 'energy.generation.price', 'energy.tariff.basis', 'energy.usage.period'])
-})
-
-/* ── fact type 마다 시각 칸 이름이 다르다 ──────────────────────────────────── */
-
-test('★ nonconformance 는 decidedAt 을 자기 시각으로 쓴다 — 세 번째로 밟은 자리다', () => {
-  /*
-   * [측정함 2026-09-06] backfill 뒤 mes-line-a 의 nonconformance 4건이 event_time == created_at
-   * 이었다. payload 의 `data.decidedAt` 은 2026-09-01 인데 저장된 시각은 2026-09-05 였다 — 5일 차이.
-   *
-   * push 경로에서는 안 보인다. 사실이 나자마자 보내니 몇 초 차이다. backfill 이 그 간격을 벌려서
-   * 드러냈다.
-   */
-  const got = ingestCanonicalRecords(
-    [{ subjectId: 'LOT-A', decision: 'scrap', decidedAt: '2026-09-01T02:50:51.832Z' }] as any,
-    't',
-    NOW
-  )
-  assert.equal(got.accepted[0]?.eventTime, '2026-09-01T02:50:51.832Z', 'ingest 시각으로 떨어졌다')
-  assert.deepEqual(got.undated, {}, '시각을 읽었으면 세지 않는다')
-})
-
-test('★ 시각을 못 읽으면 그 사실을 센다 — 조용히 지금 시각으로 떨어지지 않는다', () => {
-  /*
-   * 오류가 아니다. 절대값 snapshot 은 polling 순간이 맞는 시각이라 여기 세어지는 것이 정상이다.
-   * 다만 그 수가 어디에도 안 남으면 `event_time == created_at` 이 유일한 단서이고, 그것은 우연히
-   * 같은 것과 구별되지 않는다.
-   */
-  const got = ingestCanonicalRecords(
-    [{ subjectId: 'LOT-B', decision: 'scrap' }] as any,
-    't',
-    NOW
-  )
-  assert.deepEqual(got.undated, { disposition: 1 })
-})
-
-test('공통 이름이 있으면 그것이 이긴다 — 봉투 층의 판단이 가장 바깥이다', () => {
-  const got = ingestCanonicalRecords(
-    [{ subjectId: 'L', decision: 'scrap', at: '2026-09-03T00:00:00.000Z', decidedAt: '2026-09-01T00:00:00.000Z' }] as any,
-    't',
-    NOW
-  )
-  assert.equal(got.accepted[0]?.eventTime, '2026-09-03T00:00:00.000Z')
-})

package/test/canonical-quantity-door.test.ts

@@ -1,61 +0,0 @@
-/*
- * ★ 비직렬 수량이 들어오는 문 — **오류 없이 사라지지 않는다.**
- *
- * `CanonicalRecord` 에 `quantityList` 자리를 냈다(담김의 `childQuantityList` 가 하루 먼저 같은 이유로
- * 받은 자리다). 원본이 「이 자리에 이 품목이 얼마 남았다」를 말할 길이 없어서, 그것이 주된 경로인
- * 시스템(식품 제조 MES)은 라이브를 낼 수 없었다.
- *
- * ── 배포 뒤 (2026-08-21) ────────────────────────────────────────────────────
- * 커널 0.7.40 에 `ObjectEventMapping.quantityList` 가 들어와 **수량만 오는 레코드가 통과한다.**
- * 그 전까지는 `epcList` 와 `quantityList` 가 둘 다 비어 검증이 거부했고, 이 시험은 그 거부가 **아무 말도 없지
- * 않다**(이유와 함께 계수된다)는 것을 지켰다.
- *
- * 이제 통과 쪽으로 고정한다 — 통과와 거부를 둘 다 받아들이면 다시 막혔을 때 초록으로 남는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ingestCanonicalRecords } from '../server/engine/canonical-ingest.ts'
-
-const T0 = '2026-08-20T09:00:00.000Z'
-const CLASS = 'https://chef.example.com/class/product-7f3a'
-
-const qtyRecord = {
-  action: 'OBSERVE',
-  bizStep: 'urn:epcglobal:cbv:bizstep:storing',
-  disposition: 'urn:epcglobal:cbv:disp:sellable_accessible',
-  quantityList: [{ epcClass: CLASS, quantity: 3.5, uom: 'KGM' }],
-  readPoint: 'chef-wh:w1',
-  bizLocation: 'chef-wh:w1'
-}
-
-test('수량만 오는 레코드가 통과하고 수량이 봉투까지 실린다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(qtyRecord as any, 'plantA', T0)
-  assert.deepEqual(rejected, [], `거부됐다 — 커널에 quantityList 자리가 있는지 확인: ${JSON.stringify(rejected)}`)
-  assert.equal(accepted.length, 1)
-  /* 자리만 통과하고 값이 빠지면 더 나쁘다 — 실린 줄 알고 잃는다. */
-  const ev: any = (accepted[0] as any).data ?? (accepted[0] as any).event ?? accepted[0]
-  assert.deepEqual(ev.quantityList, [{ epcClass: CLASS, quantity: 3.5, uom: 'KGM' }])
-  assert.deepEqual(ev.epcList, [], '개체가 없으므로 빈 배열이다 — 지어내지 않는다')
-})
-
-test('개체 관측은 그대로 통과한다 — 문을 내면서 기존 길을 막지 않는다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    { epc: 'urn:epc:id:sgtin:9521321.012345.1', action: 'OBSERVE', bizStep: 'urn:epcglobal:cbv:bizstep:storing', readPoint: 'chef-wh:w1' } as any,
-    'plantA',
-    T0
-  )
-  assert.equal(rejected.length, 0, `개체 관측이 거부되면 안 된다: ${JSON.stringify(rejected)}`)
-  assert.equal(accepted.length, 1)
-})
-
-test('개체도 수량도 없으면 거부된다 — 무엇을 관측했는지 말하지 않았다', () => {
-  const { accepted, rejected } = ingestCanonicalRecords(
-    { action: 'OBSERVE', bizStep: 'urn:epcglobal:cbv:bizstep:storing', readPoint: 'chef-wh:w1' } as any,
-    'plantA',
-    T0
-  )
-  assert.equal(accepted.length, 0)
-  assert.equal(rejected.length, 1)
-  assert.ok(rejected[0].errors?.length, '이유 없이 버리지 않는다')
-})

package/test/capability-mapping.test.ts

@@ -1,89 +0,0 @@
-/*
- * 커널↔보드 capability 매핑 무결성 — 스트림라인의 척추 검증.
- * 커널이 타입별 capability 를 선언(SSOT)하고, 그 능력의 관측 상태필드가 data(tag) payload 로 흘러
- * 보드 컴포넌트에 도달한다. 이 브릿지가 끊기면 모니터링이 성립 안 한다.
- *
- * 여기서 검증하는 절반 = 커널→payload(Node 로 완결). 나머지 절반(payload→컴포넌트 렌더)은 클라 하네스.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { DOMAIN_CATALOG, CAPABILITIES, CAPABILITY_KEYS, capabilitiesForType, stateFieldsOf } from '@operato/ops-contract'
-import { buildEntityDeltas } from '../shared/entity-delta.ts'
-
-const SYSTEMS = ['wms', 'yms', 'mes'] as const
-
-test('카탈로그 무결성: 모든 타입의 capability 가 정의된 능력집합에 속함 (dangling/오타 0)', () => {
-  for (const sys of SYSTEMS) {
-    for (const t of DOMAIN_CATALOG[sys].types) {
-      assert.ok(Array.isArray(t.capabilities), `${sys}/${t.key} capabilities 배열`)
-      for (const c of t.capabilities) {
-        assert.ok(CAPABILITY_KEYS.includes(c), `${sys}/${t.key}: '${c}' 는 정의된 능력`)
-      }
-    }
-  }
-})
-
-test('capabilitiesForType: 타입→능력 해소(SSOT)', () => {
-  assert.deepEqual(capabilitiesForType('wms', 'storage'), ['storable'], 'storage=storable')
-  assert.ok(capabilitiesForType('wms', 'forklift').includes('mobile'), 'forklift 는 mobile')
-  assert.ok(capabilitiesForType('wms', 'forklift').includes('operable'), 'forklift 는 operable')
-  assert.deepEqual(capabilitiesForType('wms', '__nope__'), [], '미지 타입 → []')
-})
-
-test('능력 정의 완전성 + 직교(어느 상태필드도 두 능력에 중복 없음)', () => {
-  const seen = new Map<string, string>()
-  for (const k of CAPABILITY_KEYS) {
-    assert.ok(CAPABILITIES[k], `${k} 정의 존재`)
-    assert.ok(CAPABILITIES[k].stateFields.length > 0, `${k} stateFields ≥1`)
-    for (const f of CAPABILITIES[k].stateFields) {
-      assert.ok(!seen.has(f), `상태필드 '${f}' 직교 위반: ${seen.get(f)} & ${k}`)
-      seen.set(f, k)
-    }
-  }
-})
-
-test('능력 소싱 구조: 4 자원/위치 능력은 카탈로그 타입에서, trackable 은 런타임 오더에서', () => {
-  // 매핑 구조: 노드/무버 타입은 카탈로그가 capability 를 선언(정적 소싱).
-  // trackable(오더/아이템 생애)은 런타임 생성 엔티티라 타입 카탈로그에 없고,
-  // board-placement-twin-provider 가 __orders__ 집약에 직접 부여(런타임 소싱). 이 분리가 매핑의 실제 구조.
-  const usedByType = new Set<string>()
-  for (const sys of SYSTEMS) for (const t of DOMAIN_CATALOG[sys].types) for (const c of t.capabilities) usedByType.add(c)
-
-  // 카탈로그가 쓰는 능력은 모두 정의됨(dangling 0)
-  for (const c of usedByType) assert.ok(CAPABILITY_KEYS.includes(c as any), `카탈로그 사용 능력 '${c}' 정의됨`)
-
-  // 4 자원/위치 능력은 각기 최소 1 타입에서 사용(죽은 정의 감지)
-  for (const k of ['operable', 'storable', 'mobile', 'processable'] as const) {
-    assert.ok(usedByType.has(k), `'${k}' 는 최소 1 카탈로그 타입에서 사용`)
-  }
-  // trackable 은 타입 카탈로그에 없음 = 런타임(오더) 스코프임을 명시 (고아가 아니라 다른 소싱 경로)
-  assert.ok(!usedByType.has('trackable'), 'trackable 은 타입 카탈로그가 아니라 런타임 오더(__orders__)에서 소싱')
-})
-
-test('★ 스트림라인 브릿지: 능력의 상태필드가 라이브 payload 에 실림 (커널→보드 도달)', () => {
-  // storable 노드 → occupancy/capacity (+ operable status)
-  const nodeD: any = buildEntityDeltas({ locations: [{ id: 'n', type: 'storage', occupancy: 2, capacity: 9, status: 'idle' }] }, 't1')[0].data
-  for (const f of stateFieldsOf(['storable'])) assert.ok(f in nodeD, `storable payload.${f}`)
-  assert.ok('status' in nodeD, 'operable(노드 status) payload')
-
-  // mobile+operable 무버 → location/motion/status
-  const equipmentD: any = buildEntityDeltas({ equipment: [{ id: 'm', kind: 'forklift', location: 'n', status: 'busy', motion: { toNode: 'n2', progress: 0.3 } }] }, 't1').find(x => x.tag === 'm')!.data
-  for (const f of stateFieldsOf(['mobile'])) assert.ok(f in equipmentD, `mobile payload.${f}`)
-  for (const f of stateFieldsOf(['operable'])) assert.ok(f in equipmentD, `operable payload.${f}`)
-
-  // trackable 오더 → progress/held (lifecycle 은 payload 에서 'status' 로 표면화 — 이름-매핑 시임)
-  const orderD: any = buildEntityDeltas({ orders: [{ id: 'o', status: 'picking', progress: 0.5, held: false }] }, 't1').find(x => x.tag === 'o')!.data
-  assert.ok('progress' in orderD && 'held' in orderD, 'trackable progress/held payload')
-  assert.ok('status' in orderD, 'trackable lifecycle → payload.status (이름-매핑)')
-})
-
-test('시임 문서화 · processable output(양품/불량)은 payload oee.good/scrap 으로 표면화', () => {
-  // 계약 stateField = 'output' 이나, 라이브 payload 는 이를 oee(정수%+good/scrap)로 집약해 표면화.
-  const d: any = buildEntityDeltas({
-    equipment: [{ id: 'c', kind: 'cutter', status: 'busy', oee: { overall: 0.8, availability: 0.9, performance: 0.9, quality: 0.98, goodCount: 10, nonconformingCount: 1 } }]
-  }, 't1').find(x => x.tag === 'c')!.data
-  assert.ok(d.oee, 'processable → payload.oee 존재')
-  assert.equal(d.oee.good, 10, 'output.good = oee.good')
-  assert.equal(d.oee.scrap, 1, 'output.scrap = oee.scrap')
-})