@zackbart/connecta 0.34.0 → 0.35.0

package/dist/operator-ui/health.js

@@ -0,0 +1,52 @@
+/**
+ * The next steady evidence. A settled connector takes its current row; one
+ * being read again keeps its previous evidence when this identity has any.
+ * Returns `previous` itself when nothing changed, so it can live in React
+ * state. A new identity starts empty.
+ */
+export function steadyHealth(state, previous) {
+    const same = previous?.generation === state.generation ? previous : null;
+    const contract = state.contract?.role === "maintainer" && state.data ? state.contract : null;
+    // No contract on screen: keep what was shown until the next one arrives.
+    if (!contract || !state.data)
+        return same ?? { generation: state.generation, rows: Object.create(null) };
+    const reading = new Set(state.data.connectors.filter((c) => c.status === "loading").map((c) => c.id));
+    const held = same?.rows ?? Object.create(null);
+    const rows = Object.create(null);
+    let changed = !same || Object.keys(held).length !== contract.live.connectors.length;
+    for (const live of contract.live.connectors) {
+        const before = Object.hasOwn(held, live.id) ? held[live.id] : undefined;
+        if (before && reading.has(live.id)) {
+            rows[live.id] = before;
+            continue;
+        }
+        const failed = Object.hasOwn(state.connectorFailures, live.id) && Boolean(state.connectorFailures[live.id]);
+        if (before?.live === live && before.failed === failed)
+            rows[live.id] = before;
+        else {
+            rows[live.id] = { live, failed };
+            changed = true;
+        }
+    }
+    return changed ? { generation: state.generation, rows } : same;
+}
+/** The contract each view renders health from, with every live row replaced by its steady evidence. */
+export function shownHealth(contract, health) {
+    const signals = Object.create(null);
+    if (!contract)
+        return { contract, signals };
+    let replaced = false;
+    const connectors = contract.live.connectors.map((live) => {
+        const row = Object.hasOwn(health.rows, live.id) ? health.rows[live.id] : undefined;
+        if (row?.failed)
+            signals[live.id] = { failed: true };
+        if (!row || row.live === live)
+            return live;
+        replaced = true;
+        return row.live;
+    });
+    return {
+        contract: replaced ? { ...contract, live: { ...contract.live, connectors } } : contract,
+        signals,
+    };
+}

package/dist/operator-ui/model.d.ts

@@ -1,6 +1,6 @@
 import type { ConnectaConfigDescription } from "../describe-config.js";
+import type { CatalogAccessObservation, ResourceTemplateRefusalCode } from "../types.js";
 import type { OperatorConnectorOverlay, OperatorTool } from "./contract.js";
