@lostgradient/weft 0.23.1 → 0.24.0

package/dist/core/outbox-runner.js

@@ -0,0 +1,217 @@
+import {
+  raceAbort,
+  raceAbortWithin,
+  WaitBudgetElapsedError
+} from "./application-primitive-abort.js";
+import { claimNextDelivery } from "./outbox-delivery.js";
+import { ApplicationDeliveryValidationError, boundFailureMessage } from "./outbox-guards.js";
+import {
+  releaseAttemptController,
+  toApplicationDeliveryReceipt
+} from "./outbox-internals.js";
+import { beginAttempt, heartbeatAttempt, settleAttempt } from "./outbox-settlement.js";
+import { loadDelivery } from "./outbox-storage.js";
+import { validateOutcome } from "./outbox-validation.js";
+async function sendOnce(runtime, adapter, claim, requestSignal) {
+  const budget = claim.attemptDeadlineAt - runtime.now();
+  if (claim.signal.aborted || requestSignal?.aborted === !0 || budget <= 0)
+    return {
+      status: "retryable",
+      failure: {
+        reason: "retryable",
+        message: "The attempt ended before the transport was called."
+      },
+      retryAfterMs: void 0
+    };
+  const raced = await raceAbortWithin(async () => {
+    try {
+      return {
+        ok: !0,
+        outcome: validateOutcome(await adapter.send({
+          delivery: claim.receipt,
+          payload: claim.payload,
+          credentialRef: claim.credentialRef,
+          attemptToken: claim.attemptToken,
+          signal: claim.signal
+        }))
+      };
+    } catch (error) {
+      return { ok: !1, error };
+    }
+  }, budget, claim.signal, requestSignal);
+  if (raced.aborted)
+    return unknownAfterLostRace(runtime, claim, raced.reason);
+  if (raced.value.ok)
+    return raced.value.outcome;
+  return {
+    status: "unknown",
+    failure: {
+      reason: "unknown-outcome",
+      message: boundFailureMessage(`The transport adapter threw: ${describeError(raced.value.error)}`)
+    }
+  };
+}
+function unknownAfterLostRace(runtime, claim, reason) {
+  const deadlineWon = reason instanceof WaitBudgetElapsedError, message = deadlineWon ? "The attempt deadline passed while the transport call was in flight." : "The attempt was aborted while the transport call was in flight.";
+  if (deadlineWon) {
+    const registration = runtime.attemptControllers.get(claim.attemptToken);
+    if (registration !== void 0 && !registration.controller.signal.aborted)
+      registration.controller.abort(Error(message));
+  }
+  return { status: "unknown", failure: { reason: "unknown-outcome", message } };
+}
+function describeError(error) {
+  try {
+    const message = error instanceof Error ? error.message : error;
+    return typeof message === "string" ? message : String(message);
+  } catch {
+    return "a value that could not be converted to a string";
+  }
+}
+export async function deliverNext(runtime, options) {
+  const adapter = requireAdapter(runtime), claimed = await claimNextDelivery(runtime, options);
+  if (claimed.status !== "claimed")
+    return claimed;
+  const { claim } = claimed, deliveryId = claim.receipt.deliveryId;
+  if (options?.signal?.aborted === !0 || claim.signal.aborted || runtime.disposal.aborted)
+    return abandonBeforeSend(runtime, claim);
+  const begun = await beginAttempt(runtime, { deliveryId, attemptToken: claim.attemptToken });
+  if (begun.status !== "settled")
+    return {
+      status: "settled",
+      receipt: await currentReceipt(runtime, deliveryId, begun, claim.receipt),
+      committed: !1
+    };
+  const attempting = {
+    ...claim,
+    receipt: begun.receipt,
+    visibilityExpiresAt: begun.receipt.visibilityExpiresAt ?? claim.visibilityExpiresAt
+  };
+  return sendAndSettle(runtime, adapter, attempting, options?.signal);
+}
+async function abandonBeforeSend(runtime, claim) {
+  const deliveryId = claim.receipt.deliveryId;
+  releaseAttemptController(runtime, claim.attemptToken, "The delivery request was aborted before the send began.", deliveryId);
+  return { status: "settled", receipt: runtime.disposal.aborted ? claim.receipt : await currentReceipt(runtime, deliveryId, { status: "aborted" }, claim.receipt), committed: !1 };
+}
+async function sendAndSettle(runtime, adapter, attempting, requestSignal) {
+  const deliveryId = attempting.receipt.deliveryId, stopRenewing = keepLeaseAlive(runtime, attempting), stopForwarding = forwardAbort(runtime, attempting.attemptToken, requestSignal);
+  let outcome;
+  try {
+    outcome = await sendOnce(runtime, adapter, attempting, requestSignal);
+  } finally {
+    stopForwarding();
+  }
+  if (runtime.disposal.aborted) {
+    stopRenewing();
+    return { status: "settled", receipt: attempting.receipt, committed: !1 };
+  }
+  const settling = settleAttempt(runtime, {
+    deliveryId,
+    attemptToken: attempting.attemptToken,
+    outcome
+  }).finally(() => {
+    stopRenewing();
+    releaseAttemptController(runtime, attempting.attemptToken, "The application outbox finished this attempt.", deliveryId);
+  }), raced = await raceAbort(() => settling, requestSignal);
+  if (raced.aborted) {
+    settling.catch(() => {
+      return;
+    });
+    return { status: "settled", receipt: attempting.receipt, committed: !1 };
+  }
+  const settled = raced.value;
+  return {
+    status: "settled",
+    receipt: await currentReceipt(runtime, deliveryId, settled, attempting.receipt),
+    committed: settled.status === "settled" || settled.status === "retrying"
+  };
+}
+export function requireAdapter(runtime) {
+  if (runtime.adapter === void 0)
+    throw new ApplicationDeliveryValidationError("deliverNext() and drain() require an adapter; construct the outbox with one or drive claims directly.");
+  return runtime.adapter;
+}
+function forwardAbort(runtime, attemptToken, requestSignal) {
+  if (requestSignal === void 0)
+    return () => {
+      return;
+    };
+  const onAbort = () => {
+    const registration = runtime.attemptControllers.get(attemptToken);
+    if (registration !== void 0 && !registration.controller.signal.aborted)
+      registration.controller.abort(requestSignal.reason);
+  };
+  if (requestSignal.aborted) {
+    onAbort();
+    return () => {
+      return;
+    };
+  }
+  requestSignal.addEventListener("abort", onAbort, { once: !0 });
+  return () => {
+    requestSignal.removeEventListener("abort", onAbort);
+  };
+}
+function keepLeaseAlive(runtime, claim) {
+  const deliveryId = claim.receipt.deliveryId;
+  let timer = null, stopped = !1, confirmedExpiresAt = claim.visibilityExpiresAt;
+  const abort = (reason) => {
+    const registration = runtime.attemptControllers.get(claim.attemptToken);
+    if (registration !== void 0 && !registration.controller.signal.aborted)
+      registration.controller.abort(Error(reason));
+  }, arm = () => {
+    if (stopped)
+      return;
+    const remaining = confirmedExpiresAt - runtime.now();
+    if (remaining <= 0) {
+      abort("The attempt lease expired before its renewal could be confirmed.");
+      return;
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      renew();
+    }, Math.max(1, Math.floor(remaining / 2)));
+    timer.unref?.();
+  }, renew = async () => {
+    if (stopped)
+      return;
+    const remaining = confirmedExpiresAt - runtime.now();
+    if (remaining <= 0) {
+      abort("The attempt lease expired before its renewal could be confirmed.");
+      return;
+    }
+    const raced = await raceAbortWithin(() => heartbeatAttempt(runtime, { deliveryId, attemptToken: claim.attemptToken }), remaining).catch(() => null);
+    if (stopped)
+      return;
+    if (raced === null) {
+      arm();
+      return;
+    }
+    if (raced.aborted) {
+      abort("The attempt lease expired before its renewal could be confirmed.");
+      return;
+    }
+    const result = raced.value;
+    if (result.status !== "renewed")
+      return;
+    confirmedExpiresAt = result.visibilityExpiresAt;
+    if (result.cancellationRequested) {
+      abort("The application outbox cancelled this delivery.");
+      return;
+    }
+    arm();
+  };
+  arm();
+  return () => {
+    stopped = !0;
+    if (timer !== null)
+      clearTimeout(timer);
+  };
+}
+async function currentReceipt(runtime, deliveryId, result, lastObserved) {
+  if (result.receipt !== void 0)
+    return result.receipt;
+  const loaded = await loadDelivery(runtime.storage, runtime.keys, deliveryId);
+  return loaded === null ? lastObserved : toApplicationDeliveryReceipt(loaded.record);
+}

