@boxxy/dispatch 0.1.0 → 0.1.3

package/dist/outbox/types.d.ts

@@ -0,0 +1,61 @@
+import type { ClaimStore, Clock, FactSink, Instant, OutboxFact, OutboxStatus } from '@boxxy/model';
+export interface OutboxLimits {
+    readonly batchFacts: 100;
+    readonly factBytes: 262_144;
+    readonly batchBytes: 900_000;
+    readonly envelopeBytes: 512;
+    readonly requestTimeoutMs: 10_000;
+    readonly backoff: {
+        readonly firstMs: 1000;
+        readonly factor: 2;
+        readonly maxMs: 300_000;
+        readonly jitter: 0.2;
+    };
+    readonly blockedRetryMs: 300_000;
+    readonly parkRun: 25;
+}
+export type TakenBatch = {
+    readonly kind: 'batch';
+    readonly facts: readonly OutboxFact[];
+} | {
+    readonly kind: 'oversize';
+    readonly fact: OutboxFact;
+};
+export type SenderMove = {
+    readonly kind: 'mark-sent';
+} | {
+    readonly kind: 'retry-same';
+} | {
+    readonly kind: 'split';
+} | {
+    readonly kind: 'park';
+    readonly reason: string;
+} | {
+    readonly kind: 'block';
+    readonly reason: string;
+};
+export type SenderStep = 'idle' | 'stored' | 'retry' | 'split' | 'parked' | 'blocked';
+type SenderPhase = 'idle' | 'backing-off' | 'blocked';
+type LastError = NonNullable<OutboxStatus['lastError']>;
+export interface SenderState {
+    readonly queue: readonly (readonly OutboxFact[])[];
+    readonly retries: number;
+    readonly parkRun: number;
+    readonly phase: SenderPhase;
+    readonly failingSince: Instant | null;
+    readonly nextTryAt: Instant | null;
+    readonly lastError: LastError | null;
+    readonly lastStoredAt: Instant | null;
+}
+export interface SenderDeps {
+    readonly store: ClaimStore;
+    readonly sink: FactSink;
+    readonly clock: Clock;
+    readonly limits: OutboxLimits;
+    readonly random: () => number;
+}
+export interface SenderTurn {
+    readonly step: SenderStep;
+    readonly state: SenderState;
+}
+export {};

package/dist/pull-requests/build-link-change.d.ts

