@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/generated-not-counted.test.ts

@@ -1,99 +0,0 @@
-/*
- * **창에 다 들어오지 않은 발전 기간을 조용히 버리지 않는다.**
- *
- * ── 무엇이 일어났나 (2026-08-30) ──────────────────────────────────────────
- * 어제 발전량이 저널에 멀쩡히 있는데 화면이 비어 있었다. 발전 기간은 하루 단위이고(`08-28 15:00 →
- * 08-29 15:00`), 성과 구간은 「지금부터 24시간 전」이라 한낮에서 시작한다(`08-29 02:53 → 08-30 02:53`).
- * 하루 기간이 그 구간에 **온전히 들어오지 않는다.**
- *
- * 더하지 않는 것 자체는 맞다 — 걸친 기간을 더하면 다른 날의 값이 이 창의 값인 척한다. 틀린 것은
- * **아무 말도 하지 않은 것**이다. 사용자는 빈 화면을 「발전량이 없다」로 읽는다. 그 둘은 완전히
- * 다른 상황이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { foldKpi } from '../server/engine/kpi-fold.ts'
-
-const T = (iso: string) => Date.parse(iso)
-
-/** 실측값 — 오창의 8월 29일 하루. */
-const DAY_START = '2026-08-28T15:00:00.000Z'
-const DAY_END = '2026-08-29T15:00:00.000Z'
-
-const period = (equipmentId: string, kWh: number) => ({
-  eventType: 'energy.generation.period',
-  eventTime: DAY_END,
-  payload: {
-    eventId: `id|${equipmentId}`,
-    data: {
-      equipmentId,
-      kWh,
-      periodStart: DAY_START,
-      periodEnd: DAY_END,
-      observedFrom: DAY_START,
-      observedTo: DAY_END,
-      accumulation: 'daily',
-      boundary: 'offset'
-    }
-  }
-})
-
-const EVENTS = [period('002', 127.1), period('003', 104.1), period('004', 312.4), period('005', 102.3)] as any
-
-test('★ 창이 기간을 온전히 담으면 더한다', () => {
-  const r = foldKpi(EVENTS, { fromMs: T(DAY_START), toMs: T(DAY_END) })
-  const g = r.energy?.generated
-  assert.ok(g, '발전량이 있어야 한다')
-  assert.equal(g.counted, 4)
-  assert.equal(Math.round(g.kWh * 10) / 10, 645.9)
-  assert.equal(g.notCounted, undefined, '버린 것이 없으면 말하지 않는다')
-})
-
-test('★ 창이 기간을 반만 담으면 더하지 않되 **버렸다고 말한다**', () => {
-  /* 실제로 났던 구간 — 하루 기간의 한가운데에서 시작한다. */
-  const r = foldKpi(EVENTS, { fromMs: T('2026-08-29T02:53:00.000Z'), toMs: T('2026-08-30T02:53:00.000Z') })
-  const g = r.energy?.generated
-  assert.ok(g, '값이 없다고 아무것도 내지 않으면 화면은 「발전량 없음」으로 읽는다')
-  assert.equal(g.kWh, 0, '걸친 기간은 더하지 않는다 — 더하면 다른 날 값이 섞인다')
-  assert.equal(g.counted, 0)
-  assert.ok(g.notCounted, '버린 것을 말해야 한다')
-  assert.equal(g.notCounted.periods, 4)
-  assert.equal(Math.round(g.notCounted.kWh * 10) / 10, 645.9, '얼마를 못 세었는지 말한다')
-  assert.equal(g.notCounted.earliestStart, DAY_START)
-  assert.equal(g.notCounted.latestEnd, DAY_END)
-})
-
-test('창이 기간과 아예 겹치지 않으면 말할 것이 없다 — 없는 것을 만들지 않는다', () => {
-  const r = foldKpi(EVENTS, { fromMs: T('2026-07-01T00:00:00.000Z'), toMs: T('2026-07-02T00:00:00.000Z') })
-  assert.equal(r.energy?.generated, undefined)
-})
-
-test('온전히 든 것과 걸친 것이 섞이면 더한 것과 못 센 것을 함께 낸다', () => {
-  const earlier = {
-    ...period('002', 100),
-    eventTime: '2026-08-28T15:00:00.000Z',
-    payload: {
-      eventId: 'id|earlier',
-      data: {
-        equipmentId: '002',
-        kWh: 100,
-        periodStart: '2026-08-27T15:00:00.000Z',
-        periodEnd: '2026-08-28T15:00:00.000Z',
-        observedFrom: '2026-08-27T15:00:00.000Z',
-        observedTo: '2026-08-28T15:00:00.000Z',
-        accumulation: 'daily',
-        boundary: 'offset'
-      }
-    }
-  }
-  const r = foldKpi([earlier, ...EVENTS] as any, {
-    fromMs: T('2026-08-27T15:00:00.000Z'),
-    toMs: T('2026-08-29T02:00:00.000Z')
-  })
-  const g = r.energy?.generated
-  assert.ok(g)
-  assert.equal(g.counted, 1, '27→28 하루만 온전히 들었다')
-  assert.equal(g.kWh, 100)
-  assert.equal(g.notCounted?.periods, 4, '28→29 넷은 창의 끝을 넘는다')
-})

