@starci/jest-preset 2.3.6 → 2.4.0

package/clock.cjs

@@ -1,34 +0,0 @@
-"use strict"
-
-/**
- * `FakeClock` -- the test double for the injected `Clock` port (`platform/clock`).
- *
- * Business code asks its `Clock` port for the time (`clock.now()`) instead of reading `Date.now()` or
- * `new Date()` ambiently (`no-ambient-clock`, R79). A spec then drives time explicitly: it starts the
- * clock at a chosen instant, advances it by a duration, or sets it to a new instant, all without a real
- * sleep and without a race against the wall clock.
- */
-
-class FakeClock {
-  /** @param {Date | number | string} [at] - The instant the clock starts at; defaults to now, once, at construction. */
-  constructor(at) {
-    this._now = at === undefined ? new Date() : new Date(at)
-  }
-
-  /** The current instant, matching the `Clock` port's `now(): Date`. */
-  now() {
-    return new Date(this._now.getTime())
-  }
-
-  /** Moves the clock to `at`. */
-  set(at) {
-    this._now = new Date(at)
-  }
-
-  /** Moves the clock forward by `ms` milliseconds (negative moves it back). */
-  advance(ms) {
-    this._now = new Date(this._now.getTime() + ms)
-  }
-}
-
-module.exports = { FakeClock }

package/clock.d.ts

@@ -1,13 +0,0 @@
-/** The test double for the injected `Clock` port: `{ now(): Date }`, plus spec-only time control. */
-export declare class FakeClock {
-  constructor(at?: Date | number | string)
-
-  /** The current instant. Matches the `Clock` port's `now(): Date`, so `FakeClock` satisfies it structurally. */
-  now(): Date
-
-  /** Moves the clock to `at`. */
-  set(at: Date | number | string): void
-
-  /** Moves the clock forward by `ms` milliseconds (negative moves it back). */
-  advance(ms: number): void
-}

package/entity-manager.cjs

