@things-factory/headless-twin 10.0.19 → 10.1.0

package/test/order-and-transaction-split.test.ts

@@ -0,0 +1,107 @@
+/*
+ * ★ **오더 식별자와 거래 식별자는 다른 칸에 든다** — 한 칸에 두 낱말이 들어가던 자리.
+ *
+ * ── 실측 (2026-09-05) ──────────────────────────────────────────────────────
+ * 승격 칸 `order_id` 하나가 두 낱말을 담고 있었다.
+ *
+ *   order.status                order-1                          내부 오더 id
+ *   epcis.TransformationEvent   urn:epc:id:gdti:9521321.403.1    GS1 거래 식별자
+ *
+ * 한 오더의 이력이 **색인 안에서 두 쪽으로 갈라진다.** 어느 이름으로 물어도 절반만 나오고,
+ * 오류는 나지 않는다. 어휘가 섞인 행 10,004개.
+ *
+ * 그 갈라짐이 막은 것은 「이 개체를 어느 레시피로 만들었나」다 — 답은 오더 사건에 이미 있는데
+ * (`recipeKey`, 실측 328,021/328,021), 변환 사건에서 그 오더로 건너갈 색인이 없었다.
+ *
+ * ── 왜 이 검사인가 ────────────────────────────────────────────────────────
+ * 「합치면 편하다」는 힘이 계속 작용한다 — 값을 채우는 관점에서는 한 칸이 간단해 보이고, 실제로
+ * 그 이유로 합쳐져 있었다(옛 주석이 「오더를 스스로 말하는 사건은 그 말을 그대로 쓴다」고 적고
+ * 있었다). 그러니 갈라 둔 것을 **값으로** 못 박는다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { bizTransactionOf, orderOf, twinEventKeys } from '../server/service/twin-event/twin-event-keys.js'
+import { SUBJECT_KINDS, subjectsOf } from '../server/service/twin-subject/event-subjects.js'
+
+const GDTI = 'urn:epc:id:gdti:9521321.403.1'
+
+/** 실측한 변환 사건의 모양 — GDTI 만 있고 오더 id 는 없다. */
+const transformation = {
+  eventType: 'epcis.TransformationEvent',
+  data: {
+    type: 'TransformationEvent',
+    inputEPCList: ['urn:epc:id:sgtin:9521321.011111.1'],
+    outputEPCList: ['urn:epc:id:sgtin:9521321.033333.1'],
+    bizTransactionList: [{ type: 'urn:epcglobal:cbv:btt:prodorder', bizTransaction: GDTI }]
+  }
+}
+
+/** 실측한 오더 사건의 모양 — 둘 다 든다. 이것이 다리다. */
+const orderStatus = {
+  eventType: 'order.status',
+  data: { orderId: 'order-1', status: 'created', recipeKey: 'trailer', bizTransaction: GDTI }
+}
+
+/* ── 갈라져 있나 ─────────────────────────────────────────────────────────── */
+
+test('★ 변환 사건의 GDTI 는 거래 칸에 든다 — 오더 칸에 앉지 않는다', () => {
+  assert.equal(bizTransactionOf(transformation), GDTI)
+  assert.equal(orderOf(transformation), undefined, 'GDTI 가 오더 식별자 자리에 앉았다')
+})
+
+test('★ 오더 사건은 두 칸을 다 든다 — 이것이 EPCIS 에서 오더로 건너가는 다리다', () => {
+  const keys = twinEventKeys(orderStatus)
+  assert.equal(keys.orderId, 'order-1')
+  assert.equal(keys.bizTransaction, GDTI)
+})
+
+test('★ 두 사건이 같은 거래 값으로 이어진다 — 문자열까지 같아야 색인이 잇는다', () => {
+  /*
+   * 이 검사가 이 변경의 목적이다. 값이 한 글자라도 다르면 색인 조회가 0을 내고, 그 0은
+   * 「그런 오더가 없다」와 구별되지 않는다.
+   */
+  assert.equal(twinEventKeys(transformation).bizTransaction, twinEventKeys(orderStatus).bizTransaction)
+})
+
+test('★ 오더 사건에서 레시피를 읽을 수 있다 — 짐작하지 않아도 되는 근거', () => {
+  /* 자재로 되짚어 첫 레시피를 고르던 자리가 이 값으로 대체된다. */
+  assert.equal((orderStatus.data as any).recipeKey, 'trailer')
+})
+
+/* ── 합쳐지지 않았나 ──────────────────────────────────────────────────────── */
+
+test('★ 오더 칸이 거래로 되돌아가지 않는다 — 옛 되돌림(fallback)이 살아나면 빨강', () => {
+  /*
+   * 옛 코드: `d.orderId ?? d.bizTransactionList?.[0]?.bizTransaction`.
+   * 그 한 줄이 돌아오면 아래가 GDTI 를 내고, 두 낱말이 다시 한 칸에 든다.
+   */
+  const onlyTx = { eventType: 'epcis.ObjectEvent', data: { bizTransactionList: [{ bizTransaction: GDTI }] } }
+  assert.equal(orderOf(onlyTx), undefined, '오더 칸이 거래 값으로 되돌아간다')
+  assert.equal(bizTransactionOf(onlyTx), GDTI)
+})
+
+test('★ 주체 표도 갈라 적는다 — 거래가 오더 이름으로 앉지 않는다', () => {
+  const subjects = subjectsOf(transformation)
+  const kinds = (id: string) => subjects.filter(s => s.id === id).map(s => s.kind)
+
+  assert.deepEqual(kinds(GDTI), ['transaction'], `GDTI 가 붙은 종류가 다르다: ${JSON.stringify(subjects)}`)
+  assert.ok(SUBJECT_KINDS.includes('transaction' as any), '거래 종류가 목록에 없다')
+})
+
+test('★ 오더 사건은 두 주체를 다 낸다', () => {
+  const subjects = subjectsOf(orderStatus)
+  const has = (kind: string, id: string) => subjects.some(s => s.kind === kind && s.id === id)
+
+  assert.ok(has('order', 'order-1'), `오더 주체가 없다: ${JSON.stringify(subjects)}`)
+  assert.ok(has('transaction', GDTI), `거래 주체가 없다: ${JSON.stringify(subjects)}`)
+})
+
+/* ── 검사가 실제로 무언가를 재나 ─────────────────────────────────────────── */
+
+test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
+  const keys = twinEventKeys(orderStatus)
+  assert.ok(Object.values(keys).filter(v => v !== undefined).length >= 3, `승격 키를 ${JSON.stringify(keys)} 만 뽑았다`)
+  assert.ok(subjectsOf(orderStatus).length >= 2, '주체가 둘도 안 나왔다')
+  assert.ok(subjectsOf(transformation).length >= 1, '변환 사건에서 주체가 하나도 안 나왔다')
+})