package/dist/core/outbox-settlement.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Attempt-fenced settlement for the application delivery outbox (WFT-85):
+ * marking an attempt begun, heartbeat, reporting the transport outcome,
+ * cancellation, and the cleanup-state read.
+ *
+ * Every function proves the caller holds the current attempt before it writes
+ * anything, and re-reads durable state after a lost compare-and-swap rather
+ * than retrying with stale bytes. A stale claimant therefore cannot begin,
+ * heartbeat, settle, or cancel a newer attempt.
+ *
+ * Heartbeat is the one mutation that emits no fleet event: it is liveness
+ * evidence, not a disposition.
+ *
+ * @module core/outbox-settlement
+ */
+import type { JSONValue } from './json.ts';
+import type { ApplicationDeliveryCancellationResult, ApplicationDeliveryCleanupResult, ApplicationDeliveryHeartbeatResult, ApplicationDeliverySettleResult } from './outbox-contract.ts';
+import { type OutboxRuntime } from './outbox-internals.ts';
+import type { ValidatedOutcome } from './outbox-validation.ts';
+/**
+ * Durably mark that the current attempt is about to call the transport.
+ * `settled` here means the `attempting` record committed; the receipt says so.
+ */
+export declare function beginAttempt(runtime: OutboxRuntime, options: {
+    readonly deliveryId: string;
+    readonly attemptToken: string;
+}): Promise<ApplicationDeliverySettleResult>;
+/**
+ * Record liveness and extend visibility for the current attempt, clamped to
+ * the fixed attempt deadline. The returned `cancellationRequested` flag is the
+ * cross-process cancellation channel.
+ */
+export declare function heartbeatAttempt(runtime: OutboxRuntime, options: {
+    readonly deliveryId: string;
+    readonly attemptToken: string;
+    readonly transportActivity?: JSONValue | undefined;
+}): Promise<ApplicationDeliveryHeartbeatResult>;
+/** Settle the current attempt on a validated transport outcome. */
+export declare function settleAttempt(runtime: OutboxRuntime, options: {
+    readonly deliveryId: string;
+    readonly attemptToken: string;
+    readonly outcome: ValidatedOutcome;
+}): Promise<ApplicationDeliverySettleResult>;
+/**
+ * Record a durable cancellation request and, when the claimant is in this
+ * process, abort its attempt-scoped signal after the record commits.
+ */
+export declare function requestCancellation(runtime: OutboxRuntime, options: {
+    readonly deliveryId: string;
+    readonly reason?: string | undefined;
+}): Promise<ApplicationDeliveryCancellationResult>;
+/**
+ * Read whether a cancelled delivery's attempt has finished. `pending` means
+ * the outbox has not seen the attempt settle, never that the transport
+ * stopped.
+ */
+export declare function readCleanupState(runtime: OutboxRuntime, deliveryId: string): Promise<ApplicationDeliveryCleanupResult>;