@@ -1,146 +0,0 @@
-"use strict"
-
-/**
- * `mockEntityManager()` and `fakeTransaction()` -- the one typed double of a typeorm `EntityManager`.
- *
- * `mockEntityManager(stubs)` takes the answers a spec describes as `{ method: [Entity, result] }` (`query` takes
- * `[sql, rows]`; several answers of one method are a list of pairs). Every method is a `jest.fn()`, so
- * `expect(em.save).toHaveBeenCalledWith(...)` works, and a method the subject calls that the spec did NOT stub throws
- * `mockEntityManager: em.<method>() was called but this spec did not stub it`. The absence of a stub is therefore the
- * proof that the subject made no such call. A method stubbed for another entity (or another sql text) throws too and names
- * both. Answers of one method and one entity are handed out in order and the last one repeats. There is no typeorm import
- * here: the types come from `entity-manager.d.ts` (type-only), the runtime is a Proxy.
- *
- * `create(Entity, plain)` is pure construction and works without a stub. `transaction` needs `fakeTransaction`.
- *
- * `fakeTransaction(em)` makes `em.transaction(work)` (and `em.transaction(isolation, work)`) run `work` with a scoped view
- * of the same double and record how it ended (`commit` when `work` resolves, `rollback` when it throws and the error is
- * rethrown) and which writes it made, so a spec can assert that a rolled-back transaction committed nothing.
- */
-const { createMock, jestFn } = require("./mock.cjs")
-
-/** The manager views handed to a transaction body; `recordingEventBus` and `recordingQueueOutbox` ask whether a manager is one of them. */
-const TRANSACTION_MANAGERS = new WeakSet()
-
-/** Methods that change data; a write made inside a transaction is recorded on it. */
-const WRITE_METHODS = new Set([
-  "save", "insert", "update", "delete", "remove", "softRemove", "softDelete", "recover", "restore", "upsert",
-  "increment", "decrement", "clear",
-])
-const WRITE_SQL = /^\s*(insert|update|delete|upsert|merge|truncate)\b/i
-
-const describeTarget = (target) => (typeof target === "function" ? target.name || "<anonymous class>" : JSON.stringify(String(target)).slice(0, 80))
-
-const isPair = (value) => Array.isArray(value) && value.length === 2 && (typeof value[0] === "function" || typeof value[0] === "string")
-
-/** `{ method: [target, result] | [[target, result], ...] }` as `Map<method, Array<{ target, result, used }>>`. */
-function tableOf(stubs) {
-  const table = new Map()
-  for (const [method, value] of Object.entries(stubs)) {
-    const pairs = isPair(value) ? [value] : value
-    if (!Array.isArray(pairs) || !pairs.every(isPair)) {
-      throw new Error(`mockEntityManager: the stub of em.${method}() must be [Entity, result] (em.query: [sql, rows]) or a list of such pairs`)
-    }
-    table.set(method, pairs.map(([target, result]) => ({ target, result, used: false })))
-  }
-  return table
-}
-
-/**
- * The kit over a function factory (`makeFn(implementation)`); `mockEntityManager` and `fakeTransaction` below bind it to
- * `jest.fn`. The seam lets the package spec run the kit without a jest runtime.
- */
-function createEntityManagerKit(makeFn) {
-  function answerOf(method, entries) {
-    if (entries === undefined) {
-      return () => {
-        throw new Error(
-          `mockEntityManager: em.${method}() was called but this spec did not stub it. Stub it with mockEntityManager({ ${method}: [Entity, result] }); an unstubbed call means the subject reached the database where the spec says it must not.`,
-        )
-      }
-    }
-    return async (...args) => {
-      const matches = entries.filter((entry) => entry.target === args[0])
-      if (matches.length === 0) {
-        throw new Error(
-          `mockEntityManager: em.${method}(${describeTarget(args[0])}) was called but this spec stubbed em.${method} only for ${entries.map((entry) => describeTarget(entry.target)).join(", ")}`,
-        )
-      }
-      const entry = matches.find((candidate) => !candidate.used) ?? matches[matches.length - 1]
-      entry.used = true
-      return entry.result
-    }
-  }
-
-  /** @param {Record<string, unknown>} [stubs] */
-  function mockEntityManager(stubs = {}) {
-    const table = tableOf(stubs)
-    const create = makeFn((target, plain) => Object.assign(new target(), plain))
-    return createMock((method) => makeFn(answerOf(method, table.get(method))))({ create })
-  }
-
-  /** @param {object} [em] - The double to attach the transaction to; a fresh `mockEntityManager()` by default. */
-  function fakeTransaction(em = mockEntityManager()) {
-    const runs = []
-    const scopedFor = (run) => {
-      const view = new Proxy(em, {
-        get(target, property, receiver) {
-          if (property === "queryRunner") return { get isTransactionActive() { return run.outcome === "pending" } }
-          const value = Reflect.get(target, property, receiver)
-          if (property === "transaction") return (...args) => args[args.length - 1](view)
-          if (typeof property !== "string" || typeof value !== "function") return value
-          if (!WRITE_METHODS.has(property) && property !== "query") return value
-          return (...args) => {
-            if (property !== "query" || WRITE_SQL.test(String(args[0]))) run.writes.push({ method: property, args })
-            return value(...args)
-          }
-        },
-      })
-      TRANSACTION_MANAGERS.add(view)
-      return view
-    }
-    em.transaction = makeFn(async (...args) => {
-      const work = args[args.length - 1]
-      if (typeof work !== "function") throw new Error("fakeTransaction: em.transaction() needs a callback as its last argument")
-      const run = { outcome: "pending", writes: [] }
-      runs.push(run)
-      try {
-        const result = await work(scopedFor(run))
-        run.outcome = "commit"
-        return result
-      } catch (error) {
-        run.outcome = "rollback"
-        throw error
-      }
-    })
-    const writesOf = (outcome) => runs.filter((run) => run.outcome === outcome).flatMap((run) => run.writes)
-    return {
-      em,
-      /** How each transaction ended, in call order: "commit" or "rollback". */
-      get outcomes() {
-        return runs.map((run) => run.outcome)
-      },
-      get commits() {
-        return runs.filter((run) => run.outcome === "commit").length
-      },
-      get rollbacks() {
-        return runs.filter((run) => run.outcome === "rollback").length
-      },
-      /** The writes (`{ method, args }`) that ended in a commit, in call order. */
-      get committedWrites() {
-        return writesOf("commit")
-      },
-      /** The writes that a rollback discarded: made by a body that then threw. */
-      get rolledBackWrites() {
-        return writesOf("rollback")
-      },
-    }
-  }
-
-  return { mockEntityManager, fakeTransaction }
-}
-
-/** Whether `manager` is the scoped view a `fakeTransaction` body received. */
-const isTransactionManager = (manager) => typeof manager === "object" && manager !== null && TRANSACTION_MANAGERS.has(manager)
-
-module.exports = { ...createEntityManagerKit(jestFn), createEntityManagerKit, isTransactionManager }

