@boxxy/dispatch 0.1.0 → 0.1.3

package/dist/attempts/attempt-moves.d.ts

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

package/dist/attempts/bind-attempt-session.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSessionId, ClaimStore, Instant, NewId, SessionFault } from '@boxxy/model';
+import type { CallRef } from '../closeouts/types.ts';
+export interface BindAttemptSessionInput {
+    readonly store: ClaimStore;
+    readonly call: CallRef;
+    readonly agentSession: AgentSessionId;
+    readonly missingSkills: readonly string[];
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export type BindAnswer = {
+    readonly kind: 'bound' | 'no-attempt' | 'not-current' | 'skill-missing';
+} | SessionFault;
+export declare function bindAttemptSession(input: BindAttemptSessionInput): Promise<BindAnswer>;

package/dist/attempts/build-attempt-change.d.ts

@@ -0,0 +1,73 @@
+import type { ActorRef, AnyNewFact, AttemptRow, AttemptSessionRow, AttemptState, DecisionRow, Instant, ItemId, LeaseRow, NewId, PhaseName, SeatRelease, SeatTake } from '@boxxy/model';
+import type { AttemptGuard } from './is-same-guard.ts';
+import type { AttemptEvent, ClaimedEvent, MoveEvent } from './types.ts';
+type AttemptWrite = {
+    readonly op: 'insert';
+    readonly table: 'attempts';
+    readonly row: AttemptRow;
+} | {
+    readonly op: 'update';
+    readonly table: 'attempts';
+    readonly key: {
+        readonly id: AttemptRow['id'];
+    };
+    readonly expect: AttemptGuard;
+    readonly set: Partial<AttemptRow>;
+} | {
+    readonly op: 'insert';
+    readonly table: 'attempt_sessions';
+    readonly row: AttemptSessionRow;
+} | {
+    readonly op: 'insert';
+    readonly table: 'leases';
+    readonly row: LeaseRow;
+} | {
+    readonly op: 'update';
+    readonly table: 'leases';
+    readonly key: Pick<LeaseRow, 'item' | 'phase' | 'gen'>;
+    readonly expect: Pick<LeaseRow, 'attempt' | 'releasedAt'>;
+    readonly set: Pick<LeaseRow, 'releasedAt'>;
+} | {
+    readonly op: 'insert';
+    readonly table: 'decisions';
+    readonly row: DecisionRow;
+} | {
+    readonly op: 'take-seats';
+    readonly take: SeatTake;
+} | {
+    readonly op: 'release-seats';
+    readonly release: SeatRelease;
+};
+interface AttemptStoreChange {
+    readonly at: Instant;
+    readonly under: {
+        readonly item: ItemId;
+        readonly phase: PhaseName;
+        readonly gen: number;
+        readonly holdGen: number;
+    } | null;
+    readonly writes: readonly AttemptWrite[];
+    readonly facts: readonly AnyNewFact[];
+}
+export type AttemptChange = {
+    readonly kind: 'change';
+    readonly change: AttemptStoreChange;
+} | {
+    readonly kind: 'not-allowed';
+    readonly state: AttemptState;
+    readonly event: AttemptEvent['kind'];
+};
+interface BuildAttemptChangeBase {
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export type BuildAttemptChangeInput = BuildAttemptChangeBase & ({
+    readonly attempt: null;
+    readonly event: ClaimedEvent;
+} | {
+    readonly attempt: AttemptRow;
+    readonly event: MoveEvent;
+});
+export declare function buildAttemptChange(input: BuildAttemptChangeInput): AttemptChange;
+export {};

package/dist/attempts/build-attempt-fact.d.ts

@@ -0,0 +1,3 @@
+import type { AnyNewFact, FactType } from '@boxxy/model';
+import type { FactEnvelopeParts, MoveParts } from './types.ts';
+export declare function buildAttemptFact(type: FactType, parts: MoveParts, envelope: FactEnvelopeParts): AnyNewFact;

package/dist/attempts/end-item-attempts.d.ts

@@ -0,0 +1,18 @@
+import type { ActorRef, AnyNewFact, AttemptId, AttemptRow, Instant, NewId, RowWrite, StoreChange } from '@boxxy/model';
+interface EndItemAttemptsInput {
+    readonly attempts: readonly AttemptRow[];
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export interface EndedAttempts {
+    readonly under: NonNullable<StoreChange['under']> | null;
+    readonly writes: readonly RowWrite[];
+    readonly facts: readonly AnyNewFact[];
+    readonly ended: readonly {
+        readonly attempt: AttemptId;
+        readonly how: 'settled' | 'closing';
+    }[];
+}
+export declare function endItemAttempts(input: EndItemAttemptsInput): EndedAttempts;
+export {};

package/dist/attempts/is-same-guard.d.ts

@@ -0,0 +1,5 @@
+import type { AttemptRow } from '@boxxy/model';
+declare const attemptGuardColumns: readonly ["state", "holdGen", "suspendRequestedAt", "wakeRequestedAt", "closing", "atcSession", "strayedAt", "sessionStoppedAt", "sessionForgottenAt"];
+export type AttemptGuard = Pick<AttemptRow, (typeof attemptGuardColumns)[number]>;
+export declare function isSameGuard(seen: Partial<AttemptGuard>, row: AttemptRow): boolean;
+export {};

package/dist/attempts/pick-call-attempt.d.ts

@@ -0,0 +1,10 @@
+import type { AttemptRow } from '@boxxy/model';
+import type { CallRef } from '../closeouts/types.ts';
+export type CallAttempt = {
+    readonly kind: 'attempt';
+    readonly attempt: AttemptRow;
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'no-attempt' | 'not-current';
+};
+export declare function pickCallAttempt(latest: AttemptRow | null, call: CallRef): CallAttempt;

package/dist/attempts/stop-stray-session.d.ts

@@ -0,0 +1,11 @@
+import type { ActorRef, AttemptRow, ClaimStore, Instant, NewId, WorkerKind } from '@boxxy/model';
+import type { MoveResult } from './types.ts';
+export interface StopStraySessionInput {
+    readonly store: ClaimStore;
+    readonly worker: WorkerKind;
+    readonly attempt: AttemptRow;
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export declare function stopStraySession(input: StopStraySessionInput): Promise<MoveResult | null>;

package/dist/attempts/types.d.ts

@@ -0,0 +1,142 @@
+import type { ActorRef, AgentSessionId, AtcSessionId, AttemptId, AttemptRow, AttemptSessionRow, AttemptState, CallerIdentity, CloseOut, ClosingCause, CommitSha, DecisionRow, FactId, FactType, Instant, Minutes, NewId, ResolvedRecipe, RunnerId, SessionMode, StartPick, WakePick, WakeSource, WorkFacts } from '@boxxy/model';
+export interface AttemptContext {
+    readonly mark: boolean;
+    readonly wakeRequested: boolean;
+    readonly mode: SessionMode;
+    readonly holdGen: number;
+    readonly closing: ClosingCause | null;
+    readonly hasSession: boolean;
+    readonly strayed: boolean;
+    readonly sessionStopped: boolean;
+    readonly sessionForgotten: boolean;
+}
+export type AttemptMachineEvent = {
+    readonly type: 'started';
+    readonly via: 'start' | 'reconcile';
+} | {
+    readonly type: 'woken';
+    readonly overCap: boolean;
+} | {
+    readonly type: 'settled';
+    readonly state: 'succeeded' | 'failed';
+    readonly sessionStopped: boolean;
+} | {
+    readonly type: 'spawn-unanswered' | 'session-seen' | 'closed-out' | 'timed-out' | 'item-closed' | 'turn-ended' | 'stalled' | 'skill-missing' | 'usage-limited' | 'suspend-asked' | 'suspend-refused' | 'slept' | 'wake-requested' | 'resumed' | 'wake-refused' | 'stray-stopped' | 'session-forgotten';
+};
+export type MoveEffect = 'take-lease' | 'release-lease' | 'take-seats' | 'release-seats' | 'record-decision' | 'bind-session' | FactType;
+export interface AttemptMove {
+    readonly event: AttemptMachineEvent['type'] | 'claimed';
+    readonly from: readonly AttemptState[];
+    readonly when?: (context: AttemptContext, event: AttemptMachineEvent) => boolean;
+    readonly to: AttemptState | 'same';
+    readonly effects: readonly MoveEffect[];
+    readonly context?: (context: AttemptContext, event: AttemptMachineEvent) => Partial<AttemptContext>;
+}
+export type DecisionDraft = Omit<DecisionRow, 'id' | 'attempt' | 'at'>;
+export interface ClaimedEvent {
+    readonly kind: 'claimed';
+    readonly attempt: AttemptId;
+    readonly pick: StartPick;
+    readonly number: number;
+    readonly runner: RunnerId;
+    readonly leaseGen: number;
+    readonly recipe: Pick<ResolvedRecipe, 'hash' | 'rulesVersion'>;
+    readonly skillsRef: CommitSha | null;
+    readonly spawnRequest: AttemptRow['spawnRequest'];
+    readonly spawnRequestHash: AttemptRow['spawnRequestHash'];
+    readonly input: AttemptRow['input'];
+    readonly mode: SessionMode;
+    readonly caller: CallerIdentity | null;
+    readonly decision: DecisionDraft;
+}
+type SettledFact = WorkFacts['boxxy.attempt.settled'];
+export type MoveEvent = {
+    readonly kind: 'started';
+    readonly via: 'start' | 'reconcile';
+    readonly atcSession: AtcSessionId;
+    readonly caller: CallerIdentity | null;
+    readonly resumeFallback: boolean;
+} | {
+    readonly kind: 'spawn-unanswered';
+    readonly reason: string;
+} | {
+    readonly kind: 'session-seen';
+    readonly row: AttemptSessionRow;
+} | {
+    readonly kind: 'closed-out';
+    readonly closeOut: CloseOut;
+    readonly hash: NonNullable<AttemptRow['closeOutHash']>;
+} | {
+    readonly kind: 'timed-out';
+    readonly afterMinutes: Minutes;
+} | {
+    readonly kind: 'item-closed';
+} | {
+    readonly kind: 'turn-ended';
+} | {
+    readonly kind: 'stalled';
+} | {
+    readonly kind: 'skill-missing';
+} | {
+    readonly kind: 'usage-limited';
+} | {
+    readonly kind: 'suspend-asked';
+} | {
+    readonly kind: 'suspend-refused';
+} | {
+    readonly kind: 'slept';
+    readonly idleSince: Instant;
+    readonly asked: boolean;
+} | {
+    readonly kind: 'wake-requested';
+    readonly by: WakeSource;
+} | {
+    readonly kind: 'woken';
+    readonly pick: WakePick;
+    readonly decision: DecisionDraft;
+    readonly overCap: boolean;
+} | {
+    readonly kind: 'resumed';
+    readonly atcSession: AtcSessionId;
+    readonly caller: CallerIdentity | null;
+} | {
+    readonly kind: 'wake-refused';
+} | (Pick<SettledFact, 'state' | 'failure' | 'returnedOutcome' | 'sessionStopped' | 'criteria' | 'matched' | 'frictionDropped' | 'skippedEffects'> & {
+    readonly kind: 'settled';
+    readonly outcome: NonNullable<AttemptRow['outcome']>;
+}) | {
+    readonly kind: 'stray-stopped';
+} | {
+    readonly kind: 'session-forgotten';
+};
+export type AttemptEvent = ClaimedEvent | MoveEvent;
+export interface MoveParts {
+    readonly before: AttemptRow;
+    readonly after: AttemptRow;
+    readonly event: AttemptEvent;
+    readonly decision: DecisionRow | null;
+}
+export interface MoveBase {
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export type MoveResult = {
+    readonly kind: 'applied';
+} | {
+    readonly kind: 'not-allowed';
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+};
+export interface SeenSession {
+    readonly atcSession: AtcSessionId;
+    readonly agentSession: AgentSessionId;
+    readonly keptFrom?: AttemptId | null;
+}
+export interface FactEnvelopeParts {
+    readonly id: FactId;
+    readonly actor: ActorRef;
+    readonly now: Instant;
+}
+export {};

package/dist/attempts/write-attempt-move.d.ts

@@ -0,0 +1,7 @@
+import type { AttemptId, RowWrite, StoreTx } from '@boxxy/model';
+import type { AttemptGuard } from './is-same-guard.ts';
+import type { MoveBase, MoveEvent, MoveResult } from './types.ts';
+export declare function writeAttemptMove(tx: StoreTx, attempt: AttemptId, event: MoveEvent, base: MoveBase & {
+    readonly also?: readonly RowWrite[];
+    readonly seen?: Partial<AttemptGuard>;
+}): Promise<MoveResult>;

package/dist/attempts/write-session-bind.d.ts

@@ -0,0 +1,3 @@
+import type { AttemptRow, SessionFault, StoreTx } from '@boxxy/model';
+import type { MoveBase, SeenSession } from './types.ts';
+export declare function writeSessionBind(tx: StoreTx, attempt: AttemptRow, session: SeenSession, base: MoveBase): Promise<SessionFault | null>;

package/dist/claims/build-snapshot-hash.d.ts

@@ -0,0 +1,2 @@
+import type { PoolName, Snapshot, SnapshotHash } from '@boxxy/model';
+export declare function buildSnapshotHash(snapshot: Snapshot, backoff: readonly PoolName[]): SnapshotHash;

package/dist/claims/claim-next.d.ts

@@ -0,0 +1,6 @@
+import type { Claim } from '@boxxy/model';
+import type { ClaimInput } from './types.ts';
+export declare class ClaimRaceError extends Error {
+    constructor(result: string);
+}
+export declare function claimNext(input: ClaimInput): Promise<Claim | null>;

package/dist/claims/pick-kept-session.d.ts

@@ -0,0 +1,9 @@
+import type { AttemptRow, ItemView, KeptSession, PhaseName, Pipeline } from '@boxxy/model';
+interface KeptSessionInput {
+    readonly item: ItemView;
+    readonly attempts: readonly AttemptRow[];
+    readonly pipeline: Pipeline;
+    readonly phase: PhaseName;
+}
+export declare function pickKeptSession(input: KeptSessionInput): KeptSession | null;
+export {};

package/dist/claims/request-wake.d.ts

@@ -0,0 +1,3 @@
+import type { MoveResult } from '../attempts/types.ts';
+import type { RequestWakeInput } from './types.ts';
+export declare function requestWake(input: RequestWakeInput): Promise<MoveResult>;

package/dist/claims/resume-claim.d.ts

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

package/dist/claims/start-claim.d.ts

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

package/dist/claims/types.d.ts

@@ -0,0 +1,44 @@
+import type { ActorRef, AttemptId, CapacityBackoff, Claim, ClaimStore, Instant, LoadedRules, NewId, RepoName, RunnerId, WakeSource, WorkerKind } from '@boxxy/model';
+export interface SpawnSettings {
+    readonly target: string;
+    readonly repoPaths: ReadonlyMap<RepoName, string>;
+    readonly prompts: ReadonlyMap<string, string>;
+}
+export interface ClaimInput {
+    readonly store: ClaimStore;
+    readonly runner: RunnerId;
+    readonly rules: LoadedRules;
+    readonly now: Instant;
+    readonly newId: NewId;
+    readonly backoff: CapacityBackoff;
+    readonly spawn: SpawnSettings;
+}
+export interface StartClaimInput {
+    readonly store: ClaimStore;
+    readonly worker: WorkerKind;
+    readonly rules: LoadedRules;
+    readonly claim: Extract<Claim, {
+        kind: 'start';
+    }>;
+    readonly now: Instant;
+    readonly newId: NewId;
+    readonly backoff: CapacityBackoff;
+}
+export interface ResumeClaimInput {
+    readonly store: ClaimStore;
+    readonly worker: WorkerKind;
+    readonly claim: Extract<Claim, {
+        kind: 'wake';
+    }>;
+    readonly now: Instant;
+    readonly newId: NewId;
+    readonly backoff: CapacityBackoff;
+}
+export interface RequestWakeInput {
+    readonly store: ClaimStore;
+    readonly attempt: AttemptId;
+    readonly by: WakeSource;
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}

package/dist/closeouts/build-settle-plans.d.ts

@@ -0,0 +1,17 @@
+import type { Effect, ItemId, ItemView, WorkFacts } from '@boxxy/model';
+import type { EffectContext, EffectPlan } from './types.ts';
+type SettledFact = WorkFacts['boxxy.attempt.settled'];
+interface SettlePlansInput {
+    readonly effects: readonly Effect[];
+    readonly ctx: EffectContext;
+    readonly openIssues: readonly ItemView[];
+    readonly held: boolean;
+}
+export interface SettlePlans {
+    readonly plans: readonly EffectPlan[];
+    readonly criteria: SettledFact['criteria'];
+    readonly matched: readonly ItemId[];
+    readonly skippedEffects: SettledFact['skippedEffects'];
+}
+export declare function buildSettlePlans(input: SettlePlansInput): SettlePlans;
+export {};

package/dist/closeouts/close-out-attempt.d.ts

@@ -0,0 +1,3 @@
+import type { CloseOutAnswer } from '@boxxy/model';
+import type { CloseOutInput } from './types.ts';
+export declare function closeOutAttempt(input: CloseOutInput): Promise<CloseOutAnswer>;

package/dist/closeouts/effect-handlers.d.ts

@@ -0,0 +1,2 @@
+import type { EffectHandlers } from './types.ts';
+export declare const effectHandlers: EffectHandlers;

package/dist/closeouts/pick-settlement.d.ts

@@ -0,0 +1,14 @@
+import type { AttemptRow, EngineOutcome, ForcedFailure, Instant, ItemView, LoadedRules, OutcomeName, Settlement } from '@boxxy/model';
+interface SettlementInput {
+    readonly attempt: AttemptRow;
+    readonly item: ItemView;
+    readonly rules: LoadedRules;
+    readonly forced: ForcedFailure | null;
+    readonly now: Instant;
+}
+export interface PickedSettlement extends Omit<Settlement, 'outcome'> {
+    readonly outcome: OutcomeName | EngineOutcome;
+    readonly returnedOutcome: string | null;
+}
+export declare function pickSettlement(input: SettlementInput): PickedSettlement;
+export {};

package/dist/closeouts/settle-attempt.d.ts

@@ -0,0 +1,3 @@
+import type { MoveResult } from '../attempts/types.ts';
+import type { SettleAttemptInput } from './types.ts';
+export declare function settleAttempt(input: SettleAttemptInput): Promise<MoveResult>;

package/dist/closeouts/types.d.ts

@@ -0,0 +1,50 @@
+import type { ActorRef, AnyNewFact, AtcSessionId, AttemptId, AttemptRow, CallerIdentity, ClaimStore, Effect, ForcedFailure, Instant, ItemView, LoadedRules, NewId, RelationRow, RowWrite } from '@boxxy/model';
+import type { AttemptGuard } from '../attempts/is-same-guard.ts';
+export type EffectPlan = {
+    readonly kind: 'apply';
+    readonly effect: Effect;
+    readonly writes: readonly RowWrite[];
+    readonly facts: readonly AnyNewFact[];
+} | {
+    readonly kind: 'skip';
+    readonly effect: Effect;
+    readonly reason: string;
+};
+export interface EffectContext {
+    readonly attempt: AttemptRow;
+    readonly item: ItemView;
+    readonly rules: LoadedRules;
+    readonly relations: readonly RelationRow[];
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export type EffectHandlers = {
+    readonly [Kind in Effect['kind']]: (effect: Extract<Effect, {
+        kind: Kind;
+    }>, ctx: EffectContext) => EffectPlan;
+};
+export interface SettleAttemptInput {
+    readonly store: ClaimStore;
+    readonly attempt: AttemptId;
+    readonly forced: ForcedFailure | null;
+    readonly sessionStopped: boolean;
+    readonly seen?: Partial<AttemptGuard>;
+    readonly rules: LoadedRules;
+    readonly actor: ActorRef;
+    readonly now: Instant;
+    readonly newId: NewId;
+}
+export interface CallRef {
+    readonly attempt: AttemptId;
+    readonly session: AtcSessionId;
+    readonly caller: CallerIdentity;
+}
+export interface CloseOutInput {
+    readonly store: ClaimStore;
+    readonly call: CallRef;
+    readonly body: unknown;
+    readonly rules: LoadedRules;
+    readonly now: Instant;
+    readonly newId: NewId;
+}

package/dist/index.d.ts

@@ -1 +1,39 @@
+export { bindAttemptSession } from './attempts/bind-attempt-session.ts';
+export type { BindAnswer, BindAttemptSessionInput } from './attempts/bind-attempt-session.ts';
+export { endItemAttempts } from './attempts/end-item-attempts.ts';
+export type { EndedAttempts } from './attempts/end-item-attempts.ts';
+export { pickCallAttempt } from './attempts/pick-call-attempt.ts';
+export type { CallAttempt } from './attempts/pick-call-attempt.ts';
+export { stopStraySession } from './attempts/stop-stray-session.ts';
+export type { StopStraySessionInput } from './attempts/stop-stray-session.ts';
+export type { MoveResult } from './attempts/types.ts';
+export { ClaimRaceError, claimNext } from './claims/claim-next.ts';
+export { requestWake } from './claims/request-wake.ts';
+export { resumeClaim } from './claims/resume-claim.ts';
+export { startClaim } from './claims/start-claim.ts';
+export type { ClaimInput, RequestWakeInput, ResumeClaimInput, SpawnSettings, StartClaimInput, } from './claims/types.ts';
+export { closeOutAttempt } from './closeouts/close-out-attempt.ts';
+export { settleAttempt } from './closeouts/settle-attempt.ts';
+export type { CallRef, CloseOutInput, EffectPlan, SettleAttemptInput } from './closeouts/types.ts';
+export { noticeLimits } from './notices/constants.ts';
+export { createNullNotifier } from './notices/create-null-notifier.ts';
+export { sendNotices } from './notices/send-notices.ts';
+export type { NoticeReport, SendNoticesInput } from './notices/types.ts';
 export { packageName } from './package-name.ts';
+export { buildInitialSenderState } from './outbox/build-initial-sender-state.ts';
+export { buildOutboxStatus } from './outbox/build-outbox-status.ts';
+export { outboxLimits } from './outbox/constants.ts';
+export { runSenderOnce } from './outbox/run-sender-once.ts';
+export type { OutboxLimits, SenderDeps, SenderState, SenderStep, SenderTurn, } from './outbox/types.ts';
+export { actOnReading } from './readings/act-on-reading.ts';
+export { findWaitingSince } from './readings/find-waiting-since.ts';
+export { pickReadingAction } from './readings/pick-reading-action.ts';
+export type { ActOnReadingInput, ReadingAction, ReadingInput } from './readings/types.ts';
+export { forgetSessions } from './sessions/forget-sessions.ts';
+export type { ForgetReport, ForgetSessionsInput } from './sessions/types.ts';
+export { timeouts } from './timeouts.ts';
+export type { DispatchTimeouts } from './types.ts';
+export { linkPullRequest } from './pull-requests/link-pull-request.ts';
+export { parsePullRequestUrl } from './pull-requests/parse-pull-request-url.ts';
+export type { LinkPullRequestInput, LinkPullRequestResult, WatchPullRequestsInput, WatchReport, } from './pull-requests/types.ts';
+export { watchPullRequests } from './pull-requests/watch-pull-requests.ts';

package/dist/notices/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const noticeLimits: {
+    readonly maxTries: 5;
+    readonly readRows: 200;
+};

package/dist/notices/create-null-notifier.d.ts

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

package/dist/notices/send-notices.d.ts

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

package/dist/notices/types.d.ts

@@ -0,0 +1,11 @@
+import type { ClaimStore, Instant, Notifier } from '@boxxy/model';
+export interface SendNoticesInput {
+    readonly store: ClaimStore;
+    readonly notifier: Notifier;
+    readonly now: Instant;
+}
+export interface NoticeReport {
+    readonly sent: number;
+    readonly failed: number;
+    readonly stuck: number;
+}

package/dist/outbox/build-backoff-ms.d.ts

@@ -0,0 +1,2 @@
+import type { OutboxLimits } from './types.ts';
+export declare function buildBackoffMs(retries: number, limits: OutboxLimits, random: number): number;

package/dist/outbox/build-initial-sender-state.d.ts

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

package/dist/outbox/build-outbox-status.d.ts

@@ -0,0 +1,15 @@
+import type { Instant, OutboxStatus } from '@boxxy/model';
+import type { SenderState } from './types.ts';
+interface OutboxStatusInput {
+    readonly sink: 'pepys' | 'none';
+    readonly state: SenderState;
+    readonly counts: {
+        readonly unsent: number;
+        readonly parked: number;
+        readonly oldestUnsentAt: Instant | null;
+    };
+    readonly now: Instant;
+    readonly isSending: boolean;
+}
+export declare function buildOutboxStatus(input: OutboxStatusInput): OutboxStatus;
+export {};

package/dist/outbox/constants.d.ts

@@ -0,0 +1,2 @@
+import type { OutboxLimits } from './types.ts';
+export declare const outboxLimits: OutboxLimits;

package/dist/outbox/measure-wire-bytes.d.ts

@@ -0,0 +1,2 @@
+import type { OutboxFact } from '@boxxy/model';
+export declare function measureWireBytes(fact: OutboxFact): number;

package/dist/outbox/pick-sender-move.d.ts

@@ -0,0 +1,10 @@
+import type { SinkAnswer } from '@boxxy/model';
+import type { OutboxLimits, SenderMove } from './types.ts';
+interface SenderMoveInput {
+    readonly answer: SinkAnswer;
+    readonly batchSize: number;
+    readonly parkRun: number;
+    readonly limits: OutboxLimits;
+}
+export declare function pickSenderMove(input: SenderMoveInput): SenderMove;
+export {};

package/dist/outbox/run-sender-once.d.ts

@@ -0,0 +1,2 @@
+import type { SenderDeps, SenderState, SenderTurn } from './types.ts';
+export declare function runSenderOnce(deps: SenderDeps, state: SenderState): Promise<SenderTurn>;

package/dist/outbox/take-batch.d.ts

@@ -0,0 +1,3 @@
+import type { OutboxFact } from '@boxxy/model';
+import type { OutboxLimits, TakenBatch } from './types.ts';
+export declare function takeBatch(rows: readonly OutboxFact[], limits: OutboxLimits): TakenBatch;