package/test/reference-fill.test.ts

@@ -0,0 +1,235 @@
+/*
+ * **놓친 구간을 backfill 해 채운다** — 그 길이 없었다.
+ *
+ * ── 무엇이 있었나 (2026-08-31, 인티그레이션 레인 지적) ────────────────────
+ * 번호로 「빠졌다」를 알아채게 만들었는데, 알아챈 뒤 **그 사이를 채우는 길이 없었다.** 설계가 적어 둔
+ * 길이고 양쪽이 다 읽었는데 만들지 않았다.
+ *
+ * ── 되풀이해 요청하는 경로에서 무너지는 것 ─────────────────────────────────────
+ * 행복한 길은 짧다. 무너지는 것은 **끝나지 않는 것**이다.
+ *
+ *   빈 답에 물어본 번호를 그대로 돌려주는 원본  → 무한히 요청한다
+ *   구멍 뒤를 이어 받는다                      → 커서가 그 번호를 지나쳐 적히고 빠진 사실은 안 온다
+ *   상한에 닿았는데 조용히 끝낸다               → 사람은 다 받은 줄로 읽는다
+ *
+ * 셋 다 오류가 나지 않는다. 그래서 시험이 셋을 만든다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { fillSince } from '../server/service/reference/reference-fill.js'
+import { pushCursorKey, seqOf } from '../server/service/reference/hook-contract.js'
+import type { InboundBatch } from '../server/service/reference/reference-adapter.js'
+
+const CFG = { baseUrl: 'x' }
+const SITE = { siteId: 's-1' }
+const SCOPE = 'EVENTS'
+const KEY = pushCursorKey('twin-a', SCOPE)
+
+/** 번호가 붙은 봉투 한 쪽. */
+const page = (seqs: number[], scope: string = SCOPE): InboundBatch => ({
+  scope,
+  items: seqs.map(seq => ({ seq, record: { moverId: `eq-${seq}`, kind: 'press', status: 'idle' } }))
+})
+
+/** 저장본 하나 — 프로세스가 아니라 여기 산다. */
+function harness(initial?: unknown) {
+  const state = { cursor: initial as unknown, saves: 0, ingested: [] as unknown[][] }
+  return {
+    state,
+    saveCursor: async (c: Record<string, unknown>) => {
+      state.saves++
+      state.cursor = JSON.parse(JSON.stringify(c))
+    },
+    ingest: (records: unknown[]) => {
+      state.ingested.push(records)
+      return { applied: records.length, duplicates: 0, rejected: [] }
+    }
+  }
+}
+
+const run = (h: ReturnType<typeof harness>, fetch: any, maxPages?: number) =>
+  fillSince({
+    cfg: CFG,
+    site: SITE,
+    scope: SCOPE,
+    cursorKey: KEY,
+    cursor: h.state.cursor,
+    fetch,
+    ingest: h.ingest,
+    saveCursor: h.saveCursor,
+    ...(maxPages ? { maxPages } : {})
+  })
+
+/* ── 채운다 ───────────────────────────────────────────────────────────────── */
+
+test('★ 커서 다음부터 요청하고 받은 데까지 커서를 올린다', async () => {
+  const h = harness({ streams: { [KEY]: { seq: 4 } } })
+  const asked: number[] = []
+  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
+    asked.push(since)
+    return since === 4 ? page([5, 6]) : page([])
+  })
+
+  assert.deepEqual(asked, [4, 6], '받은 데부터 다시 요청한다')
+  assert.equal(out.applied, 2)
+  assert.equal(out.stopped, 'done')
+  assert.equal(seqOf(h.state.cursor, KEY), 6)
+})
+
+test('★ 커서가 없으면 0부터 요청한다. 처음 채우는 것이다', async () => {
+  const h = harness()
+  const asked: number[] = []
+  await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
+    asked.push(since)
+    return since === 0 ? page([1, 2, 3]) : page([])
+  })
+  assert.equal(asked[0], 0)
+  assert.equal(seqOf(h.state.cursor, KEY), 3)
+})
+
+test('여러 쪽을 이어 받는다', async () => {
+  const h = harness()
+  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
+    if (since === 0) return page([1, 2])
+    if (since === 2) return page([3, 4])
+    return page([])
+  })
+  assert.equal(out.applied, 4)
+  assert.equal(out.pages >= 2, true)
+  assert.equal(seqOf(h.state.cursor, KEY), 4)
+})
+
+/* ── 끝나지 않는 것을 막는다 ──────────────────────────────────────────────── */
+
+test('★ 번호가 나아가지 않으면 멈춘다 — 같은 것을 다시 주는 원본에 무한히 요청하지 않는다', async () => {
+  /*
+   * 아웃박스 계약이 「빈 묶음에는 물어본 번호를 그대로 돌려준다」이므로, 나아감을 보지 않고 요청하면
+   * 영원히 돈다. 실제로 그 계약을 쓰는 상대가 있다.
+   */
+  const h = harness({ streams: { [KEY]: { seq: 4 } } })
+  let calls = 0
+  const out = await run(h, async () => {
+    calls++
+    /* 이미 받은 번호만 돌려준다 — 커서가 나아가지 않는다. */
+    return page([3, 4])
+  })
+
+  assert.equal(out.stopped, 'no-progress')
+  assert.ok(calls <= 2, `무한히 요청했다 — ${calls}번`)
+  assert.match(String(out.detail), /나아가지 않았다/)
+})
+
+test('★ 빈 답은 끝이고 오류가 아니다', async () => {
+  const h = harness({ streams: { [KEY]: { seq: 9 } } })
+  const out = await run(h, async () => page([]))
+  assert.equal(out.stopped, 'done')
+  assert.equal(out.applied, 0)
+  assert.equal(out.detail, undefined)
+})
+
+/* ── 구멍 ─────────────────────────────────────────────────────────────────── */
+
+test('★ 구멍이 있으면 그 앞까지만 넣고 멈춘다 — 이어 받으면 빠진 사실이 다시 오지 않는다', async () => {
+  const h = harness({ streams: { [KEY]: { seq: 4 } } })
+  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) =>
+    since === 4 ? page([5, 6, 9, 10]) : page([])
+  )
+
+  assert.equal(out.stopped, 'gap')
+  assert.equal(out.applied, 2, '5·6 만 넣는다')
+  assert.equal(seqOf(h.state.cursor, KEY), 6, '커서가 구멍을 지나치지 않는다')
+  assert.match(String(out.detail), /6 다음이 7/)
+})
+
+test('★ 첫 봉투부터 구멍이면 아무것도 넣지 않고 커서도 그대로다', async () => {
+  const h = harness({ streams: { [KEY]: { seq: 4 } } })
+  const out = await run(h, async () => page([9, 10]))
+
+  assert.equal(out.stopped, 'gap')
+  assert.equal(out.applied, 0)
+  assert.equal(seqOf(h.state.cursor, KEY), 4)
+  assert.equal(h.state.ingested.length, 0, '넣을 것이 없는데 유입을 불렀다')
+})
+
+/* ── 상한 ─────────────────────────────────────────────────────────────────── */
+
+test('★ 쪽 상한에 닿으면 말한다 — 조용히 자르면 사람은 다 받은 줄로 읽는다', async () => {
+  const h = harness()
+  let n = 0
+  const out = await run(h, async () => page([++n]), 3)
+
+  assert.equal(out.stopped, 'page-limit')
+  assert.equal(out.pages, 3)
+  assert.match(String(out.detail), /남은 것이 있을 수 있다/)
+})
+
+/* ── 거절 ─────────────────────────────────────────────────────────────────── */
+
+test('★ backfill 이 실패하면 이유를 남기고 멈춘다 — 커서는 받은 데까지다', async () => {
+  const h = harness({ streams: { [KEY]: { seq: 4 } } })
+  const out = await run(h, async (_c: any, _s: any, _sc: string, since: number) => {
+    if (since === 4) return page([5])
+    throw new Error('MES 가 응답하지 않는다')
+  })
+
+  assert.equal(out.stopped, 'refused')
+  assert.match(String(out.detail), /응답하지 않는다/)
+  assert.equal(seqOf(h.state.cursor, KEY), 5, '받은 것은 지킨다')
+})
+
+test('★ 번호가 섞인 쪽은 받지 않는다 — 밀어 받는 길과 같은 검사를 지난다', async () => {
+  const h = harness()
+  const out = await run(h, async () => ({
+    scope: SCOPE,
+    items: [{ seq: 1, record: {} }, { record: {} }]
+  }))
+
+  assert.equal(out.stopped, 'refused')
+  assert.match(String(out.detail), /mixed batch/)
+  assert.equal(h.state.ingested.length, 0)
+})
+
+test('★ 커서 열쇠에 트윈이 들어간다 — 한 연결의 두 공장이 계수기를 함께 쓰지 않는다', async () => {
+  const other = pushCursorKey('twin-b', SCOPE)
+  const h = harness({ streams: { [KEY]: { seq: 4 }, [other]: { seq: 100 } } })
+  await run(h, async (_c: any, _s: any, _sc: string, since: number) => (since === 4 ? page([5]) : page([])))
+
+  assert.equal(seqOf(h.state.cursor, KEY), 5)
+  assert.equal(seqOf(h.state.cursor, other), 100, '다른 공장의 번호를 건드렸다')
+})
+
+/* ── 원본이 가진 번호 범위 ──────────────────────────────────────────────────── */
+
+test('★ 원본이 말한 번호 범위를 그대로 낸다 — 커서와 견주려면 이 값이 있어야 한다', async () => {
+  const got = await fillSince({
+    cfg: {},
+    site: { siteId: 's' },
+    scope: 'EVENTS',
+    cursorKey: 'i::EVENTS',
+    cursor: {},
+    fetch: async () => ({ items: [{ seq: 1, record: {} }], scope: 'EVENTS', sourceRange: { first: 1, last: 20 } }),
+    ingest: () => ({ applied: 1, duplicates: 0, rejected: [] }),
+    saveCursor: async () => {}
+  })
+  assert.deepEqual(got.sourceRange, { first: 1, last: 20 })
+})
+
+test('★ 원본이 안 말하면 그 칸을 안 낸다 — 0 으로 채우면 「다 받았다」가 된다', async () => {
+  /*
+   * 0 을 넣으면 「원본이 1번부터 다 갖고 있다」로 읽히고, 그것이 거짓이면 「우리가 다 받았다」는
+   * 잘못된 결론이 나온다. 견주는 쪽은 「맞다」가 아니라 「모른다」로 답해야 한다.
+   */
+  const got = await fillSince({
+    cfg: {},
+    site: { siteId: 's' },
+    scope: 'EVENTS',
+    cursorKey: 'i::EVENTS',
+    cursor: {},
+    fetch: async () => ({ items: [{ seq: 1, record: {} }], scope: 'EVENTS' }),
+    ingest: () => ({ applied: 1, duplicates: 0, rejected: [] }),
+    saveCursor: async () => {}
+  })
+  assert.equal(got.sourceRange, undefined)
+  assert.equal('sourceRange' in got, false, '없는 것을 undefined 로 실으면 화면이 칸을 그린다')
+})