package/entity-manager.d.ts

@@ -1,103 +0,0 @@
-/// <reference types="jest" />
-import type { DeleteResult, EntityManager, InsertResult, UpdateResult } from "typeorm"
-import type { MockOf } from "./mock"
-
-/** A typed double of `EntityManager`: assignable wherever an `EntityManager` is required, every method a jest mock. */
-export type MockEntityManager = MockOf<EntityManager>
-
-/** An entity class. */
-export type EntityClass<E extends object = object> = new (...args: never[]) => E
-
-type Row<C extends EntityClass> = InstanceType<C>
-type Write<T> = Partial<Omit<T, "raw">> & { readonly raw?: unknown }
-
-/** The result type of each entity-taking `EntityManager` method, for the entity class `C`. */
-export interface EntityAnswers<C extends EntityClass> {
-  findOne: Row<C> | null
-  findOneBy: Row<C> | null
-  findOneOrFail: Row<C>
-  findOneByOrFail: Row<C>
-  find: ReadonlyArray<Row<C>>
-  findBy: ReadonlyArray<Row<C>>
-  findAndCount: readonly [ReadonlyArray<Row<C>>, number]
-  findAndCountBy: readonly [ReadonlyArray<Row<C>>, number]
-  count: number
-  countBy: number
-  exists: boolean
-  existsBy: boolean
-  save: Row<C> | ReadonlyArray<Row<C>>
-  remove: Row<C> | ReadonlyArray<Row<C>>
-  softRemove: Row<C> | ReadonlyArray<Row<C>>
-  recover: Row<C> | ReadonlyArray<Row<C>>
-  insert: Write<InsertResult>
-  update: Write<UpdateResult>
-  upsert: Write<InsertResult>
-  delete: Write<DeleteResult>
-  softDelete: Write<UpdateResult>
-  restore: Write<UpdateResult>
-  increment: Write<UpdateResult>
-  decrement: Write<UpdateResult>
-}
-
-/** The methods a spec may stub as `[Entity, result]`. */
-export type EntityMethod = keyof EntityAnswers<EntityClass>
-
-type Pair<M extends EntityMethod, C extends EntityClass> = readonly [entity: C, result: EntityAnswers<C>[M]]
-type Untyped = readonly [unknown, unknown]
-
-/** One stub: `[Entity, result]` (`query`: `[sql, rows]`), or a list of such pairs answered in order. */
-export type StubOf<M extends string, V> = M extends "query"
-  ? readonly [sql: string, rows: unknown] | ReadonlyArray<readonly [sql: string, rows: unknown]>
-  : M extends EntityMethod
-    ? V extends readonly [infer C extends EntityClass, unknown]
-      ? Pair<M, C>
-      : V extends ReadonlyArray<readonly [infer C extends EntityClass, unknown]>
-        ? ReadonlyArray<Pair<M, C>>
-        : never
-    : never
-
-/** The stubs of a spec, checked entry by entry against the entity each one names. */
-export type StubsOf<S> = { readonly [M in keyof S & string]: StubOf<M, S[M]> }
-
-/**
- * A strict `EntityManager` double. Describe what the subject should see, `{ findOne: [OrderEntity, order] }`; any method
- * the subject calls that the spec did not stub throws an error naming the method, and a wrong entity or sql text throws
- * too. Results are typed against the entity: `findOne: [OrderEntity, 5]` is a compile error.
- */
-export declare function mockEntityManager<
-  const S extends { readonly [M in string]?: Untyped | ReadonlyArray<Untyped> } = Record<never, never>,
->(stubs?: S & StubsOf<S>): MockEntityManager
-
-/** A write made inside a transaction. */
-export interface TransactionWrite {
-  readonly method: string
-  readonly args: ReadonlyArray<unknown>
-}
-
-/** The transaction attached to a double by `fakeTransaction`. */
-export interface FakeTransaction<M extends MockEntityManager = MockEntityManager> {
-  /** The double whose `transaction(work)` runs `work`. */
-  readonly em: M
-  /** How each transaction ended, in call order. */
-  readonly outcomes: ReadonlyArray<"commit" | "rollback" | "pending">
-  /** Number of transactions that committed. */
-  readonly commits: number
-  /** Number of transactions that rolled back (the callback threw; the error was rethrown). */
-  readonly rollbacks: number
-  /** The writes of the transactions that committed. */
-  readonly committedWrites: ReadonlyArray<TransactionWrite>
-  /** The writes of the transactions that rolled back: what a real rollback would have discarded. */
-  readonly rolledBackWrites: ReadonlyArray<TransactionWrite>
-}
-
-/** Makes `em.transaction(work)` run `work` with a scoped view whose queryRunner stays active until commit or rollback. */
-export declare function fakeTransaction<M extends MockEntityManager = MockEntityManager>(em?: M): FakeTransaction<M>
-
-/** Whether `manager` is the view a `fakeTransaction` body received (used by `recordingEventBus` and `recordingQueueOutbox`). */
-export declare function isTransactionManager(manager: unknown): boolean
-
-/** The kit over a function factory, for callers that bring their own (used by the package spec). */
-export declare function createEntityManagerKit(makeFn: (implementation?: (...args: never[]) => unknown) => unknown): {
-  mockEntityManager: typeof mockEntityManager
-  fakeTransaction: typeof fakeTransaction
-}

