@animalabs/agent-framework 0.23.2 → 0.24.0

package/dist/src/recovery/discord-awareness-outbox.d.ts

@@ -1,109 +1,533 @@
+import type { JsStore } from '@animalabs/chronicle';
+/**
+ * Discord awareness marks: a reaction (💤 by default) that an operator may
+ * choose to place on Discord messages a surgery removed from a resident's
+ * context, so the people who wrote them can see the resident no longer has
+ * them in view.
+ *
+ * Marks are an explicit publication choice, separate from the surgery itself
+ * (`DiscordAwarenessMarks`, default `none`). Once requested, they are
+ * one-shot: branch moves and restarts never derive new requests from branch
+ * state, and a restart never activates a surgery's marks. A batch a crash
+ * left prepared is retired at startup, unsent, and the operator redoes the
+ * surgery from its source to choose marks again (see recoverAtStartup).
+ * Requests an activated batch owes go out with any delivery pass, a start's
+ * included. What a restart does finish is an interrupted suppression's body,
+ * on its own branch. An operator retracts or cancels explicitly. A version 2
+ * ledger's batches are kept as history when it is rewritten as version 3,
+ * and the work it had still to do is dropped, none of it sent, since nobody
+ * chose it (see migrateLedger).
+ *
+ * The ledger is a table with one entry per reaction, keyed by (MCPL server
+ * id, channel, message, emoji): what the acts that still stand want of it,
+ * whether Discord is owed a request for that, and what Discord last
+ * answered. It is never a model of what is on Discord: an answer is kept as
+ * an answer, and a request never answered is kept as one that may land,
+ * which nothing takes back. The server id is the configured route to a bot,
+ * not the bot's identity: if the route is re-pointed at another bot, owed
+ * requests act as that bot, and nothing here can detect it.
+ *
+ * Acts are ordered by the ledger's own counter (`moment`), never the clock:
+ * a surgery's marks choice (its prepare), its activation and each retract
+ * take the next moment. Between opposite wishes for one reaction the later
+ * act wins, and an activation never revives a reaction that a retract made
+ * after the surgery's choice decided against, even once that retract is
+ * cancelled.
+ *
+ * One instance is the file's only writer: the running framework, or the
+ * offline recovery while the host is stopped. It keeps the document in
+ * memory, reads the file when it first needs it and again after a write
+ * fails, and answers views from memory. Acts run one at a time, each written
+ * before the next starts: compact JSON to a temporary file, synced, renamed
+ * over the ledger, then the ledger's directory and its parent synced, by the
+ * rule the framework's own recovery files follow (writeRecoveryFile). A
+ * write that activates, completes or retires a batch syncs the store first,
+ * so the ledger never outlives the branch state it relies on. A write that
+ * throws has left the file as it was, and the act's change is dropped with
+ * it; a directory that can't be synced after the rename is reported
+ * (onUnsyncedWrite), and the write stands.
+ */
 export declare const DEFAULT_DISCORD_AWARENESS_EMOJI = "\uD83D\uDCA4";
+/**
+ * Bound text that came from elsewhere (a Discord error body, a filesystem
+ * error) before it is written to the ledger, logged or returned in a
+ * receipt: the ledger keeps its entries for the store's life, and a server's
+ * error text has no length limit of its own. Head and tail are kept, with
+ * the omitted length stated; a cut never splits a surrogate pair.
+ */
+export declare function boundDiscordAwarenessText(text: string, max?: number): string;
+/**
+ * A Discord answer that the reaction can never succeed: the message or
+ * channel is gone or inaccessible, the emoji can't be used, or the message
+ * takes no more reactions (or blocks this one). Retrying cannot help.
+ */
+export declare function isPermanentDiscordReactionFailure(message: string): boolean;
+/**
+ * An operator's request the ledger won't carry out: an unknown batch or
+ * retract request. Nothing was written. Any other error from an operator
+ * control is a failure to read or write the ledger.
+ */
+export declare class DiscordAwarenessRefusal extends Error {
+    constructor(message: string);
+}
+/** Where a store's awareness ledger lives: the path every release used. */
 export declare function defaultDiscordAwarenessOutboxPath(storePath: string): string;
 export interface DiscordAwarenessRef {
     serverId: string;
     channelId: string;
     messageId: string;
 }