package/test/guard-roots.ts

@@ -1,76 +0,0 @@
-import { existsSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-/*
- * ═══════════════════════════════════════════════════════════════════════════
- * Where the source-reading guards look, and what happens when a place is gone.
- *
- * ── Why this exists (2026-09-08) ───────────────────────────────────────────
- * Four guards in this package read the *consumer's* source as well as their own, because the
- * defects they catch are committed by callers: a caller that fills a kernel kind with a
- * literal, a caller that reads the journal without saying it is folding, a caller that
- * ingests without writing to the ledger.
- *
- * The applications then moved to their own repository, and `../../operato-twin/server` stopped
- * existing. Two of the four failed with ENOENT. **The other two passed** — their directory
- * walker swallows a missing root:
- *
- *     try { entries = readdirSync(dir) } catch { … }
- *
- * So half of each of those guards was scanning nothing and reporting green. A guard that
- * quietly stops guarding is worse than one that fails, because the failure is the only signal
- * that it was ever load-bearing.
- *
- * ── So a missing root is an error, not a skip ──────────────────────────────
- * `guardRoots` refuses to hand back a root that is not there. The message says which place is
- * gone and what to do about it, because the answer is not "delete the root" — the code being
- * guarded still exists, it is just in another repository now, and the guard has to follow it
- * there.
- * ═══════════════════════════════════════════════════════════════════════════
- */
-
-/**
- * Resolve the places a guard scans, and fail loudly if any of them is missing.
- *
- * @param base    `import.meta.url` of the calling test.
- * @param places  Paths relative to that test file.
- */
-export function guardRoots(base: string, places: readonly string[]): string[] {
-  const missing: string[] = []
-  const roots = places.map(place => {
-    const path = fileURLToPath(new URL(place, base))
-    if (!existsSync(path)) missing.push(place)
-    return path
-  })
-
-  if (missing.length) {
-    throw new Error(
-      `guard root missing: ${missing.join(' · ')}\n` +
-        'This guard reads a consumer\'s source, and that source is no longer at this path.\n' +
-        'The applications moved to the operato-application repository (ADR-0041 era). Move the\n' +
-        'consumer half of this guard there rather than deleting the root — a root removed here\n' +
-        'is a rule that stops being checked, and nothing will say so.'
-    )
-  }
-
-  return roots
-}
-
-/**
- * Resolve one file a guard reads, and fail loudly if it is gone.
- *
- * Same reason as above, for the guards that read a single named file rather than walking a
- * tree. `readFileSync` would already throw here — this only replaces `ENOENT: no such file`
- * with a sentence that says what to do.
- */
-export function guardFile(base: string, place: string): string {
-  const path = fileURLToPath(new URL(place, base))
-  if (!existsSync(path)) {
-    throw new Error(
-      `guard file missing: ${place}\n` +
-        'This guard reads a consumer\'s source. That file moved to the operato-application\n' +
-        'repository — move this assertion there rather than deleting it.'
-    )
-  }
-  return path
-}

package/test/home-in-area.test.ts

@@ -1,90 +0,0 @@
-/*
- * **설비는 자리에도 구역에도 설 수 있다.**
- *
- * ── 실물 (2026-09-06) ───────────────────────────────────────────────────────
- * `EQ-CAM-SHOWER-01`(에어샤워)이 `LINE-CAM` 이라는 **구역**에 딸려 있다. 라인 전체에 붙는 설비는
- * 자리 하나를 고를 수 없고, 그것이 정상이다.
- *
- * 그런데 인제스트가 그 참조를 **「끊어졌다」고 경고**했다. 자리 목록에서만 찾았기 때문이다.
- *
- * ```
- * unresolved-reference
- * equipment.homeLocation points at something that is not in this twin (EQ-CAM-SHOWER-01→LINE-CAM)
- * ```
- *
- * 계약이 그 갈림을 위해 `homeLocationKind = 'location' | 'area'` 를 두었는데 **아무도 안 채우고
- * 있었다** — 선언만 있고 읽는 쪽도 쓰는 쪽도 0곳이었다.
- *
- * 짐작하지 않는다. 마스터가 이미 `role` 로 자리와 구역을 가르고 있으므로 그것을 읽는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { masterToTwin } from '../server/service/reference/reference-master.ts'
-
-const master = (): any => ({
-  source: 'm',
-  system: 'mes',
-  siteName: 'S',
-  space: { spaceId: 'm-site', width: 100, depth: 60, unit: 'm' },
-  locations: [
-    { id: 'ST-1', role: 'location', type: 'weld-station', capacity: 1 },
-    { id: 'LINE-CAM', role: 'area', type: 'line' }
-  ],
-  equipment: [
-    { id: 'EQ-WELD-1', kind: 'welder', homeLocationId: 'ST-1' },
-    { id: 'EQ-CAM-SHOWER-01', kind: 'air-shower', homeLocationId: 'LINE-CAM' }
-  ]
-})
-
-const eq = (model: any, id: string) => model.equipment.find((e: any) => e.id === id)
-
-test('★ 구역에 선 설비는 homeLocationKind 로 그것을 말한다', () => {
-  const { model } = masterToTwin(master())
-  const shower = eq(model, 'EQ-CAM-SHOWER-01')
-
-  assert.equal(shower.homeLocation, 'LINE-CAM')
-  assert.equal(shower.homeLocationKind, 'area', '구역인 것을 안 말하면 읽는 쪽이 자리로 읽는다')
-})
-
-test('★ 자리에 선 설비는 그 칸을 안 만든다 — 계약의 기본값이 location 이다', () => {
-  /*
-   * 없는 칸을 만들면 화면이 그것을 그리고, 「자리」라는 당연한 말이 모든 줄에 붙는다.
-   * `homeOf()` 가 없을 때 `'location'` 을 내는 것이 그래서다.
-   */
-  const { model } = masterToTwin(master())
-  const welder = eq(model, 'EQ-WELD-1')
-
-  assert.equal(welder.homeLocation, 'ST-1')
-  assert.equal('homeLocationKind' in welder, false)
-})
-
-test("★ role 이 'both' 면 자리다 — 구역으로 만들지 않는다", () => {
-  /*
-   * `both` 는 그 줄이 자리 목록에도 구역 목록에도 들어간다는 뜻이다. 설비가 그것을 가리키면
-   * **자리 쪽이 이긴다** — 자리는 설비가 실제로 서는 지점이고, 구역은 그것을 담는 넓이다.
-   */
-  const m = master()
-  m.locations = [{ id: 'CELL-1', role: 'both', type: 'cell', capacity: 1 }]
-  m.equipment = [{ id: 'EQ-1', kind: 'welder', homeLocationId: 'CELL-1' }]
-
-  const { model } = masterToTwin(m)
-  assert.equal('homeLocationKind' in eq(model, 'EQ-1'), false)
-})
-
-test('기준 자리가 없는 설비는 그 칸도 없다', () => {
-  const m = master()
-  m.equipment = [{ id: 'EQ-FREE', kind: 'agv' }]
-  const { model } = masterToTwin(m)
-  assert.equal('homeLocationKind' in eq(model, 'EQ-FREE'), false)
-})
-
-test('★ 이 테스트가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  const { model } = masterToTwin(master())
-  assert.equal(model.equipment.length, 2, '설비를 하나도 안 읽었다')
-  assert.notEqual(
-    eq(model, 'EQ-CAM-SHOWER-01').homeLocationKind,
-    eq(model, 'EQ-WELD-1').homeLocationKind,
-    '구역에 선 설비와 자리에 선 설비가 같아졌다'
-  )
-})