package/event-bus.cjs

@@ -1,100 +0,0 @@
-"use strict"
-
-/**
- * `recordingEventBus()` -- an `EventBus` double that records what a domain service publishes, so a spec asserts on `bus.events`.
- *
- * `publish(event, tx)` records the event with the manager it was written through. `events` is what the outbox would hold: one
- * event per (event name, event id), like the real unique key, so a duplicate publication keeps one. `writes` is every call, duplicates
- * included, and `entries` adds `inTransaction`: whether `tx` was the view a `fakeTransaction` body received, so a spec proves an event
- * is published in the transaction of the change that caused it. The name of an event is the static `eventName` of its class.
- *
- * The read side is scripted: `setPendingRetries(count)` sets what `pendingRetries(eventClass)` answers, `deadLetters(eventClass)`
- * returns what `queueDeadLetters(...letters)` filled, `requeue(id)` records the id, and `failNext(operation, error)` makes the next
- * call of that operation reject once, so a spec drives the failure path.
- */
-const { isTransactionManager } = require("./entity-manager.cjs")
-
-const nameOf = (event) => event.constructor.eventName
-
-function recordingEventBus() {
-  const written = []
-  const letters = []
-  const requeued = []
-  const failures = new Map()
-  let pending = 0
-  const failIfScripted = (operation) => {
-    if (!failures.has(operation)) return
-    const error = failures.get(operation)
-    failures.delete(operation)
-    throw error
-  }
-  return {
-    async publish(event, tx) {
-      failIfScripted("publish")
-      written.push({ event, tx, inTransaction: isTransactionManager(tx) })
-    },
-    async pendingRetries() {
-      failIfScripted("pendingRetries")
-      return pending
-    },
-    async deadLetters(eventClass) {
-      failIfScripted("deadLetters")
-      return letters.filter((letter) => letter.eventName === eventClass.eventName)
-    },
-    async requeue(id) {
-      failIfScripted("requeue")
-      requeued.push(id)
-    },
-    /** The events the outbox would hold: the first publication of each (event name, event id). */
-    get events() {
-      const seen = new Set()
-      return written
-        .filter(({ event }) => {
-          const key = `${nameOf(event)}\u0000${event.eventId}`
-          if (seen.has(key)) return false
-          seen.add(key)
-          return true
-        })
-        .map(({ event }) => event)
-    },
-    /** Every publication, in order: `{ event, tx, inTransaction }`. */
-    get entries() {
-      return [...written]
-    },
-    /** Every event published, duplicates included. */
-    get writes() {
-      return written.map(({ event }) => event)
-    },
-    /** True when something was published and every publication went through a transaction manager. */
-    get allInTransaction() {
-      return written.length > 0 && written.every((entry) => entry.inTransaction)
-    },
-    /** The stored events of one class. */
-    eventsOf(eventClass) {
-      return this.events.filter((event) => nameOf(event) === eventClass.eventName)
-    },
-    /** Sets the answer of `pendingRetries`. */
-    setPendingRetries(count) {
-      pending = count
-    },
-    /** Adds dead letters `deadLetters` hands out. */
-    queueDeadLetters(...items) {
-      letters.push(...items)
-    },
-    /** The ids passed to `requeue`, in order. */
-    get requeued() {
-      return [...requeued]
-    },
-    /** Makes the next call of `operation` reject with `error`, once. */
-    failNext(operation, error) {
-      failures.set(operation, error)
-    },
-    clear() {
-      for (const list of [written, letters, requeued]) list.length = 0
-      pending = 0
-      failures.clear()
-    },
-  }
-}
-
-module.exports = { recordingEventBus }