+/** Which removed messages a publication choice covers. */
+export type DiscordAwarenessScope = 'addressed' | 'all';
+/**
+ * An operator's publication choice for one surgery. `none`, the default,
+ * keeps the surgery local. With `refs`, the choice authorizes exactly those
+ * refs (as a preview showed them): the surgery marks only the ones it
+ * actually removes, and never widens the set. Without `refs`, the scope is
+ * evaluated when the surgery applies; that form is for an immediate act whose
+ * choice and application are the same moment.
+ */
+export type DiscordAwarenessMarks = 'none' | {
+    scope: DiscordAwarenessScope;
+    refs?: DiscordAwarenessRef[];
+};
 export type DiscordAwarenessAction = 'add' | 'remove';
-export type DiscordAwarenessDeliveryStatus = 'pending' | 'applied' | 'permanent-failure';
-export interface DiscordAwarenessEntry extends DiscordAwarenessRef {
-    desired: boolean;
-    markerPresent: boolean;
-    deliveryStatus: DiscordAwarenessDeliveryStatus;
-    attempts: number;
-    lastAction?: DiscordAwarenessAction;
-    lastAttemptAt?: number;
-    lastError?: string;
+export interface DiscordSuppressionInterval {
+    fromId: string;
+    toId: string;
 }
+/**
+ * Where a batch is in its life:
+ * - `prepared`: recorded before its surgery's body change, which settles it.
+ *   One a crash leaves is retired at startup, never activated (see
+ *   recoverAtStartup), except a suppression whose body a start on its branch
+ *   finishes first. One an operator cancelled stays prepared, with
+ *   `cancelled` set, and is never activated;
+ * - `active`: activated by its surgery, or kept so from a version 2 ledger;
+ * - `retired`: none of its marks will be sent: its surgery never happened or
+ *   couldn't record its activation, a start found it left prepared, or a
+ *   version 2 ledger never activated it.
+ */
+export type DiscordAwarenessBatchStatus = 'prepared' | 'active' | 'retired';
+/** One surgery's marks choice, and a suppression's body to resume. */
 export interface DiscordAwarenessBatch {
     id: string;
-    status: 'prepared' | 'active';
+    status: DiscordAwarenessBatchStatus;
     agentName: string;
     sourceBranch: string;
     targetBranch: string;
     emoji: string;
+    /** The clock when it was prepared: shown, never compared. */
     createdAt: number;
-    refs: DiscordAwarenessEntry[];
+    /** The ledger moment of the surgery's marks choice (its prepare). */
+    chosen: number;
+    /** `none` for a suppression's batch with no marks; `legacy` for a version 2 ledger's. */
+    scope: 'none' | DiscordAwarenessScope | 'legacy';
+    /** The refs this batch requests marks on (authorized ∩ removed). */
+    refs: DiscordAwarenessRef[];
+    /** Removed addressable messages this batch leaves unmarked. */
+    unmarked?: number;
+    /** Authorized refs the surgery did not remove. */
+    notRemoved?: number;
     /**
-     * `target-branch` may be promoted when its target branch (or a descendant)
-     * is active. `explicit` requires activate() after a second mutation.
+     * A suppression's removals, by message ids, which a start on its target
+     * branch applies again while the batch is prepared: that branch being
+     * active doesn't prove the redactions finished. The ids make each one
+     * idempotent.
      */
-    activationPolicy?: 'target-branch' | 'explicit';
-    /** Idempotent interval operations used to resume an interrupted suppression. */
     suppressionIntervals?: DiscordSuppressionInterval[];
+    cancelled?: {
+        at: number;
+        by?: string;
+    };
+    /**
+     * A version 2 ledger's batch: how many of its refs agent-framework 0.22.x's
+     * last attempt saw added (an add it recorded no error for), set when the
+     * ledger was rewritten as version 3. It is history, never a claim about
+     * what is on Discord now.
+     */
+    legacyAdded?: number;
 }
-export interface DiscordSuppressionInterval {
-    fromId: string;
-    toId: string;
+/** A surgery's request, as it prepares a batch. */
+export interface DiscordAwarenessPrepareInput {
+    agentName: string;
+    sourceBranch: string;
+    targetBranch: string;
+    refs: DiscordAwarenessRef[];
+    scope: 'none' | DiscordAwarenessScope;
+    emoji?: string;
+    suppressionIntervals?: DiscordSuppressionInterval[];
+    unmarked?: number;
+    notRemoved?: number;
 }
-export interface DiscordAwarenessOperation {
-    batchId: string;
+/**
+ * What the ledger will do with a batch whose body change has landed:
+ * - `queued`: it is active, its requests owed;
+ * - `not-scheduled`: none of its marks will be sent. It was retired, or it
+ *   couldn't be, and stays prepared for the next start to retire, or it was
+ *   never recorded; `error` says which, and why its activation failed.
+ */
+export type DiscordAwarenessSettlement = {
+    status: 'queued';
+    queued: number;
+} | {
+    status: 'not-scheduled';
+    error: string;
+};
+export type DiscordAwarenessOutcome = 'confirmed' | 'failed' | 'not-sent' | 'unknown';
+/** A request Discord is owed for one reaction, or one claimed to send. */
+export interface DiscordAwarenessRequest extends DiscordAwarenessRef {
     emoji: string;
     action: DiscordAwarenessAction;
-    ref: DiscordAwarenessEntry;
+    /** The moment of the act that owes it. */
+    due: number;
+}
+/**
+ * A reaction's state, as views and receipts count it:
+ * - `queued`: a request is owed and not yet sent;
+ * - `sending`: a request is on the wire;
+ * - `present`, `absent`: nothing is owed, and that was Discord's last answer;
+ * - `unknown`: nothing is owed, and the last request went unanswered;
+ * - `failed`: what was owed ended unconfirmed: Discord refused it for good,
+ *   or three attempts went unconfirmed;
+ * - `untouched`: no request was ever answered or owed.
+ */
+export type DiscordAwarenessReactionState = 'queued' | 'sending' | 'present' | 'absent' | 'unknown' | 'failed' | 'untouched';
+/** Receipt for cancel(). Nothing is ever removed from Discord by a cancel. */
+export interface DiscordAwarenessCancelReceipt {
+    /** The batch id or retract request id that was cancelled. */
+    target: string;
+    kind: 'batch' | 'retract';
+    /** Reactions this call left with nothing owed before any request for what
+     *  the act wanted went out: for a batch not yet activated, every mark it
+     *  would have requested. A repeated cancel stops none. */
+    cancelled: number;
+    /** The act's reactions whose last answer from Discord is what the act
+     *  wanted (cancel undoes none of them). */
+    confirmed: number;
+    /** The act's reactions with a request on the wire or one never answered:
+     *  any may land. */
+    mayStillLand: number;
+}
+/** Receipt for retract(). */
+export interface DiscordAwarenessRetractReceipt {
+    requestId: string;
+    /** Removals queued: one per selected reaction, whatever was answered before. */
+    removalsQueued: number;
+    /** Reactions whose owed add this removal replaced. An add on the wire
+     *  still settles before the removal is sent, and may land
+     *  (keysWithUnresolvedAdds). */
+    addsSuperseded: number;
+    /** Reactions with an add on the wire or one never answered: such an add
+     *  may land after this removal. */
+    keysWithUnresolvedAdds: number;
+}
+/** A version 2 ledger's batch whose undelivered work its rewrite as version
+ *  3 dropped, none of it sent (see migrateLedger). */
+export interface DiscordAwarenessImportedUnsent {
+    batchId: string;
+    agentName: string;
+    sourceBranch: string;
+    targetBranch: string;
+    /** Marks agent-framework 0.22.x had still to add, and to remove. */
+    adds: number;
+    removals: number;
+}
+/** A batch startup retired (see recoverAtStartup), with what the operator
+ *  needs to redo its surgery. */
+export interface DiscordAwarenessRetirement {
+    batchId: string;
+    agentName: string;
+    sourceBranch: string;
+    targetBranch: string;
+    /** The marks it would have requested, none of them sent: 0 for a batch
+     *  with none, one an operator cancelled, or a version 2 ledger's, whose
+     *  undelivered work its rewrite dropped and reported. */
+    marks: number;
+    /** Whether it is a suppression (it names removal intervals). */
+    suppression: boolean;
+    /** A version 2 ledger's batch: its marks stay as that ledger left them. */
+    imported?: boolean;
+}
+/** Per-batch view for operators: what was asked and what is known. */
+export interface DiscordAwarenessBatchView {
+    kind: 'batch';
+    id: string;
+    status: DiscordAwarenessBatchStatus;
+    scope: DiscordAwarenessBatch['scope'];
+    agentName: string;
+    sourceBranch: string;
+    targetBranch: string;
+    emoji: string;
+    createdAt: number;
+    refs: number;
+    unmarked?: number;
+    notRemoved?: number;
+    cancelled?: {
+        at: number;
+        by?: string;
+    };
+    /** Its refs' reactions, by state. */
+    reactions: Record<DiscordAwarenessReactionState, number>;
+    /** Its refs' reactions with a request on the wire or one never answered. */
+    mayStillLand: number;
+    /** A version 2 ledger's batch: refs 0.22.x's last attempt saw added
+     *  (DiscordAwarenessBatch.legacyAdded). */
+    legacyAdded?: number;
 }
-interface BranchDescriptor {
+/** One retract request: the removals it queued and what became of them. */
+export interface DiscordAwarenessRetractView {
+    kind: 'retract';
+    /** The retract's request id (what cancel takes). */
     id: string;
-    name: string;
-    parentId?: string;
+    /** The batch it retracted, or `all`. */
+    target: string;
+    at: number;
+    by?: string;
+    cancelled?: {
+        at: number;
+        by?: string;
+    };
+    /** Removals it queued. */
+    keys: number;
+    /** The reactions it still wants absent, by state. */
+    reactions: Record<DiscordAwarenessReactionState, number>;
+    /** Of those, the ones with a request on the wire or one never answered. */
+    mayStillLand: number;
 }
+export type DiscordAwarenessView = DiscordAwarenessBatchView | DiscordAwarenessRetractView;
+/** Extract Discord addressing metadata without reading message content. */
 export interface DiscordMessageMetadataCarrier {
     metadata?: Record<string, unknown>;
 }
-/** Extract Discord addressing metadata without reading message content. */
 export declare function extractDiscordAwarenessRefs(messages: DiscordMessageMetadataCarrier[], forcedServerId?: string): DiscordAwarenessRef[];
 /**
- * A branch-independent, durable operation ledger for Discord awareness marks.
- *
- * Completed entries are retained. Reconciliation derives whether their emoji
- * should currently exist from Chronicle branch ancestry, queuing `remove`
- * after switching away from a recovery branch and `add` when returning to it.
+ * A surgery's marks choice as a caller passes it at runtime: `none` (or left
+ * out), or `{ scope: 'addressed' | 'all', refs? }` with each ref a Discord
+ * address. Anything else is refused, never guessed: a bare scope string (the
+ * host/command vocabulary) or a misspelled scope would otherwise skip the
+ * scope filter and mark every addressable message. Each entry point that
+ * takes a choice in this form checks it with this before it plans or
+ * changes anything: the framework's rollback and suppression, and the
+ * offline recovery. host/command's undo by messages takes the bare scope
+ * words instead and refuses any other, and the recovery CLI parses its --marks.
+ */
+export declare function checkedDiscordAwarenessMarks(marks: unknown): DiscordAwarenessMarks;
+/**
+ * Select the refs a publication choice covers among removed messages.
+ * `addressed` means the message carried the MCPL `chat:addressed` tag (a
+ * mention, a reply to the bot, or a DM, as the server classified it); the
+ * same signal the framework uses for loci and wakes. With `marks.refs`, only
+ * those refs are eligible as well.
+ */
+export declare function selectDiscordAwarenessRefs(messages: DiscordMessageMetadataCarrier[], marks: DiscordAwarenessMarks, forcedServerId?: string): {
+    refs: DiscordAwarenessRef[];
+    addressable: number;
+    unmarked: number;
+    notRemoved: number;
+};
+/**
+ * The durable awareness-mark ledger (see the module comment). Writing calls
+ * are async and resolve once their write is on disk; each runs alone. Views
+ * are synchronous, from memory: one made while a write is in progress sees
+ * the act that write records.
  */
 export declare class DiscordAwarenessOutbox {
     readonly path: string;
-    constructor(path: string);
-    prepare(input: {
-        agentName: string;
-        sourceBranch: string;
-        targetBranch: string;
-        refs: DiscordAwarenessRef[];
-        emoji?: string;
-        activationPolicy?: 'target-branch' | 'explicit';
-        suppressionIntervals?: DiscordSuppressionInterval[];
-    }): DiscordAwarenessBatch | null;
-    /** Activate after Chronicle has safely switched to the target branch. */
-    activate(batchId: string): void;
-    /**
-     * Retire a batch that was prepared but whose operation did not complete
-     * (fork failed, a removal threw and the source branch was restored). A
-     * prepared batch is armed: it re-fires at boot or on branch switch through
-     * `activatePreparedForBranch` / `preparedSuppressionsForBranch`, and an
-     * un-completable suppression there aborts framework start. Only prepared
-     * batches can be discarded — an active batch owns delivered markers and
-     * must be reconciled, not dropped. Returns false when nothing was removed.
-     */
-    discard(batchId: string): boolean;
-    /**
-     * Reconcile every retained ledger entry against the active branch. A marker
-     * is desired when any active batch for the same ref+emoji has a target branch
-     * in the active branch's ancestry.
-     */
-    reconcileForBranch(branchName: string, branches?: BranchDescriptor[]): {
-        activated: number;
-        queued: number;
-    };
-    /** Backward-compatible startup helper. */
-    activatePreparedForBranch(branchName: string, branches?: BranchDescriptor[]): number;
-    pending(serverId?: string): DiscordAwarenessOperation[];
-    recordSuccess(batchId: string, ref: DiscordAwarenessRef, action: DiscordAwarenessAction): void;
-    recordFailure(batchId: string, ref: DiscordAwarenessRef, action: DiscordAwarenessAction, error: string, permanent: boolean): void;
-    /** Compatibility alias for older callers that only acknowledged adds. */
-    acknowledge(batchId: string, ref: DiscordAwarenessRef): void;
+    private readonly store?;
+    /** Told what a version 2 ledger's rewrite drops, before it is written. */
+    private readonly announceImport?;
+    /** Told of a directory that couldn't be synced after a write's rename. */
+    private readonly onUnsyncedWrite;
+    /** The document, or null until it is read, and after a failed write
+     *  whose file couldn't be read back: the next read tries again. */
+    private state;
+    /** The tail of the acts queued so far: each act starts after it. */
+    private queue;
+    /**
+     * @param path the ledger file (defaultDiscordAwarenessOutboxPath under a store).
+     * @param opts.store the store whose branch state activations, completions
+     *   and retirements rely on, synced before each is written.
+     * @param opts.announceImport told, before a version 2 ledger is rewritten
+     *   as version 3, which batches' undelivered work that drops, none of it sent.
+     * @param opts.onUnsyncedWrite told of a directory that couldn't be synced
+     *   after a write's rename: the write stands, though an operating system
+     *   crash could lose it. Logged to stderr when not given.
+     */
+    constructor(path: string, opts?: {
+        store?: JsStore;
+        announceImport?: (unsent: DiscordAwarenessImportedUnsent[]) => void;
+        onUnsyncedWrite?: (directory: string, error: unknown) => void;
+    });
+    /**
+     * Record a surgery's choice before its body change. Returns null when it
+     * carries neither marks nor a suppression's removals. A prepared batch
+     * never delivers: only its surgery's activate() does. If its write fails it
+     * throws, saying what the ledger may hold (failedPrepare), and the surgery
+     * doesn't run.
+     */
+    prepare(input: DiscordAwarenessPrepareInput): Promise<DiscordAwarenessBatch | null>;
+    /**
+     * Activate a prepared batch after its body change landed: each of its
+     * refs is wanted present, and a request is owed for it, on disk before
+     * this returns. Activation completes the surgery's earlier choice; it is
+     * not a new one, so a reaction a retract reached after that choice, even
+     * one cancelled since, keeps what the retract decided. Returns how many
+     * requests it made owed.
+     */
+    activate(batchId: string): Promise<number>;
+    private activateIn;
+    /**
+     * Activate a batch after its body change landed, and if that cannot be
+     * recorded, retire it instead, so that what the caller reports is what
+     * the ledger will do: `queued`, or `not-scheduled`. A batch that can be
+     * neither activated nor retired stays prepared in the file, since a write
+     * that fails leaves it as it was, and a start retires it, none of its
+     * marks sent: the next start, or for a suppression the first start on its
+     * branch, once it finds the removals applied. Never throws.
+     */
+    settleActivation(batchId: string): Promise<DiscordAwarenessSettlement>;
+    /**
+     * Retire a batch whose surgery did not complete. Only a prepared batch can
+     * be retired; returns false when nothing was.
+     */
+    discard(batchId: string): Promise<boolean>;
+    private retireIn;
+    /**
+     * The suppressions whose body a start on `branch` finishes: prepared
+     * batches that name removal intervals, cancelled or not, whose target is
+     * exactly that branch: a surgery's leftovers, or a version 2 ledger's that
+     * agent-framework 0.22.x never activated. Branch ancestry is never
+     * consulted. Throws when the ledger can't be read.
+     */
+    pendingSuppressionsFor(branch: string): DiscordAwarenessBatch[];
+    /**
+     * Retire a suppression's batch once a start on its branch has finished
+     * its removals, none of its marks sent: a restart never activates a
+     * surgery's marks. `announceRetirement` is told before that is written,
+     * for the reason recoverAtStartup's `announce` is. Nothing is written for
+     * a batch that isn't prepared.
+     */
+    completeSuppression(batchId: string, announceRetirement?: () => void): Promise<void>;
+    /**
+     * Startup reconciliation, run once before any delivery. It derives nothing
+     * from branch ancestry, and it activates nothing:
+     * - a request a previous process left on the wire is recorded unanswered
+     *   (recordUnanswered): it may have reached Discord. It counts toward the
+     *   bound like any unanswered attempt, and `givenUp` is how many reactions
+     *   that brought there, which nothing more is sent for;
+     * - a prepared batch, which an interrupted surgery left, or a failed one
+     *   that couldn't retire it, is retired, none of its marks sent: the
+     *   operator redoes the surgery from its source to choose marks again. A
+     *   suppression whose body is pending is kept instead: a start on its
+     *   branch finishes its removals and then retires it (completeSuppression).
+     * Each retirement is reported in `retired`, and the store is synced before
+     * any is written. `announce` is told what it retires and records
+     * unanswered before that is written: each is written once, so a notice
+     * given after the write would be lost for good if the process ended
+     * between the two. If the write doesn't land, the next start says it
+     * again.
+     */
+    recoverAtStartup(announce?: (planned: {
+        retired: DiscordAwarenessRetirement[];
+        unknownAttempts: number;
+        givenUp: number;
+    }) => void): Promise<{
+        retired: DiscordAwarenessRetirement[];
+        unknownAttempts: number;
+        givenUp: number;
+    }>;
+    /**
+     * Stop a batch's marks, or a retract's removals (by its request id), from
+     * being sent or sent again: the act is taken out of each reaction it
+     * wants, and a reaction no act wants any more is owed nothing. A request
+     * on the wire still has its answer recorded, before anything else goes for
+     * that reaction. Nothing is ever removed from Discord by a cancel: the
+     * receipt reports what may already have landed, and retract removes it.
+     */
+    cancel(target: string, by?: string): Promise<DiscordAwarenessCancelReceipt>;
+    /**
+     * Remove this bot's mark (through the configured route) from a batch's
+     * refs, or (`all`) from every ref of every batch not retired, whether
+     * prepared or active, and every reaction the ledger holds. That covers
+     * every mark a version 2 ledger recorded: one of its batches that
+     * agent-framework 0.22.x activated stays active, and 0.22.x attempted only
+     * an active batch's refs. A reaction is one per (route, message, emoji),
+     * whichever batches asked for it, so this acts across batches. A removal
+     * is owed for every selected reaction, whatever was answered before: an
+     * answer can't establish what is on Discord now, and removing an absent
+     * reaction does nothing. It is the latest act on those reactions: an add
+     * owed there is replaced, and a batch whose choice came before it, once
+     * activated, leaves them as this decides. The receipt reports the adds
+     * that may still land.
+     */
+    retract(target: string | 'all', by?: string): Promise<DiscordAwarenessRetractReceipt>;
+    /**
+     * The requests owed and not on the wire, oldest act first, for one server
+     * or every one. Throws when the ledger can't be read.
+     */
+    due(serverId?: string): DiscordAwarenessRequest[];
+    /**
+     * Choose a server's next owed request and write it ahead, in one act:
+     * what is owed is read as the ledger holds it now, so a cancel or retract
+     * made while an earlier request was on the wire is never overridden by an
+     * older list. A reaction with a request on the wire is never chosen again
+     * until its answer is written. `skip` excludes requests already tried in
+     * this pass. Resolves once the write-ahead is on disk, with the request to
+     * send, or null when nothing is owed.
+     *
+     * A delivery pass claims only once its last request's answer is written,
+     * so a request of this server still marked on the wire here is one whose
+     * answer couldn't be written. It is recorded as unanswered first, as a
+     * start records one an earlier process left: it may land, and what it
+     * served is owed again.
+     */
+    claim(serverId: string, skip?: (request: DiscordAwarenessRequest) => boolean): Promise<DiscordAwarenessRequest | null>;
+    /**
+     * Record a claimed request's answer. An answer ends what is owed only if
+     * it is for the act its request served: one for an older act updates what
+     * Discord last answered, and what may land, alone, so an act made while a
+     * request was out still gets its own request. Resolves to whether this
+     * ended what is owed without a confirmation (refused for good, or at the
+     * third unconfirmed attempt), so nothing more is sent for it.
+     */
+    recordOutcome(request: DiscordAwarenessRequest, outcome: DiscordAwarenessOutcome, detail?: {
+        permanent?: boolean;
+    }): Promise<boolean>;
     batches(): DiscordAwarenessBatch[];
-    preparedSuppressionsForBranch(branchName: string, branches?: BranchDescriptor[]): DiscordAwarenessBatch[];
-    private read;
-    private write;
+    view(): DiscordAwarenessView[];
+    /**
+     * Run one act after every act queued before it, on the document as it is
+     * then (read first if it isn't held). A version 2 ledger is rewritten as
+     * version 3 by the first act, before the act's own change.
+     */
+    private act;
+    /** Drop the document held in memory and read the file back; if it can't
+     *  be read, the next read tries again. */
+    private forget;
+    /**
+     * Read the ledger for an act. A version 2 ledger is rewritten as version
+     * 3 (migrateLedger), the work it drops announced before the write; the
+     * rewritten document is held only once its write is on disk.
+     */
+    private open;
+    /**
+     * The document for a view: as held, or read now. A version 2 ledger is
+     * refused here: only an act rewrites it.
+     */
+    private loaded;
+    /**
+     * Write the document. A write that throws has left the file as it was, so
+     * the act's change, already made in memory, is dropped: the document is
+     * read back from the file, and if it can't be read, the next read tries
+     * again. `afterCommittedState` syncs the store first.
+     */
+    private persist;
 }
-export {};
+/** The report of a directory that couldn't be synced, in the words of the
+ *  framework's recovery-sync alert. */
+export declare function unsyncedWriteText(directory: string, path: string, error: unknown): string;
+/** The Discord channel id a ref's channel names: its last part, when it's
+ *  spelled `discord:<guild>:<channel>`. Delivery sends it, and keys use it. */
+export declare function discordChannelOf(channelId: string): string;
 //# sourceMappingURL=discord-awareness-outbox.d.ts.map

package/dist/src/recovery/discord-awareness-outbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discord-awareness-outbox.d.ts","sourceRoot":"","sources":["../../../src/recovery/discord-awareness-outbox.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"discord-awareness-outbox.d.ts","sourceRoot":"","sources":["../../../src/recovery/discord-awareness-outbox.ts"],"names":[],"mappings":"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"}