-import type { CatalogAccessObservation, CatalogDriftReport, ResourceTemplateRefusalCode } from "../types.js";
 /** Tool verdicts, independent of whether the selected pool is read-only. */
 export type UiToolSafety = "runs_in_programs" | "needs_approval";
 export interface UiTool extends Pick<OperatorTool, "name" | "address" | "description"> {
@@ -91,7 +91,6 @@ export interface UiConnector {
      * drifted — which is why the UI renders that as its own state rather than as
      * a clean one.
      */
-    catalogDrift?: CatalogDriftReport;
     /** Last agent-facing catalog read in this runtime; never persisted. */
     catalogAccess?: CatalogAccessObservation;
     resourceTemplateRefusals?: ResourceTemplateRefusalCode[];
@@ -114,7 +113,7 @@ export interface UiData {
      */
     pools?: string[];
 }
-export interface FilteredUiConnector {
+interface FilteredUiConnector {
     connector: UiConnector;
     tools: UiTool[];
 }

package/dist/operator-ui/overview.js

@@ -13,7 +13,7 @@ function affects(paths) {
     return paths.length ? `Affects ${joinList(paths)}` : "No endpoint serves it";
 }
 /**
- * One row per connector that is not healthy, failing first, then one per
+ * One row per connector that is not healthy, in config order, then one per
  * agent that sits in an endpoint without a working token. Each row carries
  * the fix the rest of the UI already offers for it.
  */
@@ -26,7 +26,7 @@ export function attentionItems(contract, options = {}) {
         const live = contract.live.connectors.find((c) => c.id === config.id);
         if (!live)
             continue;
-        const signals = options.signals?.[config.id] ?? {};
+        const signals = options.signals && Object.hasOwn(options.signals, config.id) ? options.signals[config.id] : {};
         const verdict = connectorVerdict(live, signals);
         if ((verdict.tone !== "warn" && verdict.tone !== "danger") || !verdict.action)
             continue;
@@ -71,22 +71,16 @@ export function attentionItems(contract, options = {}) {
                 fix: null,
             });
         }
-        else {
-            // Healthy but drifted: the live tool list differs from the reviewed one.
-            connectors.push({
-                ...base,
-                problem: "has a changed tool list",
-                body: affects(paths),
-                fix: { kind: "catalog_drift", connectorId: config.id },
-            });
-        }
     }
     const agents = contract.agents
-        .filter((agent) => agent.pools.length && agent.token.state !== "issued")
+        .filter((agent) => agent.pools.length &&
+        !agent.credentialTypes.includes("vercel_oidc") &&
+        agent.token &&
+        agent.token.state !== "issued")
         .map((agent) => {
         // An agent connects only at a pool's agent URL.
         const paths = agent.pools.map((name) => contract.pools.find((pool) => pool.name === name)?.agentPath ?? `/agent/${name}`);
-        const revoked = agent.token.state === "revoked";
+        const revoked = agent.token?.state === "revoked";
         return {
             key: `agent:${agent.name}`,
             kind: "agent",
@@ -101,11 +95,9 @@ export function attentionItems(contract, options = {}) {
             fix: null,
         };
     });
-    return [
-        ...connectors.filter((item) => item.tone === "danger"),
-        ...connectors.filter((item) => item.tone === "warn"),
-        ...agents,
-    ];
+    // Severity changes as individual details settle. Config order keeps surviving
+    // rows in place without waiting for the slowest connector's read.
+    return [...connectors, ...agents];
 }
 /** The numbers above the list, counted from the same map the page draws. */
 export function overviewHeadline(contract, map, items, signals = {}) {
@@ -113,7 +105,7 @@ export function overviewHeadline(contract, map, items, signals = {}) {
         const live = contract.live.connectors.find((c) => c.id === config.id);
         if (!live)
             return [];
-        const health = connectorVerdict(live, signals[config.id]);
+        const health = connectorVerdict(live, Object.hasOwn(signals, config.id) ? signals[config.id] : undefined);
         return [{ id: config.id, title: config.title ?? config.id, tone: health.tone, label: health.label }];
     });
     const healthy = bar.filter((entry) => entry.tone === "ok").length;

package/dist/operator-ui/setup-commands.js

@@ -22,10 +22,6 @@ export function clientServerName(serverName, pool) {
         .slice(0, 48) || "connecta";
     return pool ? `${base}-${pool}` : base;
 }
-/** The URL for a pool: `/mcp` plus its name, which config limits to `[a-z0-9_-]`. */
-export function poolEndpointUrl(mcpUrl, pool) {
-    return `${mcpUrl.replace(/\/+$/, "")}/${encodeURIComponent(pool)}`;
-}
 /** POSIX single-quoting, only when the value needs it. */
 function shellWord(value) {
     return /^[A-Za-z0-9_./:@%+=,~-]+$/.test(value) ? value : `'${value.replace(/'/g, `'"'"'`)}'`;

package/dist/operator-ui/view.d.ts

@@ -1,8 +1,7 @@
+import type { AgentSlot } from "./agents.js";
 import type { OperatorRole, OperatorUiContractV2 } from "./contract.js";
-import type { CatalogDriftReport } from "../types.js";
-import type { CredentialManagementCapability, UiConnector, UiData, UiProblem } from "./model.js";
 import type { FixPromptKind } from "./fix-prompts.js";
-import type { AgentSlot } from "./agents.js";
+import type { UiConnector, UiData, UiProblem } from "./model.js";
 export declare function registrationPathLabel(path: NonNullable<UiConnector["registrationPath"]>): string;
 export type OperatorPage = "overview" | "endpoints" | "settings" | "connector" | "tokens" | "connections" | "activity";
 /** Pages the nav lists, in dashboard order. */
@@ -302,7 +301,6 @@ export declare function resetIdentity(state: OperatorState, gate?: Notice | null
  * typed credential, and the notices that answered the page just left.
  */
 export declare function withPage(state: OperatorState, page: OperatorPage): OperatorState;
-export declare function credentialUnavailableCopy(capability?: CredentialManagementCapability): string;
 /**
  * The status badge. An auth-needed connector is named by what it needs, so a
  * row whose fix is "Add credential" does not say "Authorization needed".
@@ -318,9 +316,8 @@ export declare function problemCopy(problem: UiProblem | undefined): string | nu
  * error. The two used to share the red box, so the row contradicted itself.
  */
 export declare function problemTone(problem: UiProblem): "warn" | "danger";
-/** What the page knows about a connector beyond its live status: catalog drift and a failed detail read. */
+/** What the page knows about a connector beyond its live status: a failed detail read. */
 export interface ConnectorSignals {
-    drift?: boolean;
     failed?: boolean;
 }
 /** One connector's health everywhere it is shown: badge tone, status word, and the one action beside it. */
@@ -328,12 +325,12 @@ export interface ConnectorVerdict {
     tone: "ok" | "warn" | "danger" | "neutral";
     label: string;
     /** The link to the Connection tab, or null when the connector is fine. */
-    action: "Connect" | "Replace key" | "Inspect" | "Review" | null;
+    action: "Connect" | "Replace key" | "Inspect" | null;
 }
 /**
  * The verdict the Connectors list, the Overview, Endpoints and a connector's
  * page all show. The server's problem code comes first, then a failed detail
- * read on this page, then a non-ok status, then catalog drift. A problem
+ * read on this page, then a non-ok status. Catalog drift is informational. A problem
  * outranks the status, so a connector whose catalog failed is never
  * "Connected". A failed read marks its connector `connector_unavailable` in
  * the store, so that one code beside a failed read is the page's own and
@@ -343,27 +340,6 @@ export declare function connectorVerdict(live: {
     status: string;
     problem?: UiProblem;
 }, signals?: ConnectorSignals): ConnectorVerdict;
-/**
- * Hosted-provider catalog drift, as an operator reads it
- * ([#343](https://github.com/zackbart/connecta/issues/343)).
- *
- * - `unavailable` — no refresh has been observed in this runtime, so there is
- *   nothing to report. Deliberately not `clean`: "we have not looked" and "we
- *   looked and it matches" are different answers, and only one of them is a
- *   reason to stop worrying.
- * - `clean` — a refresh happened and every category counted zero.
- * - `warning` — a refresh happened and at least one category did not.
- */
-export type DriftState = "clean" | "warning" | "unavailable";
-export declare function driftState(drift?: CatalogDriftReport): DriftState;
-/** Every category with its count, so a clean report still shows its zeros. */
-export declare function driftCounts(drift?: CatalogDriftReport): Array<{
-    key: string;
-    label: string;
-    count: number;
-}>;
-/** One line naming the state and when it was observed. Never what drifted. */
-export declare function driftSummary(drift?: CatalogDriftReport): string;
 /**
  * Only http/https may become a clickable href — the browser half of the gate
  * `src/ui.ts` applies before an authorizationUrl is ever serialized. A hostile

package/dist/operator-ui/view.js

@@ -345,15 +345,6 @@ export function withPage(state, page) {
         confirming: null,
     };
 }
-export function credentialUnavailableCopy(capability) {
-    if (capability === "no_slots") {
-        return "No connector declares a credential slot. Credentials stay in code.";
-    }
-    if (capability === "vault_not_configured") {
-        return "No credential vault is configured.";
-    }
-    return "Managing credentials needs an interactive sign-in. A bearer token can only view them.";
-}
 /**
  * The status badge. An auth-needed connector is named by what it needs, so a
  * row whose fix is "Add credential" does not say "Authorization needed".
@@ -425,7 +416,7 @@ function problemAction(problem) {
 /**
  * The verdict the Connectors list, the Overview, Endpoints and a connector's
  * page all show. The server's problem code comes first, then a failed detail
- * read on this page, then a non-ok status, then catalog drift. A problem
+ * read on this page, then a non-ok status. Catalog drift is informational. A problem
  * outranks the status, so a connector whose catalog failed is never
  * "Connected". A failed read marks its connector `connector_unavailable` in
  * the store, so that one code beside a failed read is the page's own and
@@ -443,57 +434,8 @@ export function connectorVerdict(live, signals = {}) {
         const tone = connectorStatusTone(live.status) === "warn" ? "warn" : "danger";
         return { tone, label: connectorStatusLabel(live.status), action: tone === "warn" ? "Connect" : "Inspect" };
     }
-    if (signals.drift)
-        return { tone: "warn", label: "Catalog drift", action: "Review" };
     return { tone: "ok", label: "Connected", action: null };
 }
-/**
- * The categories, in the order an operator should read them: what the
- * deployment refuses to call, what it can no longer call, what contradicts a
- * vetted verdict, and what changed shape underneath a reviewed schema. Counts
- * only — a name or a schema on this path would be the payload leak the whole
- * drift model exists to avoid.
- */
-const DRIFT_CATEGORIES = [
-    { key: "unclassifiedTools", label: "Unclassified" },
-    { key: "unservedTools", label: "Unserved" },
-    { key: "annotationConflicts", label: "Annotation conflicts" },
-    { key: "schemaChanges", label: "Schema changes" },
-    { key: "droppedTools", label: "Dropped tool names" },
-];
-function driftTotal(drift) {
-    if (!drift)
-        return 0;
-    return DRIFT_CATEGORIES.reduce((sum, { key }) => sum + (drift[key] || 0), 0);
-}
-export function driftState(drift) {
-    if (!drift)
-        return "unavailable";
-    return driftTotal(drift) > 0 ? "warning" : "clean";
-}
-/** Every category with its count, so a clean report still shows its zeros. */
-export function driftCounts(drift) {
-    if (!drift)
-        return [];
-    return DRIFT_CATEGORIES.filter(({ key }) => key !== "droppedTools" || drift.droppedTools !== undefined).map(({ key, label }) => ({
-        key,
-        label,
-        count: drift[key] || 0,
-    }));
-}
-/** One line naming the state and when it was observed. Never what drifted. */
-export function driftSummary(drift) {
-    const state = driftState(drift);
-    if (state === "unavailable") {
-        return "No catalog refresh yet.";
-    }
-    const observed = formatDate(drift?.observedAt);
-    const when = observed ? ` · observed ${observed}` : "";
-    if (state === "clean")
-        return `Matches the reviewed manifest${when}`;
-    const total = driftTotal(drift);
-    return `${total} difference${total === 1 ? "" : "s"} from the reviewed manifest${when}`;
-}
 /**
  * Only http/https may become a clickable href — the browser half of the gate
  * `src/ui.ts` applies before an authorizationUrl is ever serialized. A hostile
@@ -528,6 +470,7 @@ const ACTOR_KINDS = {
     "cloudflare-access": "Cloudflare Access",
     anonymous: "Anonymous",
     access_token: "Agent token",
+    vercel_oidc: "Vercel workload",
 };
 /** How a caller signed in, as a person reads it. An unknown kind is shown as sent. */
 function actorKindLabel(kind) {
@@ -610,6 +553,7 @@ export function activityOutcomeBadge(outcome) {
     return OUTCOME_BADGE[outcome] ?? { label: "Failed", tone: "danger" };
 }
 const SOURCE_LABELS = {
+    native: "Native tool call",
     execute_code: "In a program",
     call_tool: "Direct call",
     call_destructive_tool: "Direct call, approved by the host",

package/dist/program-writes.js

@@ -17,28 +17,38 @@ export function writeStateOf(outcome) {
             error: outcome.error,
             ...(outcome.answered !== undefined ? { answered: outcome.answered } : {}),
         });
-    return state === "unknown" && !outcome.ok && outcome.error.uncertainCall
+    if (state !== "unknown" || outcome.ok)
+        return state;
+    const { error } = outcome;
+    const handoff = (error.code === "auth_required" || error.code === "downstream_oauth_required") &&
+        error.nextAction &&
+        "tool" in error.nextAction &&
+        error.nextAction.tool === "authorize_connector"
         ? {
-            state,
-            uncertainCall: outcome.error.uncertainCall,
-            ...(outcome.error.details?.stage !== undefined
-                ? {
-                    deadline: {
-                        ...(outcome.error.details.operation !== undefined
-                            ? { operation: outcome.error.details.operation }
-                            : {}),
-                        stage: outcome.error.details.stage,
-                        ...(outcome.error.details.elapsedMs !== undefined
-                            ? { elapsedMs: outcome.error.details.elapsedMs }
-                            : {}),
-                        ...(outcome.error.details.deadlineMs !== undefined
-                            ? { deadlineMs: outcome.error.details.deadlineMs }
-                            : {}),
-                    },
-                }
-                : {}),
+            code: error.code,
+            ...(error.connector !== undefined ? { connector: error.connector } : {}),
+            ...(error.recovery !== undefined ? { recovery: error.recovery } : {}),
+            nextAction: error.nextAction,
+            ...(error.retry !== undefined ? { retry: error.retry } : {}),
         }
-        : state;
+        : undefined;
+    if (!error.uncertainCall && !handoff)
+        return state;
+    return {
+        state,
+        ...(error.uncertainCall ? { uncertainCall: error.uncertainCall } : {}),
+        ...(error.uncertainCall && error.details?.stage !== undefined
+            ? {
+                deadline: {
+                    ...(error.details.operation !== undefined ? { operation: error.details.operation } : {}),
+                    stage: error.details.stage,
+                    ...(error.details.elapsedMs !== undefined ? { elapsedMs: error.details.elapsedMs } : {}),
+                    ...(error.details.deadlineMs !== undefined ? { deadlineMs: error.details.deadlineMs } : {}),
+                },
+            }
+            : {}),
+        ...(handoff ? { handoff } : {}),
+    };
 }
 /**
  * The writes one program sends. The play closes this when the
@@ -55,6 +65,7 @@ export class ProgramWrites {
     uncertainCalls = [];
     uncertainCallsTruncated = false;
     deadlines = [];
+    handoff;
     /** Whether the program has settled: a write gated now is not sent. */
     get isClosed() {
         return this.closed;
@@ -80,12 +91,15 @@ export class ProgramWrites {
             recorded = true;
             const state = typeof completion === "string" ? completion : completion.state;
             if (typeof completion !== "string") {
-                if (this.uncertainCalls.length < 10)
-                    this.uncertainCalls.push(completion.uncertainCall);
-                else
-                    this.uncertainCallsTruncated = true;
+                if (completion.uncertainCall) {
+                    if (this.uncertainCalls.length < 10)
+                        this.uncertainCalls.push(completion.uncertainCall);
+                    else
+                        this.uncertainCallsTruncated = true;
+                }
                 if (completion.deadline && this.deadlines.length < 10)
                     this.deadlines.push(completion.deadline);
+                this.handoff ??= completion.handoff;
             }
             this.states.push(state);
             this.inFlight.delete(settled);
@@ -108,10 +122,17 @@ export class ProgramWrites {
             unknown: this.states.filter((state) => state === "unknown").length,
         };
         if (writes.unknown > 0) {
+            // Caught or not, an authorization verdict a write met after it left is
+            // the result, as a direct call reports it: its code and handoff, never
+            // retryable, with the write's outcome unknown.
+            const handoff = this.handoff;
             return errorEnvelope({
-                code: "write_outcome_unknown",
-                message: "A write this program sent has no known outcome, so that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call.",
+                code: handoff?.code ?? "write_outcome_unknown",
+                message: handoff
+                    ? "A write this program sent failed authorization after it left, so whether it took effect is unknown, and that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it, and give nextAction to the operator to recover the connector. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call."
+                    : "A write this program sent has no known outcome, so that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call.",
                 retryable: false,
+                ...(handoff ? { ...handoff, reconciliationRequired: true, writeOutcome: "unknown" } : {}),
                 ...(this.deadlines.length > 0 ? { details: this.deadlines[0] } : {}),
                 ...(this.deadlines.length > 1 ? { timeouts: this.deadlines } : {}),
                 ...(this.uncertainCalls.length === 1

package/dist/provider-call-facts.d.ts

@@ -0,0 +1,115 @@
+import { ConnectorCallError } from "./errors.js";
+import type { Connector } from "./types.js";
+export interface ProviderRequest {
+    readonly dispatched: boolean;
+    readonly status?: number;
+    auxiliary: boolean;
+    /** A kit auxiliary declared as a read lacked physical GET/HEAD proof at dispatch. */
+    readonly blocksAuxiliaryProof?: true;
+    provider: string;
+    /** The HTTP method it was sent with, when its channel knows it. */
+    readonly method?: string;
+    /** Positive operation/tool evidence; an HTTP method alone proves no read. */
+    classification?: "read" | "write" | undefined;
+    /** Remote MCP's source class said write, recorded at physical dispatch. */
+    readonly sourceWrite?: true;
+    /** The genuine, legal idempotency key the vendor honors that it carried; nothing else. */
+    key?: string;
+    /**
+     * Its answer was a 401 that the transport's reviewed `authBeforeExecution`
+     * evidence covers: the vendor rejected the credential before it acted on
+     * the request. Only that makes a 401 a refusal (`servedRefusal`).
+     */
+    authBeforeExecution?: true;
+    /**
+     * Its answer was a 401, and a renewal then replaced the credential it sent
+     * with a different one ({@link renewedAfterUnauthorized}). The 401 no
+     * longer needs the operator's recovery. The single `settleWrite` decider
+     * still reports unknown, without the handoff (Q8).
+     */
+    readonly renewed?: true;
+}
+export type CallTool = Connector["callTool"];
+interface Boundary {
+    /** The api() or remoteMcp() object whose own code enters the logical call. */
+    boundary: object;
+    own: CallTool;
+}
+export declare function originalCallIdentity(connector: object): object;
+export declare function boundaryFor(connector: object): Boundary | undefined;
+export declare function delegatorFor(connector: object): CallTool | undefined;
+/** A physical send owns its fields permanently; its own answer is recorded once. */
+export declare function recordRequestField(request: ProviderRequest, field: keyof ProviderRequest, value: unknown): void;
+export declare function recordProviderResponse(request: ProviderRequest, status: number): void;
+/**
+ * Declare that every request the connector's handlers send goes through a
+ * channel the call ledger records: a guarded transport, `ctx.fetch`, or
+ * `ctx.oauth.fetch`. Only then does an empty ledger prove that a failed
+ * write never left. Maintained providers declare it; an arbitrary `api()`
+ * handler can reach the network some other way, so its ledger proves nothing.
+ */
+export declare function tracksEveryRequest<T extends object>(connector: T): T;
+export declare function tracksRequests(connector: object): boolean;
+/**
+ * Declare a maintained connector whose `callTool` hands each call to at most
+ * one api() or remoteMcp() boundary and sends nothing else that could apply
+ * it (GitHub). Only then may that boundary's verdict stand for the call. The
+ * object and its function are recorded now, at construction: a later
+ * assignment to the property, or a copy of the object, declares nothing.
+ */
+export declare function delegatesEachCall<T extends Connector>(connector: T): T;
+/**
+ * Record a just-built api() or remoteMcp() object as a boundary, with its
+ * published `callTool`. Its own code then names the same object, from its
+ * closure, in {@link enterProviderBoundary}.
+ */
+export declare function providerBoundary(connector: Connector): void;
+/**
+ * `alias` serves `base` itself (`defineProvider`'s inheriting stamp), so it
+ * takes `base`'s recorded identities. Only construction code calls this.
+ */
+export declare function aliasCallIdentity(alias: object, base: object): void;
+/**
+ * Whether a served HTTP status says the request was refused, not applied: a
+ * 4xx other than 408. A 408 is a timeout, whose request may have been acted
+ * on; a 2xx or 5xx never proves a write unapplied. A 401 passes here, and
+ * `servedRefusal` still asks for the vendor's reviewed evidence.
+ */
+export declare function refusedStatus(status: number | undefined): boolean;
+/**
+ * Refusal provenance, recorded where the answer is observed: the request was
+ * served a refusing status (`refusedStatus`) and the mapper failed on it. An
+ * error code alone is never this evidence.
+ */
+export declare function vendorRefusal<T>(error: T, request: ProviderRequest): T;
+/** An authorization verdict, the kind that keeps the `authorize_connector` handoff. */
+export declare function authorizationFailure(error: unknown): error is ConnectorCallError;
+/**
+ * The authorization verdict `request`'s own 401 answer was mapped to, as
+ * {@link vendorRefusal} recorded it. Undefined when nothing mapped that
+ * answer, such as a body past the ceiling.
+ */
+export declare function unauthorizedAnswer(request: ProviderRequest): ConnectorCallError | undefined;
+/**
+ * A renewal answered `request`'s own 401 (a refresh, a login, a fresh token
+ * minted) with `fresh`, a credential other than `sent`, the one the request
+ * carried: that 401 no longer needs the operator's recovery (Q8). It names
+ * the one request it answered and never marks another. A renewal that hands
+ * back the credential the request already sent (an earlier recovery reused)
+ * renewed nothing.
+ */
+export declare function renewedAfterUnauthorized(request: ProviderRequest | undefined, sent: string, fresh: string): void;
+export declare function refusalRequest(error: unknown): ProviderRequest | undefined;
+export declare function knownProviderFailure<T>(error: T): T;
+export declare function isKnownProviderFailure(error: unknown): boolean;
+/** Withdraw a verdict that does not hold for the call that reports it. */
+export declare function forgetProviderFailure(error: object): void;
+/** Preserve internal verdicts and resend advice through redaction and provider recovery wording. */
+export declare function carryProviderFailure<T>(from: unknown, to: T): T;
+/** Mark a verdict that already accounts for a write's 401 in its own words. */
+export declare function explainedUnauthorizedVerdict<T>(error: T): T;
+export declare function explainsUnauthorized(error: unknown): boolean;
+/** Mark a verdict the Q8 decision made, final for every step after it. */
+export declare function settledWrite<T>(error: T): T;
+export declare function isSettledWrite(error: unknown): boolean;
+export {};