package/event-bus.d.ts

@@ -1,54 +0,0 @@
-/** An event as the bus port takes it: a class instance with a stable id; its name is the static `eventName` of its class. */
-export interface RecordedEvent {
-  readonly eventId: string
-}
-/** The static side of an event class. */
-export interface RecordedEventClass {
-  readonly eventName: string
-}
-/** One recorded publication. */
-export interface EventWrite<E extends RecordedEvent = RecordedEvent> {
-  readonly event: E
-  readonly tx: unknown
-  /** Whether `tx` was the view a `fakeTransaction` body received. */
-  readonly inTransaction: boolean
-}
-/** A dead letter as the bus port returns it. */
-export interface RecordedDeadLetter {
-  readonly id: string
-  readonly eventName: string
-  readonly eventId: string
-  readonly reason: string
-  readonly attempts: number
-}
-/** The bus operations `failNext` can make reject. */
-export type EventBusOperation = "publish" | "pendingRetries" | "deadLetters" | "requeue"
-
-/** An `EventBus` double that records publications and scripts the read side. */
-export interface RecordingEventBus<E extends RecordedEvent = RecordedEvent> {
-  publish(event: E, tx: unknown): Promise<void>
-  pendingRetries(eventClass: RecordedEventClass): Promise<number>
-  deadLetters(eventClass: RecordedEventClass): Promise<ReadonlyArray<RecordedDeadLetter>>
-  requeue(id: string): Promise<void>
-  /** What the outbox would hold: the first publication of each (event name, event id). */
-  readonly events: ReadonlyArray<E>
-  /** Every publication with its manager, duplicates included. */
-  readonly entries: ReadonlyArray<EventWrite<E>>
-  /** Every event published, duplicates included. */
-  readonly writes: ReadonlyArray<E>
-  /** True when something was published and every publication went through a `fakeTransaction` manager. */
-  readonly allInTransaction: boolean
-  eventsOf(eventClass: RecordedEventClass): ReadonlyArray<E>
-  /** Sets the answer of `pendingRetries`. */
-  setPendingRetries(count: number): void
-  /** Adds dead letters `deadLetters` hands out. */
-  queueDeadLetters(...items: ReadonlyArray<RecordedDeadLetter>): void
-  /** The ids passed to `requeue`. */
-  readonly requeued: ReadonlyArray<string>
-  /** Makes the next call of `operation` reject with `error`, once. */
-  failNext(operation: EventBusOperation, error: Error): void
-  clear(): void
-}
-
-/** The event bus double. */
-export declare function recordingEventBus<E extends RecordedEvent = RecordedEvent>(): RecordingEventBus<E>

package/ids.cjs