package/dist/core/outbox-settlement.js

@@ -0,0 +1,183 @@
+import { leaseCommitSerial } from "./application-primitive-attempt-registry.js";
+import { ApplicationDeliveryValidationError } from "./outbox-guards.js";
+import {
+  commitDeliveryTransition,
+  MAX_OUTBOX_TRANSITION_ATTEMPTS,
+  OutboxContentionError,
+  releaseAttemptController,
+  releaseAttemptsForDelivery,
+  toApplicationDeliveryReceipt
+} from "./outbox-internals.js";
+import { commitOutboxTransition, loadDelivery, planDeliveryTransition } from "./outbox-storage.js";
+import {
+  isTerminalDeliveryRecord
+} from "./outbox-transition-helpers.js";
+import {
+  beginDeliveryAttempt,
+  heartbeatDeliveryAttempt,
+  requestDeliveryCancellation,
+  settleDeliveryAttempt
+} from "./outbox-transitions.js";
+import { isApplicationDeliveryLeased } from "./outbox-types.js";
+function refusal(reason, record) {
+  return {
+    status: reason === "deadline-exceeded" ? "deadline-exceeded" : "stale",
+    receipt: toApplicationDeliveryReceipt(record)
+  };
+}
+function releaseRefusedAttempt(runtime, deliveryId, attemptToken) {
+  releaseAttemptController(runtime, attemptToken, "This attempt is no longer current: its request was refused.", deliveryId);
+}
+function refuse(runtime, deliveryId, attemptToken, reason, record) {
+  if (reason === "not-applicable")
+    return { status: "settled", receipt: toApplicationDeliveryReceipt(record) };
+  if (reason === "not-attempting")
+    return { status: "stale", receipt: toApplicationDeliveryReceipt(record) };
+  releaseRefusedAttempt(runtime, deliveryId, attemptToken);
+  return refusal(reason, record);
+}
+async function fenced(runtime, deliveryId, attemptToken, operation, decide) {
+  for (let attempt = 1;attempt <= MAX_OUTBOX_TRANSITION_ATTEMPTS; attempt += 1) {
+    const loaded = await loadDelivery(runtime.storage, runtime.keys, deliveryId);
+    if (loaded === null) {
+      releaseRefusedAttempt(runtime, deliveryId, attemptToken);
+      return { status: "unknown" };
+    }
+    if (runtime.disposal.aborted)
+      return { status: "stale", receipt: toApplicationDeliveryReceipt(loaded.record) };
+    const now = runtime.now(), transition = decide(loaded.record, now);
+    if (!transition.ok)
+      return refuse(runtime, deliveryId, attemptToken, transition.reason, loaded.record);
+    if (!await commitDeliveryTransition(runtime, {
+      previous: loaded.record,
+      expectedBytes: loaded.bytes,
+      next: transition.next,
+      now
+    }))
+      continue;
+    if (isTerminalDeliveryRecord(transition.next) || !isApplicationDeliveryLeased(transition.next)) {
+      releaseAttemptController(runtime, attemptToken, "The application outbox released this attempt when the delivery settled.");
+      return {
+        status: isTerminalDeliveryRecord(transition.next) ? "settled" : "retrying",
+        receipt: toApplicationDeliveryReceipt(transition.next)
+      };
+    }
+    return { status: "settled", receipt: toApplicationDeliveryReceipt(transition.next) };
+  }
+  throw new OutboxContentionError(operation, deliveryId);
+}
+export function beginAttempt(runtime, options) {
+  return fenced(runtime, options.deliveryId, options.attemptToken, "begin", (record, now) => beginDeliveryAttempt(record, { attemptToken: options.attemptToken, now }));
+}
+export async function heartbeatAttempt(runtime, options) {
+  for (let attempt = 1;attempt <= MAX_OUTBOX_TRANSITION_ATTEMPTS; attempt += 1) {
+    const loaded = await loadDelivery(runtime.storage, runtime.keys, options.deliveryId);
+    if (loaded === null) {
+      releaseRefusedAttempt(runtime, options.deliveryId, options.attemptToken);
+      return { status: "unknown" };
+    }
+    if (runtime.disposal.aborted)
+      return { status: "stale", receipt: toApplicationDeliveryReceipt(loaded.record) };
+    const now = runtime.now(), transition = heartbeatDeliveryAttempt(loaded.record, {
+      attemptToken: options.attemptToken,
+      now,
+      transportActivity: options.transportActivity
+    });
+    if (!transition.ok) {
+      releaseRefusedAttempt(runtime, options.deliveryId, options.attemptToken);
+      return refusal(transition.reason, loaded.record);
+    }
+    if (!await commitOutboxTransition(runtime.storage, runtime.events, planDeliveryTransition(runtime.keys, {
+      previous: loaded.record,
+      expectedBytes: loaded.bytes,
+      next: transition.next,
+      event: null,
+      now
+    })))
+      continue;
+    if (runtime.now() >= transition.next.attemptDeadlineAt) {
+      releaseRefusedAttempt(runtime, options.deliveryId, options.attemptToken);
+      return refusal("deadline-exceeded", transition.next);
+    }
+    return {
+      status: "renewed",
+      visibilityExpiresAt: transition.next.visibilityExpiresAt,
+      attemptDeadlineAt: transition.next.attemptDeadlineAt,
+      cancellationRequested: transition.next.state === "cancellation-requested",
+      receipt: toApplicationDeliveryReceipt(transition.next)
+    };
+  }
+  throw new OutboxContentionError("heartbeat", options.deliveryId);
+}
+export function settleAttempt(runtime, options) {
+  return fenced(runtime, options.deliveryId, options.attemptToken, "settle", (record, now) => settleDeliveryAttempt(record, {
+    attemptToken: options.attemptToken,
+    now,
+    outcome: options.outcome,
+    retryBackoffMs: runtime.policy.retryBackoffMs,
+    maxRetryBackoffMs: runtime.policy.maxRetryBackoffMs
+  }));
+}
+function abortLocalClaimant(runtime, attemptToken) {
+  const registration = runtime.attemptControllers.get(attemptToken);
+  if (registration !== void 0 && !registration.controller.signal.aborted)
+    registration.controller.abort(Error("The application outbox cancelled this delivery."));
+}
+function releaseTerminalAttempts(runtime, deliveryId, observedAt) {
+  releaseAttemptsForDelivery(runtime, deliveryId, "This delivery is terminal; its attempt is over.", void 0, observedAt);
+}
+export async function requestCancellation(runtime, options) {
+  for (let attempt = 1;attempt <= MAX_OUTBOX_TRANSITION_ATTEMPTS; attempt += 1) {
+    const observedAt = leaseCommitSerial(), loaded = await loadDelivery(runtime.storage, runtime.keys, options.deliveryId);
+    if (loaded === null) {
+      releaseTerminalAttempts(runtime, options.deliveryId, observedAt);
+      return { status: "unknown" };
+    }
+    if (runtime.disposal.aborted)
+      throw new ApplicationDeliveryValidationError("This application outbox has been disposed.");
+    const now = runtime.now(), transition = requestDeliveryCancellation(loaded.record, { now, reason: options.reason });
+    if (!transition.ok) {
+      if (transition.reason === "not-leased" && isApplicationDeliveryLeased(loaded.record)) {
+        abortLocalClaimant(runtime, loaded.record.attemptToken);
+        return {
+          status: "requested",
+          receipt: toApplicationDeliveryReceipt(loaded.record),
+          cleanupPending: !0
+        };
+      }
+      releaseTerminalAttempts(runtime, options.deliveryId, observedAt);
+      return { status: "already-terminal", receipt: toApplicationDeliveryReceipt(loaded.record) };
+    }
+    if (!await commitDeliveryTransition(runtime, {
+      previous: loaded.record,
+      expectedBytes: loaded.bytes,
+      next: transition.next,
+      now
+    }))
+      continue;
+    if (transition.next.state === "cancellation-requested") {
+      abortLocalClaimant(runtime, transition.next.attemptToken);
+      return {
+        status: "requested",
+        receipt: toApplicationDeliveryReceipt(transition.next),
+        cleanupPending: !0
+      };
+    }
+    if (isApplicationDeliveryLeased(loaded.record))
+      releaseAttemptController(runtime, loaded.record.attemptToken, "The application outbox cancelled this delivery before its send began.");
+    return { status: "cancelled", receipt: toApplicationDeliveryReceipt(transition.next) };
+  }
+  throw new OutboxContentionError("cancel", options.deliveryId);
+}
+export async function readCleanupState(runtime, deliveryId) {
+  const observedAt = leaseCommitSerial(), loaded = await loadDelivery(runtime.storage, runtime.keys, deliveryId);
+  if (loaded === null) {
+    releaseAttemptsForDelivery(runtime, deliveryId, "This delivery no longer exists; its receipt was retired.", void 0, observedAt);
+    return { status: "unknown" };
+  }
+  releaseAttemptsForDelivery(runtime, deliveryId, "This attempt is no longer the current lease on its delivery.", isApplicationDeliveryLeased(loaded.record) ? loaded.record.attemptToken : void 0, observedAt);
+  const receipt = toApplicationDeliveryReceipt(loaded.record);
+  if (receipt.terminalAt !== void 0 && receipt.cleanupPending !== !0)
+    return { status: "settled", receipt };
+  return { status: "pending", receipt };
+}