package/test/hook-address.test.ts

@@ -1,28 +0,0 @@
-/*
- * ★ The hook address the contract comments give is the address the route answers.
- *
- * 2026-10-11: both contract comments said `POST /domain/<도메인>/twin/hook/…`. The route sits on the
- * domain-public router with no prefix, so the warehouse destination, written from that comment, got 405
- * for every fact. The tenant travels in the X-Things-Factory-Domain header (the webhook destination's
- * params.receivingDomain), not in the path.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-const read = (rel: string) => readFileSync(new URL(`../server/${rel}`, import.meta.url), 'utf8')
-
-const route = read('routes.ts').match(/router\.post\('([^']*twin\/hook[^']*)'/)?.[1]
-
-test('the hook route is registered without a domain prefix', () => {
-  assert.equal(route, '/twin/hook/:source/:instanceId')
-})
-
-for (const file of ['service/reference/hook-contract.ts', 'service/reference/reference-hook.ts']) {
-  test(`${file} gives the address the route answers`, () => {
-    const line = read(file).match(/주소\s+POST\s+(\S+)/)?.[1]
-    assert.ok(line, 'no address line')
-    assert.equal(line, '/twin/hook/<연결이름>/<트윈>')
-    assert.equal(line.replace(/<[^>]+>/g, 'x'), route!.replace(/:\w+/g, 'x'), 'the comment and the route name different paths')
-  })
-}

package/test/hook-rejected-shape.test.ts

@@ -1,86 +0,0 @@
-/*
- * 떨어진 것에 봉투 id 가 실리나.
- *
- * ── 왜 필요한가 (2026-09-07 측정) ───────────────────────────────────────────
- * 훅 응답의 떨어진 목록이 `{ record, errors }` 였고, plant 은 그것을 **봉투 id 문자열 목록**으로
- * 읽고 있었다.
- *
- * ```
- * headless-twin  rejected: { record, errors }[]        객체 배열
- * plant          "rejected is a list of envelope ids"  문자열 배열
- * ```
- *
- * `Array.isArray` 는 통과하니 그쪽 guard 도 안 걸렸다. id 를 맞추는데 객체라 하나도 안 맞고
- * **묶음 전체가 「보냈음」으로 찍혔다** — 422 와 `ok: false` 를 보냈는데 재시도 0 · 오류 없음이었다.
- *
- * 우리가 말했는데 상대가 못 알아듣는 모양이면, 말한 것이 아니다.
- *
- * 이 시험은 **모양**을 본다. 값이 흐르는지는 다른 시험이 보고, 여기서는 보내는 쪽이 자기 행을 찾을 수
- * 있는 열쇠가 실리는지만 본다.
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import { rejectedForCaller } from '../server/service/reference/hook-rejected.js'
-
-const bad = { orderId: 'WO-1' }
-const worse = { orderId: 'WO-2' }
-const ERRORS = ['order: at 없음/형식 오류']
-
-test('봉투 id 를 아는 것은 id 로 나간다 — 보내는 쪽이 그 행만 표시할 수 있다', () => {
-  const out = rejectedForCaller([{ record: bad, errors: ERRORS }], [{ record: bad, eventId: 'evt-1' }])
-
-  assert.deepEqual(out, [{ eventId: 'evt-1', errors: ERRORS }])
-})
-
-test('id 를 모르면 레코드를 그대로 싣는다 — 빈 id 를 넣지 않는다', () => {
-  /*
-   * 빈 id 를 실으면 보내는 쪽이 아무 행도 못 찾으면서 「알았다」고 여긴다. 그때는 무엇이 떨어졌는지
-   * 보여 주는 것이 유일한 답이다.
-   */
-  const out = rejectedForCaller([{ record: bad, errors: ERRORS }], [{ record: bad }])
-
-  assert.deepEqual(out, [{ record: bad, errors: ERRORS }])
-})
-
-test('짝은 객체 동일성으로 짓는다 — 같은 모양의 레코드 둘이 서로의 id 를 가져가지 않는다', () => {
-  const twinA = { orderId: 'SAME' }
-  const twinB = { orderId: 'SAME' }
-  const out = rejectedForCaller(
-    [{ record: twinB, errors: ERRORS }],
-    [
-      { record: twinA, eventId: 'evt-A' },
-      { record: twinB, eventId: 'evt-B' }
-    ]
-  )
-
-  assert.deepEqual(out, [{ eventId: 'evt-B', errors: ERRORS }], '값으로 비교하면 evt-A 가 나온다')
-})
-
-test('여러 건이 각자의 id 로 나간다', () => {
-  const out = rejectedForCaller(
-    [
-      { record: bad, errors: ERRORS },
-      { record: worse, errors: ['다른 까닭'] }
-    ],
-    [
-      { record: bad, eventId: 'evt-1' },
-      { record: worse, eventId: 'evt-2' }
-    ]
-  )
-
-  assert.deepEqual(out, [
-    { eventId: 'evt-1', errors: ERRORS },
-    { eventId: 'evt-2', errors: ['다른 까닭'] }
-  ])
-})
-
-test('빈 문자열·공백 id 는 없는 것으로 본다 — 아무 행도 못 찾는 열쇠다', () => {
-  assert.deepEqual(rejectedForCaller([{ record: bad, errors: ERRORS }], [{ record: bad, eventId: '   ' }]), [
-    { record: bad, errors: ERRORS }
-  ])
-})
-
-test('떨어진 것이 없으면 빈 목록이다', () => {
-  assert.deepEqual(rejectedForCaller([], [{ record: bad, eventId: 'evt-1' }]), [])
-})