@@ -0,0 +1,11 @@
+import type { ActorRef, AttemptRow, Instant, NewId, PullRequestReading, PullRequestRef, StoreChange } from '@boxxy/model';
+export interface LinkChangeInput {
+    readonly attempt: AttemptRow;
+    readonly ref: PullRequestRef;
+    readonly reading: PullRequestReading;
+    readonly source: 'hook' | 'watch';
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export declare function buildLinkChange(input: LinkChangeInput): StoreChange;

package/dist/pull-requests/build-state-fact.d.ts

@@ -0,0 +1,8 @@
+import type { ActorRef, AnyNewFact, FactId, ItemId, PullRequestRow } from '@boxxy/model';
+export interface StateFactInput {
+    readonly row: PullRequestRow;
+    readonly item: ItemId;
+    readonly actor: ActorRef;
+    readonly id: FactId;
+}
+export declare function buildStateFact(input: StateFactInput): AnyNewFact | null;

package/dist/pull-requests/collect-attempt-trailers.d.ts

@@ -0,0 +1,2 @@
+import type { AttemptId } from '@boxxy/model';
+export declare function collectAttemptTrailers(message: string): AttemptId[];

package/dist/pull-requests/collect-seen-state.d.ts

@@ -0,0 +1,7 @@
+import type { CommitSha, Instant, PullRequestReading, PullRequestRow } from '@boxxy/model';
+export interface SeenState {
+    readonly state: PullRequestRow['state'];
+    readonly mergedAt: Instant | null;
+    readonly mergeCommit: CommitSha | null;
+}
+export declare function collectSeenState(reading: PullRequestReading): SeenState;

package/dist/pull-requests/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const watchLimits: {
+    readonly linkWindowMs: number;
+};

package/dist/pull-requests/link-pull-request.d.ts

@@ -0,0 +1,2 @@
+import type { LinkPullRequestInput, LinkPullRequestResult } from './types.ts';
+export declare function linkPullRequest(input: LinkPullRequestInput): Promise<LinkPullRequestResult>;

package/dist/pull-requests/parse-pull-request-url.d.ts

@@ -0,0 +1,2 @@
+import type { PullRequestRef } from '@boxxy/model';
+export declare function parsePullRequestUrl(url: string): PullRequestRef | null;

package/dist/pull-requests/types.d.ts

@@ -0,0 +1,37 @@
+import type { ClaimStore, Forge, Instant, ItemRules, NewId, RepoName, RunnerId } from '@boxxy/model';
+import type { CallRef } from '../closeouts/types.ts';
+export interface LinkPullRequestInput {
+    readonly store: ClaimStore;
+    readonly forge: Forge;
+    readonly rules: ItemRules;
+    readonly call: CallRef;
+    readonly url: string;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export type LinkPullRequestResult = {
+    readonly kind: 'linked';
+    readonly repo: RepoName;
+    readonly number: number;
+    readonly repeat: boolean;
+} | {
+    readonly kind: 'retry';
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'not-a-pull-request-url' | 'linked-elsewhere' | 'no-attempt' | 'not-current';
+};
+export interface WatchPullRequestsInput {
+    readonly store: ClaimStore;
+    readonly forge: Forge;
+    readonly rules: ItemRules;
+    readonly runner: RunnerId;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export interface WatchReport {
+    readonly linked: number;
+    readonly commitsLinked: number;
+    readonly merged: number;
+    readonly closed: number;
+    readonly unanswered: number;
+}

package/dist/pull-requests/watch-pull-requests.d.ts

@@ -0,0 +1,2 @@
+import type { WatchPullRequestsInput, WatchReport } from './types.ts';
+export declare function watchPullRequests(input: WatchPullRequestsInput): Promise<WatchReport>;

package/dist/readings/act-on-reading.d.ts

@@ -0,0 +1,3 @@
+import type { SessionFault } from '@boxxy/model';
+import type { ActOnReadingInput } from './types.ts';
+export declare function actOnReading(input: ActOnReadingInput): Promise<SessionFault | null>;

package/dist/readings/find-waiting-since.d.ts

@@ -0,0 +1,9 @@
+import type { AttemptRow, Instant, SessionReading } from '@boxxy/model';
+interface WaitingInput {
+    readonly attempt: AttemptRow;
+    readonly reading: SessionReading;
+    readonly quietAfterMinutes: number;
+    readonly now: Instant;
+}
+export declare function findWaitingSince(input: WaitingInput): Instant | null;
+export {};

package/dist/readings/pick-reading-action.d.ts

@@ -0,0 +1,2 @@
+import type { ReadingAction, ReadingInput } from './types.ts';
+export declare function pickReadingAction(input: ReadingInput): ReadingAction;

package/dist/readings/types.d.ts

@@ -0,0 +1,79 @@
+import type { AttemptRow, CapacityBackoff, ClaimStore, ForcedFailure, Instant, LiveAttemptState, LoadedRules, NewId, PipelineStep, SessionReading, SleepRules, WakeSource, WorkerKind } from '@boxxy/model';
+export type ReadingAction = {
+    readonly kind: 'nothing';
+} | {
+    readonly kind: 'bind-only';
+} | {
+    readonly kind: 'move-to-running';
+    readonly via: 'reconcile' | 'resume';
+} | {
+    readonly kind: 'respawn';
+} | {
+    readonly kind: 'clear-mark';
+} | {
+    readonly kind: 'sleep-if-idle';
+    readonly waitingSince: Instant;
+} | {
+    readonly kind: 'sleep-unattended';
+    readonly since: Instant;
+} | {
+    readonly kind: 'await-spawn';
+} | {
+    readonly kind: 'sleep';
+    readonly requestWake: boolean;
+} | {
+    readonly kind: 'request-wake';
+    readonly by: WakeSource;
+} | {
+    readonly kind: 'wake-over-cap';
+} | {
+    readonly kind: 'resume';
+} | {
+    readonly kind: 'close';
+    readonly cause: 'timed-out';
+    readonly afterMinutes: number;
+} | {
+    readonly kind: 'close';
+    readonly cause: 'turn-ended' | 'stalled';
+} | {
+    readonly kind: 'close';
+    readonly cause: 'usage-limit';
+    readonly resetsAt: Instant;
+} | {
+    readonly kind: 'stop';
+} | {
+    readonly kind: 'settle';
+    readonly forced: ForcedFailure | null;
+    readonly sessionStopped: boolean;
+};
+export interface ReadingInput<Reading extends SessionReading = SessionReading> {
+    readonly attempt: AttemptRow;
+    readonly reading: Reading;
+    readonly step: PipelineStep | null;
+    readonly sleep: SleepRules;
+    readonly now: Instant;
+}
+type ReadingRule<Kind extends SessionReading['kind']> = (input: ReadingInput<Extract<SessionReading, {
+    kind: Kind;
+}>>) => ReadingAction;
+export type ReadingTable = {
+    readonly [Kind in SessionReading['kind']]: Readonly<Record<LiveAttemptState, ReadingRule<Kind>>>;
+};
+export interface ActOnReadingInput {
+    readonly store: ClaimStore;
+    readonly worker: WorkerKind;
+    readonly rules: LoadedRules;
+    readonly backoff: CapacityBackoff;
+    readonly attempt: AttemptRow;
+    readonly reading: SessionReading;
+    readonly action: ReadingAction;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export interface RunningBound {
+    readonly name: string;
+    readonly pick: (input: ReadingInput<Extract<SessionReading, {
+        kind: 'running';
+    }>>) => ReadingAction | null;
+}
+export {};

package/dist/sessions/build-keep-writes.d.ts

@@ -0,0 +1,9 @@
+import type { AttemptRow, Instant, ItemView, LoadedRules, RowWrite } from '@boxxy/model';
+interface KeepInput {
+    readonly attempt: AttemptRow;
+    readonly item: ItemView;
+    readonly rules: LoadedRules;
+    readonly now: Instant;
+}
+export declare function buildKeepWrites(input: KeepInput): RowWrite[];
+export {};

package/dist/sessions/build-kept-clear.d.ts

@@ -0,0 +1,2 @@
+import type { ItemId, KeptSession, RowWrite } from '@boxxy/model';
+export declare function buildKeptClear(item: ItemId, kept: KeptSession): RowWrite;

package/dist/sessions/forget-sessions.d.ts

@@ -0,0 +1,2 @@
+import type { ForgetReport, ForgetSessionsInput } from './types.ts';
+export declare function forgetSessions(input: ForgetSessionsInput): Promise<ForgetReport>;

package/dist/sessions/is-kept-due.d.ts

@@ -0,0 +1,2 @@
+import type { KeptForgetInput } from './types.ts';
+export declare function isKeptDue(input: KeptForgetInput): boolean;

package/dist/sessions/resume-kept-session.d.ts

@@ -0,0 +1,6 @@
+import type { KeptSession, SpawnRequest, StartOutcome, WorkerKind } from '@boxxy/model';
+export interface ResumedSession {
+    readonly outcome: StartOutcome;
+    readonly resumeFallback: boolean;
+}
+export declare function resumeKeptSession(worker: WorkerKind, kept: KeptSession, spawn: SpawnRequest): Promise<ResumedSession>;

package/dist/sessions/types.d.ts

@@ -0,0 +1,19 @@
+import type { ActorRef, AtcSessionId, AttemptRow, ClaimStore, Instant, ItemView, KeptSession, LoadedRules, NewId, WorkerKind } from '@boxxy/model';
+export interface ForgetSessionsInput {
+    readonly store: ClaimStore;
+    readonly worker: WorkerKind;
+    readonly rules: LoadedRules;
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export interface ForgetReport {
+    readonly forgotten: readonly AtcSessionId[];
+    readonly failed: readonly AtcSessionId[];
+}
+export interface KeptForgetInput {
+    readonly kept: KeptSession;
+    readonly item: ItemView | null;
+    readonly latest: AttemptRow | null;
+    readonly now: Instant;
+}

package/dist/test-utils/apply-memory-change.d.ts

@@ -0,0 +1,3 @@
+import type { ApplyResult, StoreChange } from '@boxxy/model';
+import type { MemoryTables } from './types.ts';
+export declare function applyMemoryChange(tables: MemoryTables, change: StoreChange): ApplyResult;

package/dist/test-utils/build-memory-reader.d.ts

@@ -0,0 +1,3 @@
+import type { StoreReader } from '@boxxy/model';
+import type { MemoryTables } from './types.ts';
+export declare function buildMemoryReader(getLiveTables: () => MemoryTables): StoreReader;

package/dist/test-utils/build-mock-bind-change.d.ts

@@ -0,0 +1,7 @@
+import type { AgentSessionId, AttemptRow, StoreChange } from '@boxxy/model';
+interface BindInput {
+    readonly attempt: AttemptRow;
+    readonly agentSession: AgentSessionId;
+}
+export declare function buildMockBindChange(input: BindInput): StoreChange;
+export {};

package/dist/test-utils/build-mock-claim-change.d.ts

@@ -0,0 +1,2 @@
+import type { AttemptRow, LimitName, StoreChange } from '@boxxy/model';
+export declare function buildMockClaimChange(attempt: AttemptRow, limits?: readonly LimitName[]): StoreChange;

package/dist/test-utils/build-mock-file-item-change.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRow, StoreChange } from '@boxxy/model';
+export declare function buildMockFileItemChange(item: ItemRow): StoreChange;

package/dist/test-utils/build-mock-lever-change.d.ts

@@ -0,0 +1,2 @@
+import type { LeverRow, StoreChange } from '@boxxy/model';
+export declare function buildMockLeverChange(lever: LeverRow): StoreChange;

package/dist/test-utils/build-mock-new-id.d.ts

@@ -0,0 +1,2 @@
+import type { NewId } from '@boxxy/model';
+export declare function buildMockNewId(): NewId;

package/dist/test-utils/build-mock-note-change.d.ts

@@ -0,0 +1,2 @@
+import type { NoteRow, StoreChange } from '@boxxy/model';
+export declare function buildMockNoteChange(note: NoteRow): StoreChange;

package/dist/test-utils/build-mock-pause-change.d.ts

@@ -0,0 +1,2 @@
+import type { RunnerId, StoreChange } from '@boxxy/model';
+export declare function buildMockPauseChange(runner: RunnerId): StoreChange;

package/dist/test-utils/build-mock-pull-request-change.d.ts

@@ -0,0 +1,8 @@
+import type { AttemptRow, PullRequestRow, StoreChange } from '@boxxy/model';
+interface PullRequestInput {
+    readonly attempt: AttemptRow;
+    readonly state: PullRequestRow['state'];
+    readonly number?: number;
+}
+export declare function buildMockPullRequestChange(input: PullRequestInput): StoreChange;
+export {};

package/dist/test-utils/build-mock-relation-change.d.ts

@@ -0,0 +1,7 @@
+import type { ItemId, StoreChange } from '@boxxy/model';
+interface RelationInput {
+    readonly source: ItemId;
+    readonly target: ItemId;
+}
+export declare function buildMockRelationChange(input: RelationInput): StoreChange;
+export {};

package/dist/test-utils/build-mock-running-reading.d.ts

@@ -0,0 +1,6 @@
+import type { SessionReading } from '@boxxy/model';
+type RunningReading = Extract<SessionReading, {
+    kind: 'running';
+}>;
+export declare function buildMockRunningReading(overrides?: Partial<RunningReading>): RunningReading;
+export {};

package/dist/test-utils/build-mock-settle-change.d.ts

@@ -0,0 +1,7 @@
+import type { AttemptRow, StoreChange } from '@boxxy/model';
+interface SettleInput {
+    readonly attempt: AttemptRow;
+    readonly state: 'succeeded' | 'failed';
+}
+export declare function buildMockSettleChange(input: SettleInput): StoreChange;
+export {};

package/dist/test-utils/build-mock-start-change.d.ts

@@ -0,0 +1,2 @@
+import type { AttemptRow, CallerIdentity, StoreChange } from '@boxxy/model';
+export declare function buildMockStartChange(attempt: AttemptRow, caller?: CallerIdentity | null): StoreChange;

package/dist/test-utils/claim-store-attempt-reader-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreAttemptReaderCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-claim-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreClaimCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-close-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreCloseCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-contract.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreContract: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-copy-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreCopyCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-exclusive-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreExclusiveCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-guard-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreGuardCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-item-reader-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreItemReaderCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-outbox-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreOutboxCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-race-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreRaceCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-rollback-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreRollbackCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-seat-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreSeatCases: readonly ClaimStoreCase[];

package/dist/test-utils/claim-store-session-cases.d.ts

@@ -0,0 +1,2 @@
+import type { ClaimStoreCase } from './types.ts';
+export declare const claimStoreSessionCases: readonly ClaimStoreCase[];

package/dist/test-utils/collect-memory-limit-fills.d.ts

@@ -0,0 +1,3 @@
+import type { LimitFill } from '@boxxy/model';
+import type { MemoryTables } from './types.ts';
+export declare function collectMemoryLimitFills(tables: MemoryTables): LimitFill[];

package/dist/test-utils/compare-text.d.ts

@@ -0,0 +1 @@
+export declare function compareText(first: string, second: string): number;

package/dist/test-utils/create-fake-backoff.d.ts

@@ -0,0 +1,2 @@
+import type { CapacityBackoff } from '@boxxy/model';
+export declare function createFakeBackoff(): CapacityBackoff;

package/dist/test-utils/create-fake-clock.d.ts

@@ -0,0 +1,5 @@
+import type { Clock, Instant } from '@boxxy/model';
+export interface FakeClock extends Clock {
+    advance: (byMs: number) => Instant;
+}
+export declare function createFakeClock(startMs?: number): FakeClock;

package/dist/test-utils/create-fake-fact-sink.d.ts

@@ -0,0 +1,8 @@
+import type { FactId, FactSink, OutboxFact, SinkAnswer } from '@boxxy/model';
+export interface FakeFactSink extends FactSink {
+    readonly sends: readonly (readonly FactId[])[];
+    readonly facts: ReadonlyMap<FactId, OutboxFact>;
+    answerNext: (...answers: SinkAnswer[]) => void;
+    refuseFact: (id: FactId, status: 413 | 422) => void;
+}
+export declare function createFakeFactSink(): FakeFactSink;

package/dist/test-utils/create-fake-forge.d.ts

@@ -0,0 +1,17 @@
+import type { Forge, PullRequestReading, PullRequestRef } from '@boxxy/model';
+export interface SeededPullRequest {
+    readonly ref: PullRequestRef;
+    readonly githubId: number;
+    readonly reading: Omit<PullRequestReading, 'githubId' | 'url'>;
+}
+export interface ReadHold {
+    readonly entered: Promise<void>;
+    readonly release: () => void;
+}
+export interface FakeForge extends Forge {
+    readonly calls: readonly string[];
+    seed: (pullRequest: SeededPullRequest) => void;
+    setDown: (isDown: boolean) => void;
+    holdNextRead: () => ReadHold;
+}
+export declare function createFakeForge(): FakeForge;

package/dist/test-utils/create-fake-worker.d.ts

@@ -0,0 +1,42 @@
+import type { AgentSessionId, AttemptId, Attention, Clock, Instant, WorkerKind } from '@boxxy/model';
+type FailableMethod = 'start' | 'suspend' | 'resume' | 'stop' | 'forget' | 'resumeKept';
+export type FakeFailure = {
+    readonly kind: 'refused';
+    readonly cause: 'capacity' | 'other';
+    readonly reason: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+};
+export type FakeSession = {
+    readonly state: 'running';
+    readonly attention?: Attention;
+    readonly lastActivityAt?: Instant;
+    readonly lastOwnerAt?: Instant;
+    readonly agentSession?: AgentSessionId | null;
+    readonly usageLimitResetsAt?: Instant | null;
+} | {
+    readonly state: 'suspended';
+    readonly asked?: boolean;
+    readonly agentSession?: AgentSessionId | null;
+} | {
+    readonly state: 'ended';
+    readonly agentSession?: AgentSessionId | null;
+} | {
+    readonly state: 'absent';
+};
+export interface FakeWorkerCall {
+    readonly method: keyof WorkerKind;
+    readonly subject: string;
+}
+export interface FakeWorker extends WorkerKind {
+    readonly calls: readonly FakeWorkerCall[];
+    setSession: (attempt: AttemptId, session: FakeSession) => void;
+    failNext: (method: FailableMethod, failure: FakeFailure) => void;
+    failAlways: (method: FailableMethod, failure: FakeFailure) => void;
+}
+interface FakeWorkerInput {
+    readonly clock: Clock;
+}
+export declare function createFakeWorker(input: FakeWorkerInput): FakeWorker;
+export {};

package/dist/test-utils/create-memory-claim-store.d.ts

@@ -0,0 +1,2 @@
+import type { ClosableClaimStore } from './types.ts';
+export declare function createMemoryClaimStore(): ClosableClaimStore;

package/dist/test-utils/create-test-dispatch.d.ts

@@ -0,0 +1,46 @@
+import type { ApplyResult, AttemptId, AttemptRow, CallerIdentity, CapacityBackoff, Claim, DesignMode, FactType, ItemId, LoadedRules, NewId, OutboxFact, PhaseName, RunnerId } from '@boxxy/model';
+import type { SpawnSettings } from '../claims/types.ts';
+import type { CallRef } from '../closeouts/types.ts';
+import type { FakeClock } from './create-fake-clock.ts';
+import type { FakeWorker } from './create-fake-worker.ts';
+import type { ClosableClaimStore } from './types.ts';
+export interface SeedItemInput {
+    readonly phase?: PhaseName;
+    readonly designMode?: DesignMode;
+}
+export interface ReworkInput {
+    readonly keptCaller?: CallerIdentity | null;
+    readonly startByWorker?: boolean;
+}
+export interface Rework {
+    readonly first: AttemptRow;
+    readonly claimed: AttemptRow;
+    readonly second: AttemptRow;
+    readonly firstBody: unknown;
+}
+export interface TestDispatch {
+    readonly store: ClosableClaimStore;
+    readonly clock: FakeClock;
+    readonly worker: FakeWorker;
+    readonly backoff: CapacityBackoff;
+    readonly newId: NewId;
+    readonly runner: RunnerId;
+    readonly spawn: SpawnSettings;
+    readonly rules: () => LoadedRules;
+    readonly setRules: (rules: LoadedRules) => void;
+    readonly tick: () => Promise<void>;
+    readonly claim: () => Promise<Claim | null>;
+    readonly seedItem: (input: SeedItemInput) => Promise<ItemId>;
+    readonly seedBuild: () => Promise<AttemptRow>;
+    readonly seedRework: (input: ReworkInput) => Promise<Rework>;
+    readonly seedReworkAfter: (first: AttemptRow) => Promise<AttemptRow>;
+    readonly closeItem: (item: ItemId, reason: string) => Promise<ApplyResult>;
+    readonly readAttempt: (id: AttemptId) => Promise<AttemptRow>;
+    readonly heldSeats: (attempt: AttemptId) => Promise<string[]>;
+    readonly listFacts: (type: FactType) => Promise<OutboxFact[]>;
+    readonly buildCallRef: (attempt: AttemptRow) => CallRef;
+}
+export interface TestDispatchOptions {
+    readonly store?: ClosableClaimStore;
+}
+export declare function createTestDispatch(options?: TestDispatchOptions): Promise<TestDispatch>;

package/dist/test-utils/forge-contract.d.ts

@@ -0,0 +1,15 @@
+import type { Forge } from '@boxxy/model';
+import type { SeededPullRequest } from './create-fake-forge.ts';
+export interface ForgeHarness {
+    readonly forge: Forge;
+    seed: (pullRequest: SeededPullRequest) => void;
+}
+export interface ForgeContractOutcome {
+    readonly received: unknown;
+    readonly expected: unknown;
+}
+export type ForgeContractCase = readonly [
+    title: string,
+    check: (harness: ForgeHarness) => Promise<ForgeContractOutcome>
+];
+export declare const forgeContract: readonly ForgeContractCase[];

package/dist/test-utils/is-same-held-seat.d.ts

@@ -0,0 +1,2 @@
+import type { LimitSeatRow } from '@boxxy/model';
+export declare function isSameHeldSeat(seat: LimitSeatRow, held: LimitSeatRow): boolean;

package/dist/test-utils/types.d.ts

@@ -0,0 +1,19 @@
+import type { ClaimStore, Limit, LimitSeatRow, OutboxFact, TableName, Tables } from '@boxxy/model';
+export interface ClosableClaimStore extends ClaimStore {
+    close: () => Promise<void>;
+}
+export interface ClaimStoreOutcome {
+    readonly received: unknown;
+    readonly expected: unknown;
+}
+export type ClaimStoreCase = readonly [
+    title: string,
+    check: (store: ClosableClaimStore) => Promise<ClaimStoreOutcome>
+];
+export type MemoryTables = {
+    [T in TableName]: Tables[T][];
+} & {
+    outbox: OutboxFact[];
+    limits: Limit[];
+    limit_seats: LimitSeatRow[];
+};