package/dist/core/outbox-storage.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Storage access for the application delivery outbox (WFT-85): bound keys,
+ * record loads that keep the exact bytes for compare-and-swap, index
+ * maintenance, and the transition plan the shared commit executes.
+ *
+ * @module core/outbox-storage
+ */
+import type { BatchOperation, ConditionalBatchCondition, Storage } from '../storage/interface.ts';
+import { type ApplicationCommitPlan, type ApplicationEventSink } from './application-primitive-commit.ts';
+import type { LoadedDeliveryRecord } from './outbox-contract.ts';
+import { type ApplicationDeliveryIdempotencyRecord, type ApplicationDeliveryRecord, type OutboxRecord } from './outbox-types.ts';
+/** Every key builder for one `(namespace, ownerId)` outbox, bound once. */
+export type OutboxKeys = Readonly<{
+    header: string;
+    sinkProbe: (nonce: string) => string;
+    deliveryPrefix: string;
+    delivery: (deliveryId: string) => string;
+    duePrefix: string;
+    due: (availableAt: number, deliveryId: string) => string;
+    bySequencePrefix: string;
+    bySequence: (sequence: number) => string;
+    idempotency: (key: string) => string;
+    terminalPrefix: string;
+    terminal: (terminalAt: number, deliveryId: string) => string;
+}>;
+/** Bind every outbox storage key to one namespace and owner. */
+export declare function createOutboxKeys(namespace: string, ownerId: string): OutboxKeys;
+/** The empty header an outbox starts from. */
+export declare function emptyOutboxRecord(namespace: string, ownerId: string): OutboxRecord;
+/** A header read together with the exact bytes it decoded from. */
+export type LoadedOutboxRecord = {
+    readonly record: OutboxRecord;
+    /** `null` when the outbox has never been written. */
+    readonly bytes: Uint8Array | null;
+};
+/**
+ * Read the per-outbox header, treating an absent key as a fresh outbox.
+ *
+ * @throws {PersistedDataCorruptError} When the stored header is malformed.
+ */
+export declare function loadOutboxHeader(storage: Storage, keys: OutboxKeys, namespace: string, ownerId: string): Promise<LoadedOutboxRecord>;
+/**
+ * Read one delivery record with the exact bytes it decoded from.
+ *
+ * @throws {PersistedDataCorruptError} When the stored record is malformed.
+ */
+export declare function loadDelivery(storage: Storage, keys: OutboxKeys, deliveryId: string): Promise<LoadedDeliveryRecord | null>;
+/**
+ * Read the idempotency binding for a retry key.
+ *
+ * @throws {PersistedDataCorruptError} When the stored binding is malformed.
+ */
+export declare function loadDeliveryIdempotencyBinding(storage: Storage, keys: OutboxKeys, idempotencyKey: string): Promise<{
+    readonly record: ApplicationDeliveryIdempotencyRecord;
+    readonly bytes: Uint8Array;
+} | null>;
+/** One entry of the time-keyed due index. */
+export type DueEntry = {
+    readonly key: string;
+    readonly bytes: Uint8Array;
+    readonly deliveryId: string;
+};
+/**
+ * Read the earliest entries of the due index.
+ *
+ * The index is keyed by `availableAt`, so the first entry is the earliest
+ * delivery, due or not. The caller decides whether it is claimable now.
+ *
+ * @throws {PersistedDataCorruptError} When an index entry is malformed, or names a delivery other than the one its key names.
+ */
+export declare function loadDueHead(storage: Storage, keys: OutboxKeys, limit: number): Promise<DueEntry[]>;
+/**
+ * Put/delete operations that keep the due and terminal indexes consistent
+ * with a record's new state.
+ *
+ * Unlike the mailbox's FIFO index, the due key embeds `availableAt`, which a
+ * reschedule changes: the entry under the previous instant is deleted and one
+ * under the new instant is written. A terminal record moving between terminal
+ * dispositions (an operator dead-letter of a parked delivery) likewise moves
+ * its retention entry to its new `terminalAt`.
+ */
+export declare function indexOperationsFor(keys: OutboxKeys, previous: ApplicationDeliveryRecord | null, next: ApplicationDeliveryRecord): BatchOperation[];
+/**
+ * Commit one outbox transition, atomically with its fleet event when a sink is
+ * configured. The outbox's binding of the shared commit.
+ */
+export declare function commitOutboxTransition(storage: Storage, events: ApplicationEventSink | undefined, plan: ApplicationCommitPlan): Promise<boolean>;
+/**
+ * Persist a delivery record plus its index maintenance as one plan.
+ *
+ * `expectedBytes` must be the exact bytes the record was read as, never a
+ * re-encoding of the decoded value.
+ */
+export declare function planDeliveryTransition(keys: OutboxKeys, options: {
+    readonly previous: ApplicationDeliveryRecord | null;
+    readonly expectedBytes: Uint8Array | null;
+    readonly next: ApplicationDeliveryRecord;
+    readonly event: {
+        readonly kind: string;
+        readonly payload: unknown;
+    } | null;
+    readonly now: number;
+    readonly extraConditions?: readonly ConditionalBatchCondition[] | undefined;
+    readonly extraOperations?: readonly BatchOperation[] | undefined;
+}): ApplicationCommitPlan;
+/** The put operation that advances the outbox header. */
+export declare function headerOperation(keys: OutboxKeys, record: OutboxRecord): BatchOperation;