package/test/hook-response-sum.test.ts

@@ -1,193 +0,0 @@
-/*
- * Does the reply's own arithmetic close.
- *
- * ── Why this exists (2026-09-07) ───────────────────────────────────────────
- * The contract now declares the response a sender reads, and the reason it had to is that a
- * sender guessed instead: operato-plant read `rejected` as a list of envelope id strings, the
- * receiver sent `{record, errors}`, `Array.isArray` passed on both, and a batch of three was
- * stamped delivered while one envelope never landed (mes_outbox_events seq 178 — SENT,
- * attempts 0, no error).
- *
- * `offered` is the field that makes that catchable without reading the rejection list at all:
- *
- *   offered === applied + duplicates + rejected.length + vocabulary
- *
- * ── What this file is really guarding ──────────────────────────────────────
- * The first version of that sum left `vocabulary` out, and it was wrong. Vocabulary elements are
- * counted in `offered` and deliberately kept out of the other three — they set state and must
- * never reach the journal, because they carry no time axis. So every batch carrying one would
- * have failed a sender's check, the warning would have been ignored within a week, and the real
- * loss would have been ignored with it.
- *
- * The integration lane found that by looking for a counterexample rather than a confirmation,
- * and had a measured one: 32 distinct facts reconciled as 29 journal + 2 rejected + 1 vocabulary.
- *
- * The count already existed — `liveIngest` has returned `vocabulary` all along — and this
- * boundary dropped it, because the callback was typed as `IngestResult` and the field was not on
- * it. A declared field nobody fills is the same defect one layer over, so what is asserted here
- * is that a number handed to `ingest` arrives in the reply, and that the sum closes on a batch
- * where it is not zero.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { WEBHOOK_STATUS } from '@operato/ops-contract'
-
-import { handleHook, type HookStore } from '../server/service/reference/reference-hook.js'
-import { registerAdapterType, getAdapter } from '../server/service/reference/reference-adapter.js'
-
-const DOMAIN = 'd-1'
-const SOURCE = 'sum-source'
-const TWIN = 'twin-a'
-const SECRET = 'shared-secret'
-
-/** Hands every item straight through — this file is about the counts, not about translation. */
-const ADAPTER_TYPE = 'test-sum-push'
-if (!getAdapter(ADAPTER_TYPE)) {
-  registerAdapterType({
-    type: ADAPTER_TYPE,
-    label: 'sum push (test)',
-    handleInbound: (_cfg: any, _site: any, body: any) => ({ items: body?.items ?? [] })
-  } as any)
-}
-
-function makeStore(): HookStore {
-  const row = {
-    id: 'ref-1',
-    source: SOURCE,
-    adapterType: ADAPTER_TYPE,
-    connectionConfig: { hookSecret: SECRET },
-    scopeSpec: { produced: [{ siteId: 'site-a', instanceId: TWIN }] }
-  }
-  return {
-    load: async (domainId: string, source: string) => (domainId === DOMAIN && source === SOURCE ? row : null),
-    saveCursor: async () => {}
-  } as any
-}
-
-/** `count` unnumbered items — no `scope`, so sequence checking stays out of the way. */
-function items(count: number) {
-  return Array.from({ length: count }, (_v, i) => ({ record: { moverId: `eq-${i}`, kind: 'press', status: 'idle' } }))
-}
-
-function push(count: number, ingest: any) {
-  return handleHook({
-    domainId: DOMAIN,
-    source: SOURCE,
-    instanceId: TWIN,
-    headers: { 'x-twin-hook-secret': SECRET },
-    body: { items: items(count) },
-    nowMs: Date.parse('2026-09-07T02:00:00.000Z'),
-    ingest,
-    store: makeStore()
-  })
-}
-
-/** What the sender is told to check. Written once so every case below reads the same way. */
-function closes(body: any) {
-  return body.offered === body.applied + body.duplicates + (body.rejected?.length ?? 0) + body.vocabulary
-}
-
-test('the sum closes when everything was applied', async () => {
-  const out = await push(3, (_id: string, r: unknown[]) => ({ applied: r.length, duplicates: 0, rejected: [] }))
-
-  assert.equal(out.status, WEBHOOK_STATUS.ok)
-  assert.equal(out.body.offered, 3)
-  assert.equal(out.body.vocabulary, 0)
-  assert.ok(closes(out.body), JSON.stringify(out.body))
-})
-
-test('the sum closes when a batch carried vocabulary — this is the case that failed', async () => {
-  /*
-   * Three offered: two events seated, one vocabulary element. Without `vocabulary` in the reply
-   * the sender sees `3 - 2 - 0 - 0 = 1` and calls it a loss, on traffic that is entirely correct.
-   */
-  const out = await push(3, () => ({ applied: 2, duplicates: 0, rejected: [], vocabulary: 1 }))
-
-  assert.equal(out.body.offered, 3)
-  assert.equal(out.body.applied, 2)
-  assert.equal(out.body.vocabulary, 1, 'the count exists in liveIngest; this boundary must carry it')
-  assert.ok(closes(out.body), JSON.stringify(out.body))
-})
-
-test('a batch that is only vocabulary is not read as a dead twin', async () => {
-  /*
-   * This is what the sum test found, and it was a live defect rather than a missing field.
-   *
-   * The 503 branch inferred "the twin is not running live" from applied, duplicates and rejected
-   * all being zero. A vocabulary-only batch is exactly that shape and yet everything in it
-   * landed, so the receiver answered 503 to correct traffic — and a 503 means hold and retry, so
-   * the sender would have re-sent that batch every thirty seconds indefinitely.
-   *
-   * An absence is not a cause. The fourth term is what tells the two apart.
-   */
-  const out = await push(2, () => ({ applied: 0, duplicates: 0, rejected: [], vocabulary: 2 }))
-
-  assert.equal(out.status, WEBHOOK_STATUS.ok, 'zero events applied is not a twin that stopped')
-  assert.equal(out.body.applied, 0)
-  assert.equal(out.body.vocabulary, 2)
-  assert.ok(closes(out.body), 'zero applied is not zero received')
-})
-
-test('a dead twin is still reported as one — the fourth term did not loosen the check', async () => {
-  /*
-   * Breaking the case above must not cost the case it was guarding. Nothing applied and no
-   * vocabulary either is the real "nothing landed", and it has to keep answering 503: a 200 there
-   * would have the sender mark those facts sent and drop them.
-   */
-  const out = await push(2, () => ({ applied: 0, duplicates: 0, rejected: [], vocabulary: 0 }))
-
-  assert.equal(out.status, WEBHOOK_STATUS.notLive)
-  assert.equal(out.body.retryAfterMs, 30_000, 'hold and come back, do not drop')
-})
-
-test('the sum closes on a partial — the rejected list is a term in it', async () => {
-  const out = await push(3, (_id: string, r: unknown[]) => ({
-    applied: 1,
-    duplicates: 0,
-    rejected: [{ record: r[1], errors: ['no inputQuantityList'] }],
-    vocabulary: 1
-  }))
-
-  assert.equal(out.status, WEBHOOK_STATUS.partial, '422 is what a sender must not resend')
-  assert.equal(out.body.rejected?.length, 1)
-  assert.ok(closes(out.body), JSON.stringify(out.body))
-})
-
-test('duplicates are a term too — a resend is normal here, not a loss', async () => {
-  const out = await push(4, () => ({ applied: 1, duplicates: 3, rejected: [] }))
-
-  assert.equal(out.body.duplicates, 3)
-  assert.ok(closes(out.body))
-})
-
-test('an ingest that says nothing about vocabulary still reports the term', async () => {
-  /*
-   * `vocabulary` is optional on `IngestResult` so a caller that does not count it need not claim
-   * none. The reply must still carry the term: a field that appears only sometimes leaves the
-   * sender unable to tell "none" from "this receiver does not count it", which is the same
-   * ambiguity that made `rejected` guessable.
-   */
-  const out = await push(2, () => ({ applied: 2, duplicates: 0, rejected: [] }))
-
-  assert.equal(out.body.vocabulary, 0)
-  assert.ok('vocabulary' in (out.body as any))
-})
-
-test('seq 178 as it would read now — three offered, two applied', async () => {
-  /*
-   * The real batch: one of the three had no `inputQuantityList` and the kernel was right to
-   * refuse it. What went wrong was that the sender could not read the refusal, so it marked all
-   * three sent. The sum alone says otherwise, whatever shape the rejection list is in.
-   */
-  const out = await push(3, (_id: string, r: unknown[]) => ({
-    applied: 2,
-    duplicates: 0,
-    rejected: [{ record: r[2], errors: ['transformation: inputQuantityList is empty'] }]
-  }))
-
-  assert.equal(out.body.offered, 3)
-  assert.equal(out.body.applied, 2)
-  assert.equal(out.body.offered - out.body.applied - out.body.duplicates - out.body.vocabulary, 1)
-  assert.ok(closes(out.body), 'and the missing one is accounted for by the rejected list')
-})