@@ -1,41 +0,0 @@
-"use strict"
-
-/**
- * `fakeIds()` -- the test double for the platform ids port (`{ next(): string }`; the production adapter is
- * `randomUUID()` behind the port). Ids are deterministic and UUID-shaped, so a spec can assert on the exact persisted id:
- * the first is `00000000-0000-4000-8000-000000000001`, the second `...0002`, and so on. A `prefix` (1 to 8 hex digits)
- * changes the leading group so two generators in one spec never collide.
- */
-class FakeIds {
-  /** @param {string} [prefix] - 1 to 8 hex digits for the first group; default "00000000". */
-  constructor(prefix = "00000000") {
-    if (!/^[0-9a-f]{1,8}$/i.test(prefix)) throw new Error("fakeIds: the prefix is 1 to 8 hex digits")
-    this._prefix = prefix.padStart(8, "0").toLowerCase()
-    this._issued = []
-  }
-
-  /** The next id. */
-  next() {
-    const n = String(this._issued.length + 1).padStart(12, "0")
-    const id = `${this._prefix}-0000-4000-8000-${n}`
-    this._issued.push(id)
-    return id
-  }
-
-  /** Every id handed out so far, in order. */
-  get issued() {
-    return [...this._issued]
-  }
-
-  /** Starts the sequence over. */
-  reset() {
-    this._issued = []
-  }
-}
-
-/** @param {string} [prefix] */
-function fakeIds(prefix) {
-  return new FakeIds(prefix)
-}
-
-module.exports = { fakeIds, FakeIds }

package/ids.d.ts

@@ -1,13 +0,0 @@
-/** The platform ids port a spec injects `fakeIds()` for: `{ next(): string }`. */
-export declare class FakeIds {
-  constructor(prefix?: string)
-  /** The next deterministic UUID-shaped id. */
-  next(): string
-  /** Every id handed out so far, in order. */
-  readonly issued: ReadonlyArray<string>
-  /** Starts the sequence over. */
-  reset(): void
-}
-
-/** A deterministic id generator: `00000000-0000-4000-8000-000000000001`, `...0002`, ... */
-export declare function fakeIds(prefix?: string): FakeIds

package/inbox.cjs

