@things-factory/headless-twin 10.0.15 → 10.0.18

package/test/broadcast-cost-baseline.test.ts

@@ -22,7 +22,8 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { MesKernel, type CanonicalEnvelope, type ProductionSpec, type ScenarioDef, type TwinModelDef } from '@operato/twin-kernel'
+import { MesKernel } from '@operato/twin-kernel'
+import { type CanonicalEnvelope, type ProductionSpec, type ScenarioDef, type TwinModelDef } from '@operato/ops-contract'
 
 import { buildEntityDeltas } from '../shared/entity-delta.ts'
 

package/test/broadcast-period.test.ts

@@ -9,7 +9,7 @@
  *  ① 무거우면 늘린다 — 상한까지만.
  *  ② 가벼워지면 되돌린다 — 원래 주기 아래로는 내려가지 않는다.
  *  ③ 경계에서 늘리고 줄이기를 반복하지 않는다(문턱이 둘이다).
- *  ④ **늘렸다는 사실을 센다** — 조용히 늦추면 사람은 화면이 낡은 이유를 알 수 없다.
+ *  ④ **늘렸다는 사실을 센다** — 알리지 않고 늦추면 사람은 화면이 낡은 이유를 알 수 없다.
  */
 import { test, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
@@ -35,7 +35,7 @@ test('브로드캐스팅이 주기의 몫을 넘게 쓰면 주기를 늘린다
   assert.equal(TwinEngine.broadcastPeriodMs, TwinEngine.BROADCAST_MAX_COALESCE_MS, '상한 위로는 올라가지 않는다')
 })
 