package/test/reference-hook.test.ts

@@ -67,7 +67,7 @@ test('★ 그 연결이 만든 트윈만 받는다 — 남의 트윈에 밀어
 
 test('★ 응답 코드 표가 계약에 있다 — 여기에 두 번째 벌을 만들지 않는다', () => {
   /*
-   * 예전에는 이 표가 훅 규약 파일에 있었고 보내는 쪽(operato-mes)에도 있었다. 그래서 같은 409 를 양쪽이
+   * 예전에는 이 표가 훅 규약 파일에 있었고 보내는 쪽(operato-plant)에도 있었다. 그래서 같은 409 를 양쪽이
    * 다른 뜻으로 썼다 — 여기서는 「트윈이 안 돈다」, 저쪽에서는 「번호가 비었다」였다.
    *
    * 값을 여기서 다시 단정하지 않는다. 계약이 정본이고 그 시험은 계약 쪽에 있다. 여기서 지키는 것은

package/test/reference-links.test.ts

@@ -0,0 +1,56 @@
+/*
+ * 원본에만 있는 관계를 화면에 낼 수 있는지 판정하는 부분.
+ *
+ * 조회 자체는 DB 와 어댑터를 물어야 돌아가므로 테스트가 다루지 않는다. 여기서 확인하는 것은
+ * 원본이 준 값을 그대로 믿지 않는다는 것이다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { usableLinkGroups } from '../server/service/reference/reference-link-groups.js'
+
+test('정상 그룹은 그대로 남는다', () => {
+  const got = usableLinkGroups([
+    { via: 'mes.rel.report', from: 'productionReports', tense: 'past', ids: ['PR-1'], total: 2 }
+  ])
+  assert.equal(got.length, 1)
+  assert.equal(got[0].tense, 'past')
+})
+
+test('★ 전체 수가 없는 그룹은 버린다 — 화면이 목록 길이를 전체 수로 쓰게 된다', () => {
+  /*
+   * 원본이 20개만 보내고 전체 수를 빼면, 실제 200건이 화면에 20건으로 표시된다. 오류가 나지
+   * 않으므로 아무도 알아채지 못한다.
+   */
+  const got = usableLinkGroups([{ via: 'mes.rel.report', from: 'x', ids: ['a', 'b'] } as any])
+  assert.equal(got.length, 0)
+})
+
+test('전체 수가 0 인 그룹은 버린다 — 원본이 그 축을 취급하지 않는다는 뜻이다', () => {
+  assert.equal(usableLinkGroups([{ via: 'v', from: 'f', ids: [], total: 0 }]).length, 0)
+})
+
+test('이름이 없는 그룹은 버린다 — 화면에 이름 없는 줄이 된다', () => {
+  const got = usableLinkGroups([
+    { via: '', from: 'f', ids: ['a'], total: 1 },
+    { via: '   ', from: 'f', ids: ['a'], total: 1 },
+    { from: 'f', ids: ['a'], total: 1 } as any
+  ])
+  assert.equal(got.length, 0)
+})
+
+test('원본이 아무것도 안 주거나 목록에 빈 값이 섞여도 견딘다', () => {
+  assert.deepEqual(usableLinkGroups(undefined), [])
+  assert.deepEqual(usableLinkGroups(null), [])
+  assert.equal(usableLinkGroups([null as any, undefined as any]).length, 0)
+})
+
+test('★ 이 테스트가 실제로 무언가를 확인한다 — 통과와 탈락이 둘 다 있어야 한다', () => {
+  const got = usableLinkGroups([
+    { via: 'ok', from: 'f', ids: ['a'], total: 1 },
+    { via: 'no-total', from: 'f', ids: ['a'] } as any,
+    { via: '', from: 'f', ids: ['a'], total: 5 }
+  ])
+  assert.equal(got.length, 1, '통과한 것이 하나여야 한다')
+  assert.equal(got[0].via, 'ok')
+})

package/test/retry-plan.test.ts

@@ -0,0 +1,139 @@
+/*
+ * ★ **다시 넘길 것인가, 언제인가** — 일꾼의 판단 전부.
+ *
+ * ── 왜 이 판단이 필요한가 (2026-09-04) ─────────────────────────────────────
+ * 승인 직후에 한 번 보내는 것만 있었다. 그래서 **커밋과 발신 사이에 프로세스가 죽으면** 그
+ * 조치는 `approved` 로 남고 스스로 나가지 않았다. 그리고 실패한 것을 다시 보내는 것은 사람이
+ * 시켜야 했다.
+ *
+ * ── 실패가 다 같지 않다 (2026-09-02 실측) ──────────────────────────────────
+ * 저쪽 인증 정보가 없어 503 이었던 것(고치면 됨)과 `ITEM-1` 이 400 이었던 것(고쳐도 이 조치로는
+ * 안 됨)이 같은 모양이었다. 다 다시 하면 없는 자재를 끝없이 두드리고, 다 포기하면 저쪽을 고쳐
+ * 놓고도 안 나간다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  AFTER_FIX_PERIOD_MS,
+  AGAIN_BACKOFF_MS,
+  retryDecisionOf
+} from '../server/service/actuation/retry-plan.js'
+
+const NOW = 1_800_000_000_000
+const at = (over: Record<string, unknown> = {}) =>
+  retryDecisionOf({ state: 'failed', dispatchable: true, nowMs: NOW, ...over } as any)
+
+/* ── 첫 시도 — 승인 직후 발신이 놓친 것을 줍는다 ─────────────────────────── */
+
+test('★ 승인됐는데 한 번도 안 나간 것은 바로 집는다 — 그 창이 이 일꾼의 존재 이유다', () => {
+  const d = at({ state: 'approved', attempts: 0 })
+
+  assert.equal(d.take, true)
+  assert.equal(d.attempt, 1)
+})
+
+test('★ 첫 시도는 멱등을 묻지 않는다 — 한 번뿐이라 두 건이 설 수 없다', () => {
+  assert.equal(at({ state: 'approved', attempts: 0, idempotent: false }).take, true)
+})
+
+test('★ 첫 시도는 어댑터의 답을 묻지 않는다 — 아직 아무 답도 하지 않았다', () => {
+  assert.equal(at({ state: 'approved' }).take, true)
+})
+
+/* ── 재시도 — 모르면 넘기지 않는다 ──────────────────────────────────────── */
+
+test('★ 어댑터가 다시 될 일인지 말하지 않았으면 집지 않는다 — 「never」로 접지도 않는다', () => {
+  /*
+   * 모르는 것을 `never` 로 접으면 고칠 수 있는 것을 사람이 포기한다. 그래서 집지 않고 목록에
+   * 「모름」으로 남긴다 — 사람이 보고 정한다.
+   */
+  const d = at({ attempts: 1, idempotent: true })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'outlook-unknown')
+})
+
+test('★ 멱등을 선언하지 않은 커넥터는 재시도하지 않는다 — 현장에 지시가 두 건 서면 안 된다', () => {
+  const d = at({ attempts: 1, retry: 'again' })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'not-idempotent')
+})
+
+test('★ 영원히 안 될 것은 집지 않는다 — 사람이 새 조치를 내야 한다', () => {
+  const d = at({ attempts: 1, retry: 'never', idempotent: true })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'never', '우리 쪽에 고칠 것이 없다는 뜻이다')
+})
+
+/* ── `again` — 짧게 세 번, 그다음 접는다 ────────────────────────────────── */
+
+test('★ 물러서면서 세 번 한다', () => {
+  for (const [i, expected] of AGAIN_BACKOFF_MS.entries()) {
+    const d = at({ attempts: i, retry: 'again', idempotent: true, state: i === 0 ? 'approved' : 'failed' })
+
+    assert.equal(d.take, true, `${i + 1}번째를 안 했다`)
+    assert.equal(d.attempt, i + 1)
+    assert.equal(Date.parse(d.nextAttemptAt!) - NOW, expected, `${i + 1}번째 물러섬이 다르다`)
+  }
+})
+
+test('★ 세 번을 다 쓰면 접는다 — 끝없이 두드리는 것은 소음이다', () => {
+  const d = at({ attempts: AGAIN_BACKOFF_MS.length, retry: 'again', idempotent: true })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'attempts-spent')
+})
+
+/* ── `after-fix` — 접지 않는다. 이 파일에서 가장 중요한 것 ──────────────── */
+
+test('★ 설정 문제는 횟수로 접지 않는다 — 고쳐 놓고도 손으로 눌러야 하면 안 된다', () => {
+  /*
+   * 2026-09-02 사고가 그 모양이었다: 저쪽이 고쳐진 뒤 사람이 손으로 다시 넘겨서 나갔다.
+   * `after-fix` 는 재시도가 아니라 **기다리는 것**이다.
+   */
+  for (const attempts of [1, 3, 10, 100]) {
+    const d = at({ attempts, retry: 'after-fix', idempotent: true })
+
+    assert.equal(d.take, true, `${attempts}번째에 접었다`)
+    assert.equal(Date.parse(d.nextAttemptAt!) - NOW, AFTER_FIX_PERIOD_MS, '간격이 늘어났다')
+  }
+})
+
+/* ── 물러섬을 표에서 읽는다 ─────────────────────────────────────────────── */
+
+test('★ 아직 이르면 기다린다', () => {
+  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: new Date(NOW + 10_000).toISOString() })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'backing-off')
+})
+
+test('★ 때가 되면 집는다', () => {
+  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: new Date(NOW - 1).toISOString() })
+
+  assert.equal(d.take, true)
+})
+
+test('★ 읽을 수 없는 시각으로 막지 않는다 — 막으면 그 조치가 표에 갇힌다', () => {
+  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: '언젠가' })
+
+  assert.equal(d.take, true)
+})
+
+/* ── 넘길 수 없는 상태 ──────────────────────────────────────────────────── */
+
+test('★ 종착이면 아무것도 하지 않는다', () => {
+  const d = at({ state: 'acked', dispatchable: false, attempts: 1, retry: 'again', idempotent: true })
+
+  assert.equal(d.take, false)
+  assert.equal(d.skip, 'not-dispatchable')
+})
+
+test('넘길 수 없으면 다른 어떤 값도 그것을 뒤집지 않는다', () => {
+  for (const retry of ['again', 'after-fix', 'never', undefined]) {
+    assert.equal(at({ dispatchable: false, attempts: 0, retry, idempotent: true }).skip, 'not-dispatchable')
+  }
+})