@@ -1,162 +0,0 @@
-"use strict"
-
-const { isDeepStrictEqual } = require("node:util")
-const { isTransactionManager } = require("./entity-manager.cjs")
-const CLIENT_SWEEP_BATCH = 500
-
-/** The fake carries the production refusal code without depending on an application's error family. */
-const inboxError = (code) => Object.assign(new Error(code), { code })
-
-/** Clone JSON values directly so toJSON cannot change the request or the stored outcome. */
-const snapshot = (value, ancestors = new Set()) => {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return value
-  if (typeof value === "number" && Number.isFinite(value)) return value === 0 ? 0 : value
-  if (typeof value !== "object" || ancestors.has(value)) throw inboxError("IDEMPOTENCY_REQUEST_INVALID")
-  ancestors.add(value)
-  let result
-  if (Array.isArray(value)) result = Array.from(value, (member) => snapshot(member, ancestors))
-  else {
-    const prototype = Object.getPrototypeOf(value)
-    if (prototype !== Object.prototype && prototype !== null) throw inboxError("IDEMPOTENCY_REQUEST_INVALID")
-    result = Object.fromEntries(Object.entries(value).map(([key, member]) => [key, snapshot(member, ancestors)]))
-  }
-  ancestors.delete(value)
-  return result
-}
-
-/**
- * `fakeInbox(clock?)` records delivery and client claims, so a spec asserts deduplication and the transaction passed by
- * its service. Client calls replay JSON outcomes; `clock` gives retention tests a driven claim timestamp.
- *
- * `claim(source, eventId)` answers `true` for the first call of a (source, eventId) pair and `false` for every later one, like the
- * real unique key; `release(source, eventId)` gives an ordinary delivery claim back while preserving client outcomes.
- * `claims` is every claim in order, `claimed` the pairs that are held now, `released` every release, `seen(source, eventId)` marks a
- * pair as already delivered (a redelivery), and `failNext(operation, error)` makes the next call of that operation reject once, so
- * a spec drives the failure path.
- */
-function fakeInbox(clock) {
-  const held = new Set()
-  const claims = []
-  const released = []
-  const clients = new Map()
-  const clientEntries = []
-  const sweeps = []
-  const failures = new Map()
-  const keyOf = (source, eventId) => `${source}\u0000${eventId}`
-  const failIfScripted = (operation) => {
-    if (!failures.has(operation)) return
-    const error = failures.get(operation)
-    failures.delete(operation)
-    throw error
-  }
-  return {
-    async claim(source, eventId) {
-      failIfScripted("claim")
-      claims.push({ source, eventId })
-      const key = keyOf(source, eventId)
-      if (held.has(key)) return false
-      held.add(key)
-      return true
-    },
-    async release(source, eventId) {
-      failIfScripted("release")
-      released.push({ source, eventId })
-      const key = keyOf(source, eventId)
-      if (!clients.has(key)) held.delete(key)
-    },
-    async runClient(request, tx, effect) {
-      failIfScripted("runClient")
-      const { principalId, operation, idempotencyKey } = request
-      if (!principalId.trim() || principalId.includes(":") || !operation.trim() || operation.includes(":")
-        || !idempotencyKey.trim() || idempotencyKey.length > 64) {
-        throw inboxError("IDEMPOTENCY_REQUEST_INVALID")
-      }
-      const source = `client:${principalId}:${operation}`
-      const key = keyOf(source, idempotencyKey)
-      const body = snapshot(request.request)
-      claims.push({ source, eventId: idempotencyKey })
-      clientEntries.push({ source, eventId: idempotencyKey, tx, inTransaction: isTransactionManager(tx) })
-      const previous = clients.get(key)
-      if (previous !== undefined) {
-        if (!isDeepStrictEqual(previous.request, body)) throw inboxError("IDEMPOTENCY_KEY_REUSED")
-        return snapshot(await previous.result)
-      }
-      if (held.has(key)) throw inboxError("IDEMPOTENCY_KEY_REUSED")
-      const entry = { request: body, claimedAt: clock === undefined ? new Date(0) : clock.now(), completed: false }
-      held.add(key)
-      clients.set(key, entry)
-      entry.result = Promise.resolve().then(effect).then((value) => {
-        let stored
-        try {
-          stored = snapshot(value)
-        } catch (cause) {
-          throw Object.assign(inboxError("INBOX_OUTCOME_INVALID"), { cause })
-        }
-        entry.completed = true
-        return stored
-      }).catch((error) => {
-        if (clients.get(key) === entry) {
-          clients.delete(key)
-          held.delete(key)
-        }
-        throw error
-      })
-      return snapshot(await entry.result)
-    },
-    async sweepClients(cutoff, tx) {
-      sweeps.push({ cutoff: new Date(cutoff), tx, inTransaction: isTransactionManager(tx) })
-      failIfScripted("sweepClients")
-      let swept = 0
-      for (const [key, entry] of clients) {
-        if (swept === CLIENT_SWEEP_BATCH) break
-        if (!entry.completed || entry.claimedAt >= cutoff) continue
-        clients.delete(key)
-        held.delete(key)
-        swept += 1
-      }
-      return swept
-    },
-    /** Marks a pair as already claimed, so the next `claim` of it answers `false` (a redelivery). */
-    seen(source, eventId) {
-      held.add(keyOf(source, eventId))
-    },
-    /** Makes the next call of `operation` reject with `error`, once. */
-    failNext(operation, error) {
-      failures.set(operation, error)
-    },
-    /** Every `claim`, in order, duplicates included. */
-    get claims() {
-      return [...claims]
-    },
-    /** The pairs held now: claimed and not released. */
-    get claimed() {
-      return [...held].map((key) => {
-        const [source, eventId] = key.split("\u0000")
-        return { source, eventId }
-      })
-    },
-    /** Every `release`, in order. */
-    get released() {
-      return [...released]
-    },
-    /** Every client claim, including repeats, with the domain transaction it used. */
-    get clientEntries() {
-      return [...clientEntries]
-    },
-    /** Every retention attempt with its cutoff and domain transaction, including a scripted failure. */
-    get sweeps() {
-      return [...sweeps]
-    },
-    clear() {
-      held.clear()
-      claims.length = 0
-      released.length = 0
-      failures.clear()
-      clients.clear()
-      clientEntries.length = 0
-      sweeps.length = 0
-    },
-  }
-}
-
-module.exports = { fakeInbox }