-test('늘렸다는 사실을 센다 — 조용히 늦추지 않는다', () => {
+test('늘렸다는 사실을 센다 — 알리지 않고 늦추지 않는다', () => {
   adjust(TwinEngine.BROADCAST_COALESCE_MS)
   assert.equal(TwinEngine.broadcastBackoffs, 1)
 })

package/test/broadcast-queue-overflow.test.ts

@@ -0,0 +1,244 @@
+/*
+ * ★ 브로드캐스팅이 서버를 죽였다 — 그 기전을 실제 라이브러리로 재고, 우리 코드가 그것을 넘기지 않는지 본다.
+ *
+ * ── 무엇이 났나 (2026-08-27 10:24 · 실측) ───────────────────────────────────
+ * `RepeaterOverflowError: No more than 1024 pending calls to push are allowed on a single repeater.`
+ * 가 브로드캐스팅 타이머 안에서 나서 프로세스가 내려갔다. 같은 예외로 2026-08-14 에도 죽었다.
+ *
+ * ── 기전 ────────────────────────────────────────────────────────────────────
+ * 구독의 대기열에는 버퍼가 없다. `pubsub.subscribe` 가 `new Repeater(fn)` 을 버퍼 인자 없이 만든다.
+ * 그래서 발행하는 순간에 「다음 값을 달라」는 요청이 이미 걸려 있어야 바로 전달되고, 아니면 대기열에
+ * 쌓인다. 상한은 1024 이고 넘으면 예외가 난다.
+ *
+ * 값을 꺼내는 쪽은 비동기다. 그래서 **동기 반복문이 도는 중에는 한 건도 꺼내지 못한다.** 반복문으로
+ * N 건을 발행하면 첫 건만 전달되고 나머지 N−1 건이 전부 쌓인다. 브라우저가 아무리 빨라도 넘는다 —
+ * 속도 문제가 아니라 꺼낼 틈을 주지 않는 것이 원인이다.
+ *
+ * ── 왜 try/catch 로 못 막나 ─────────────────────────────────────────────────
+ * 2026-08-14 에 `publishGuarded` 가 `pubsub.publish` 를 try/catch 로 감쌌고, 커밋 제목이 「방송이
+ * 호스트를 죽이지 못하게」였다. 그것이 무력하다. 예외는 `EventTarget` 이 부른 리스너 안에서 나고,
+ * 런타임은 리스너 예외를 호출자에게 주지 않고 uncaughtException 으로 보낸다. 이 테스트가 그것을
+ * 값으로 못 박는다 — 그때 검증하지 않아서 3주 동안 막힌 줄 알고 있었다.
+ *
+ * ── 왜 오늘 났나 ────────────────────────────────────────────────────────────
+ * 오늘 아침 chef 커넥터가 묻는 간격을 5초에서 30초로 올렸다(상대 서버 부담을 줄이려고). 요청 횟수는
+ * 줄지만 한 번에 오는 양이 6배가 된다. 초당 130건이 들어오는 원본에서 한 묶음이 3,900건이 되고, 그
+ * 묶음이 한 창에 몰려 반복문 하나가 1024 를 넘겼다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const ENGINE = join(import.meta.dirname, '..', 'server', 'engine', 'twin-engine.ts')
+const src = readFileSync(ENGINE, 'utf8')
+
+/** 저장소 뿌리 — 자식이 `graphql-yoga` 를 찾을 수 있어야 한다. */
+const REPO = join(import.meta.dirname, '..', '..', '..')
+
+/**
+ * 발행을 **자식 프로세스**에서 한다 — 「프로세스가 죽는다」를 종료 코드로 확인하려면 그래야 한다.
+ *
+ * 같은 프로세스에서 재면 예외가 테스트 러너에 잡혀 이 테스트의 실패로 보고된다. 그것도 사실이지만
+ * 확인하려는 것은 「감싸도 못 막고 프로세스가 내려간다」이므로 자식의 종료 코드로 판정한다.
+ */
+function runChild(
+  count: number,
+  opts: { consume: boolean; chunk?: number; subscribers?: number; watchAll?: boolean }
+) {
+  const subscribers = opts.subscribers ?? 1
+  const code = `
+    import { createPubSub, pipe, filter } from 'graphql-yoga'
+    const pubsub = createPubSub()
+    const watchAll = ${!!opts.watchAll}
+    let pulled = 0, ordered = true, lastSeen = -1
+    if (${opts.consume}) {
+      for (let s = 0; s < ${subscribers}; s++) {
+        const stream = pipe(pubsub.subscribe('data'), filter(p => watchAll || p.tag === 'watched'))
+        ;(async () => {
+          for await (const p of stream) {
+            /* 순서 확인은 첫 구독만 한다 — 여럿이 세면 서로의 값이 섞인다. */
+            if (s === 0) {
+              pulled++
+              if (watchAll) {
+                if (p.i !== lastSeen + 1) ordered = false
+                lastSeen = p.i
+              }
+            }
+          }
+        })().catch(() => {})
+      }
+      /* 소비자들이 첫 요청을 걸 틈을 준다 — 이것이 없으면 리스너조차 등록되지 않는다(지연 구독). */
+      await new Promise(r => setImmediate(r))
+    }
+    let thrownToCaller = 0, sinceYield = 0
+    for (let i = 0; i < ${count}; i++) {
+      try { pubsub.publish('data', { tag: (watchAll || i === 0) ? 'watched' : 'other-' + i, i }) }
+      catch { thrownToCaller++ }
+      const chunk = ${opts.chunk ?? 0}
+      if (chunk && ++sinceYield >= chunk) { sinceYield = 0; await new Promise(r => setImmediate(r)) }
+    }
+    /* 남은 것을 다 꺼낼 틈을 준다 — 여기서 짧게 끊으면 「빠졌다」로 오판한다. */
+    for (let k = 0; k < 50; k++) await new Promise(r => setImmediate(r))
+    await new Promise(r => setTimeout(r, 100))
+    console.log(JSON.stringify({ thrownToCaller, pulled, ordered }))
+  `
+  const r = spawnSync(process.execPath, ['--input-type=module', '-e', code], {
+    cwd: REPO,
+    encoding: 'utf8'
+  })
+  const line = (r.stdout ?? '').trim().split('\n').filter(Boolean).pop()
+  return {
+    status: r.status,
+    overflowed: /No more than 1024 pending calls to push/.test(r.stderr ?? ''),
+    result: line ? (JSON.parse(line) as { thrownToCaller: number; pulled: number; ordered: boolean }) : null
+  }
+}
+
+test('★ 구독자가 있고 한 차례에 1024건을 넘게 발행하면 프로세스가 죽는다 — 브라우저 속도와 무관하다', () => {
+  const r = runChild(2000, { consume: true })
+  assert.ok(r.overflowed, '대기열이 넘쳐 예외가 나야 한다(이것이 서버를 죽인 그 예외다)')
+  assert.notEqual(r.status, 0, '그 예외로 프로세스가 내려간다')
+})
+
+test('★ 그 예외는 publish() 를 감싼 try/catch 로 잡히지 않는다 — 08-14 의 가드가 무력한 이유', () => {
+  const r = runChild(2000, { consume: true })
+  assert.equal(r.result, null, '완주하지 못한다 — 결과를 낼 자리에 닿지 못한다')
+  assert.ok(r.overflowed, '예외는 감싼 곳이 아니라 uncaughtException 으로 간다')
+})
+
+test('★ 상한마다 루프를 비워 주면 넘지 않는다 — 이것이 고친 방법이다', () => {
+  const r = runChild(5000, { consume: true, chunk: 200 })
+  assert.equal(r.status, 0, '청크마다 양보하면 프로세스가 살아 있다')
+  assert.equal(r.overflowed, false, '대기열이 넘지 않는다')
+  assert.ok((r.result?.pulled ?? 0) > 0, '소비자가 실제로 꺼내 간다')
+})
+
+test('★ 동기 반복문 중에는 소비자가 꺼내지 못한다 — 속도가 아니라 틈이 없는 것이 원인이다', () => {
+  /* 1024 아래로 두어 죽지 않게 하고, 그 사이에 몇 건이 꺼내졌는지 본다. */
+  const r = runChild(1000, { consume: true })
+  assert.equal(r.status, 0)
+  assert.ok((r.result?.pulled ?? -1) <= 2, `꺼낸 것이 ${r.result?.pulled}건뿐이다 — 1000건을 발행하는 동안`)
+})
+
+test('구독자가 없으면 아무것도 쌓이지 않는다 — 리스너가 없다', () => {
+  const r = runChild(2000, { consume: false })
+  assert.equal(r.status, 0, '들을 사람이 없으면 대기열도 없다')
+  assert.equal(r.overflowed, false)
+})
+
+
+
+
+
+
+test('★ 엔진의 발행 반복문이 상한마다 루프를 비워 준다', () => {
+  const at = src.indexOf('static async publishEntityData')
+  assert.ok(at > 0, 'publishEntityData 가 async 여야 한다 — 양보할 수 없으면 상한을 지킬 수 없다')
+  const body = src.slice(at, at + 6000)
+  assert.match(body, /PUBLISH_CHUNK/, '한 차례의 상한에 이름이 있어야 한다')
+  assert.match(
+    body,
+    /sinceYield \+= 0|\+\+sinceYield >= this\.PUBLISH_CHUNK[\s\S]{0,120}?setImmediate/,
+    '상한에 닿으면 루프를 비워 줘야 한다'
+  )
+  /* 상한은 1024 보다 넉넉히 작아야 한다 — 한 청크를 다 꺼내지 못해도 여유가 남게. */
+  const cap = Number(/static PUBLISH_CHUNK = ([0-9_]+)/.exec(src)?.[1]?.replace(/_/g, ''))
+  assert.ok(cap > 0 && cap <= 512, `상한이 ${cap} 이다 — 1024 의 절반 아래여야 한다`)
+})
+
+test('★ 발행을 중간에 그만두지 않는다 — 그만두면 그 태그가 낡은 값으로 남는다', () => {
+  const at = src.indexOf('static async publishEntityData')
+  const body = src.slice(at, at + 6000)
+  /* 상한에 닿았을 때 `break`·`return` 으로 빠지면 남은 태그는 이 창에서 발행되지 않는다. */
+  assert.doesNotMatch(body, />= this\.PUBLISH_CHUNK[\s\S]{0,80}?(break|return)/, '상한에서 빠져나가지 않는다')
+})
+
+test('★ 한 창이 겹쳐 돌지 않는다 — 같은 태그가 두 순서로 나가지 않게', () => {
+  const at = src.indexOf('static flushLiveBroadcasts')
+  assert.ok(at > 0, 'flushLiveBroadcasts 가 있어야 한다')
+  const body = src.slice(at, at + 1200)
+  assert.match(body, /if \(this\.flushInFlight\)/, '앞 창이 돌고 있으면 들어가지 않는다')
+  assert.match(body, /flushOverruns\+\+/, '겹친 횟수를 센다 — 알리지 않고 넘기지 않는다')
+  /* 발행을 기다려야 청크 사이의 양보가 뜻을 갖는다. */
+  assert.match(src, /await this\.publishEntityData\(inst\)/, '창이 발행을 기다린다')
+})
+
+test('★ 발행 건수를 남긴다 — 다음에 이 판단을 추측으로 하지 않게', () => {
+  const at = src.indexOf('static async publishEntityData')
+  const body = src.slice(at, at + 6000)
+  assert.match(body, /publishedTotal/, '누적 발행 건수를 든다')
+  assert.match(body, /건 발행/, '상한을 넘긴 창은 건수를 로그에 남긴다')
+})
+
+/*
+ * ── 여기서부터: 상한 근처와 그 너머를 더 넓게 잰다 ────────────────────────────
+ *
+ * 위 테스트가 「1024 를 넘으면 죽고, 200마다 양보하면 산다」를 못 박았다. 그런데 실제 창은 18,426건이고
+ * 구독은 하나가 아니다(`board-provider` 가 컴포넌트마다 하나씩 연다). 그 조건에서도 서는지 잰다.
+ */
+
+test('★ 실제 규모에서 선다 — 한 창 18,426건 · 청크 200', () => {
+  /* 2026-08-27 11:11 실측값 그대로. 이 수가 상한의 18배라서 청크 없이는 반드시 죽는다. */
+  const r = runChild(18426, { consume: true, chunk: 200 })
+  assert.equal(r.status, 0, '실측 규모에서 프로세스가 살아 있어야 한다')
+  assert.equal(r.overflowed, false)
+})
+
+test('★ 구독이 여러 개여도 선다 — 화면은 컴포넌트마다 구독을 하나씩 연다', () => {
+  /*
+   * 지금 구조에서는 발행 하나가 **구독마다** 큐를 지나간다. 그래서 구독 수가 늘면 밀리는 총량도
+   * 그만큼 늘고, 양보 한 번에 소비자 여럿이 나눠 꺼내야 한다. 그 조건에서도 상한을 넘지 않아야 한다.
+   */
+  const r = runChild(5000, { consume: true, chunk: 200, subscribers: 20 })
+  assert.equal(r.status, 0, '구독 20개에서도 살아 있어야 한다')
+  assert.equal(r.overflowed, false)
+})
+
+test('★ 한 실행 차례의 경계는 1,025건이다 — 재서 확인한 값이다', () => {
+  /*
+   * ── 측정값 (2026-08-27) ─────────────────────────────────────────────────────
+   *   청크 1,024 · 1,025   산다
+   *   청크 1,026           죽는다
+   *   구독 수(1·5·20)      경계를 바꾸지 않는다 — 구독마다 자기 대기열이 따로다
+   *
+   * 1,025 까지 사는 이유: 청크가 시작될 때 소비자의 요청이 하나 걸려 있어 첫 건은 바로 전달되고,
+   * 그 뒤 1,024건이 쌓인 상태에서 검사를 통과한다. 1,026번째에 상한에 닿는다.
+   *
+   * 처음에 「청크가 상한과 같으면 위험하다」고 단정했는데 틀렸다. 재서 고쳤다.
+   */
+  assert.equal(runChild(5000, { consume: true, chunk: 1025 }).status, 0, '1,025 는 산다')
+  const over = runChild(5000, { consume: true, chunk: 1026 })
+  assert.ok(over.overflowed, '1,026 은 넘친다')
+  assert.notEqual(over.status, 0, '그리고 프로세스가 내려간다')
+})
+
+test('★ 그래도 여유를 둔다 — 같은 실행 차례에 다른 발행처가 함께 넣는다', () => {
+  /*
+   * 경계가 1,025 라도 그것에 붙여 쓰지 않는다. 이 채널에 발행하는 곳이 우리만이 아니다 —
+   * `integration-base` 의 상태 등록 변경과 `shell` 의 진행률 보고가 같은 채널을 쓴다. 그것들이
+   * 같은 실행 차례에 끼어들면 우리 몫에 더해진다.
+   *
+   * 엔진의 값이 200 이다(경계의 1/5). 이 테스트는 그 값이 여유 있는 쪽에 있는지만 본다.
+   */
+  const cap = Number(/static PUBLISH_CHUNK = ([0-9_]+)/.exec(src)?.[1]?.replace(/_/g, ''))
+  assert.ok(cap > 0 && cap <= 512, `상한이 ${cap} 이다 — 경계(1,025)의 절반 아래여야 한다`)
+})
+
+test('청크가 넉넉히 작으면 구독이 늘어도 여유가 남는다 — 엔진의 200이 그 자리에 있다', () => {
+  const r = runChild(5000, { consume: true, chunk: 200, subscribers: 50 })
+  assert.equal(r.status, 0)
+  assert.equal(r.overflowed, false)
+})
+
+test('★ 발행한 것이 하나도 빠지지 않는다 — 청크로 나눈 것이 값을 잃지 않았음을 확인한다', () => {
+  /*
+   * 청크는 시점만 나눈다. 건수·내용·순서가 그대로여야 한다. 그것을 확인하지 않으면 「죽지 않는다」만
+   * 알고 「제대로 전달된다」는 모르는 상태가 된다.
+   */
+  const r = runChild(3000, { consume: true, chunk: 200, watchAll: true })
+  assert.equal(r.status, 0)
+  assert.equal(r.result?.pulled, 3000, '발행한 3,000건이 그대로 도착해야 한다')
+  assert.equal(r.result?.ordered, true, '순서도 그대로여야 한다')
+})

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

@@ -15,7 +15,12 @@ import assert from 'node:assert/strict'
 
 import { ingestCanonicalRecords } from '../server/engine/canonical-ingest.ts'
 
-const NOW = '2026-08-14T09:00:00.000Z'
+/*
+ * 이 파일의 **시계**. 아래 픽스처들이 8월 말을 쓰는데 시계가 8월 14일이었다 — 자기 시계보다 뒤의
+ * 사실을 표본으로 두고 있었다. 커널이 「아직 오지 않은 시각의 사실」을 거부하게 되면서 드러났다
+ * (2026-08-30). 시계를 픽스처 뒤로 옮긴다.
+ */
+const NOW = '2026-09-01T00:00:00.000Z'
 
 const epcisRecord = {
   epc: 'urn:epc:id:sgtin:0614141.107346.2017',
@@ -57,11 +62,11 @@ test('거부분이 사라지지 않는다 — 커넥터 매핑이 틀린 것을
   for (const r of rejected) assert.ok(r.errors.length > 0, '이유 없는 거부가 없다')
 })
 
-test('빈 입력에서 두 경로 모두 조용하다 — 없는 것을 만들지 않는다', () => {
-  const empty = ingestCanonicalRecords([], 't', NOW)
-  assert.deepEqual(empty, { accepted: [], rejected: [] })
-  const nothing = ingestCanonicalRecords(null, 't', NOW)
-  assert.deepEqual(nothing, { accepted: [], rejected: [] })
+test('빈 입력에서 모든 갈래가 들어온 것이 없다 — 없는 것을 만들지 않는다', () => {
+  /* 어휘가 다섯이다 — 사건 넷과 사건이 아닌 것 하나(마스터데이터). 어느 갈래도 값을 지어내지 않는다. */
+  const none = { accepted: [], rejected: [], masterData: [] }
+  assert.deepEqual(ingestCanonicalRecords([], 't', NOW), none)
+  assert.deepEqual(ingestCanonicalRecords(null, 't', NOW), none)
 })
 
 test('시각이 없는 계측은 호출자의 기준 시각을 쓴다 — 도착 시각이 근거다', () => {
@@ -121,7 +126,7 @@ test('개폐 위치는 표준의 네 값만 받는다 — 과도·불량을 열
  * ── 레코드가 말한 시각이 봉투의 시각이 된다 (2026-08-23) ────────────────────
  *
  * 이 경로는 `eventTimePath` 를 주지 않아 **언제나 폴링 시각**을 썼다. 그래서 커넥터가 이미 싣고 있던
- * `eventTime` 이 조용히 무시됐다 — 어디에도 오류가 나지 않고, 커넥터를 붙인 쪽은 그것이 먹는다고
+ * `eventTime` 이 알리지 않고 무시됐다 — 어디에도 오류가 나지 않고, 커넥터를 붙인 쪽은 그것이 먹는다고
  * 믿고 있었다.
  *
  * 무엇이 걸렸나: **계보의 시각**이다. 4월에 만든 로트가 8월에 만들어진 것으로 저널에 남았다. 그리고
@@ -144,10 +149,256 @@ test('레코드가 시각을 말하면 그것이 봉투의 시각이다 — 폴
 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'])
+})

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

@@ -1,5 +1,5 @@
 /*
- * ★ 비직렬 수량이 들어오는 문 — **조용히 사라지지 않는다.**
+ * ★ 비직렬 수량이 들어오는 문 — **오류 없이 사라지지 않는다.**
  *
  * `CanonicalRecord` 에 `quantityList` 자리를 냈다(담김의 `childQuantityList` 가 하루 먼저 같은 이유로
  * 받은 자리다). 원본이 「이 자리에 이 품목이 얼마 남았다」를 말할 길이 없어서, 그것이 주된 경로인
@@ -7,7 +7,7 @@
  *
  * ── 배포 뒤 (2026-08-21) ────────────────────────────────────────────────────
  * 커널 0.7.40 에 `ObjectEventMapping.quantityList` 가 들어와 **수량만 오는 레코드가 통과한다.**
- * 그 전까지는 `epcList` 와 `quantityList` 가 둘 다 비어 검증이 거부했고, 이 시험은 그 거부가 **조용하지
+ * 그 전까지는 `epcList` 와 `quantityList` 가 둘 다 비어 검증이 거부했고, 이 시험은 그 거부가 **아무 말도 없지
  * 않다**(이유와 함께 계수된다)는 것을 지켰다.
  *
  * 이제 통과 쪽으로 고정한다 — 통과와 거부를 둘 다 받아들이면 다시 막혔을 때 초록으로 남는다.

package/test/capability-mapping.test.ts

@@ -8,7 +8,7 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { DOMAIN_CATALOG, CAPABILITIES, CAPABILITY_KEYS, capabilitiesForType, stateFieldsOf } from '@operato/twin-kernel'
+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

package/test/checkpoint-refuses-empty.test.ts

@@ -8,7 +8,7 @@
  *
  * 실측(포천, `operato-chef-v1-pocheon`):
  *
- *   저널을 접으면        items 741 · orders 2,856 · tasks 9,250 · nowTime 2026-04-15
+ *   저널을 계산하면        items 741 · orders 2,856 · tasks 9,250 · nowTime 2026-04-15
  *   라이브 미러          items   0 · orders     0 · tasks     0 · nowTime 2026-01-01
  *   저장된 스냅샷        rev 221,884 · items 741 · orders 2,780 · tasks 6,353  (어제 것)
  *   그런데 이 판이       같은 키에 **빈 상태**를 쓰고 있었다
@@ -98,6 +98,6 @@ test('엔진이 실제로 이 판정을 한다 — 식만 시험하면 엔진이
   const body = code.slice(at, at + 2000)
   assert.match(body, /ingestedTotal/, '「들은 것이 있나」를 본다')
   assert.match(body, /items\?\.length[\s\S]{0,80}orders\?\.length[\s\S]{0,80}tasks\?\.length/, '관측 축 셋을 합쳐 센다')
-  assert.match(body, /checkpoint refused/, '거절을 말한다 — 조용히 거절하지 않는다')
+  assert.match(body, /checkpoint refused/, '거절을 말한다 — 알리지 않고 거절하지 않는다')
   assert.doesNotMatch(body.slice(0, body.indexOf('checkpoint refused')), /revision >|revision </, '리비전 비교로 판정하지 않는다')
 })