@fabricorg/platform 1.9.0 → 1.10.1

package/dist/adapters/index.d.ts

@@ -1,3 +1,4 @@
+//#region adapters/circuit-breaker.d.ts
 /**
  * State of an adapter circuit breaker.
  *
@@ -7,7 +8,7 @@
  * - `half_open`: the cooldown elapsed. One probe call is admitted; its outcome
  *   closes the breaker (success) or reopens it (failure).
  */
-type AdapterCircuitState = "closed" | "open" | "half_open";
+export type AdapterCircuitState = "closed" | "open" | "half_open";
 /**
  * How a single adapter outcome counts toward the breaker.
  *
@@ -17,7 +18,7 @@ type AdapterCircuitState = "closed" | "open" | "half_open";
  *   (a validation or business rejection). It is neither a success nor a
  *   dependency failure and does not enter the rolling window.
  */
-type AdapterCircuitOutcome = "success" | "failure" | "ignored";
+export type AdapterCircuitOutcome = "success" | "failure" | "ignored";
 /**
  * Map an {@link AdapterOutcomeKind} to how it counts toward a circuit breaker.
  *
@@ -37,90 +38,90 @@ type AdapterCircuitOutcome = "success" | "failure" | "ignored";
  * `classifyThrownError` (default `transient_failure`) and maps that kind here,
  * so an unclassified thrown error counts as a failure.
  */
-declare function classifyCircuitBreakerOutcome(kind: AdapterOutcomeKind): AdapterCircuitOutcome;
+export declare function classifyCircuitBreakerOutcome(kind: AdapterOutcomeKind): AdapterCircuitOutcome;
 /** The answer a breaker gives before a call. */
-interface AdapterCircuitAdmission {
-    /**
-     * Whether the call may proceed. Always `true` in `monitor` mode; `false`
-     * only in `enforce` mode while the breaker is open, forced open, or
-     * half-open with its probe already in flight.
-     */
-    allowed: boolean;
-    /** State at the time of the decision. */
-    state: AdapterCircuitState;
-    /** True when this admission is the half-open probe. Pass it back to `record`. */
-    probe: boolean;
-    /** Monitor mode only: true when `enforce` mode would have rejected this call. */
-    wouldReject?: boolean;
-    /**
-     * Milliseconds until the breaker will admit a probe, when known. Absent while
-     * a manual `force_open` override is set or a half-open probe is in flight.
-     */
-    retryAfterMs?: number;
-    /** Set when a manual override decided the admission. */
-    manualOverride?: AdapterCircuitBreakerManualOverride;
-    /**
-     * The breaker epoch the admission was granted in; opaque to callers.
-     * {@link InMemoryAdapterCircuitBreaker} lets an outcome change state only
-     * when this still matches its current epoch. An admission without it is
-     * treated as current.
-     */
-    generation?: number;
+export interface AdapterCircuitAdmission {
+  /**
+   * Whether the call may proceed. Always `true` in `monitor` mode; `false`
+   * only in `enforce` mode while the breaker is open, forced open, or
+   * half-open with its probe already in flight.
+   */
+  allowed: boolean;
+  /** State at the time of the decision. */
+  state: AdapterCircuitState;
+  /** True when this admission is the half-open probe. Pass it back to `record`. */
+  probe: boolean;
+  /** Monitor mode only: true when `enforce` mode would have rejected this call. */
+  wouldReject?: boolean;
+  /**
+   * Milliseconds until the breaker will admit a probe, when known. Absent while
+   * a manual `force_open` override is set or a half-open probe is in flight.
+   */
+  retryAfterMs?: number;
+  /** Set when a manual override decided the admission. */
+  manualOverride?: AdapterCircuitBreakerManualOverride;
+  /**
+   * The breaker epoch the admission was granted in; opaque to callers.
+   * {@link InMemoryAdapterCircuitBreaker} lets an outcome change state only
+   * when this still matches its current epoch. An admission without it is
+   * treated as current.
+   */
+  generation?: number;
 }
 /**
  * Contract between a circuit breaker and `executeWithAdapterRetry`.
  * Implement it to plug in a shared or distributed breaker.
  */
-interface AdapterCircuitBreaker {
-    /** Registry key this breaker guards; defaults to `adapterType:operation`. */
-    readonly key: string;
-    readonly mode: "monitor" | "enforce";
-    /** Current state, applying any elapsed cooldown or manual override. */
-    getState(): AdapterCircuitState;
-    /**
-     * Preview whether a call would be admitted now. Side-effect free: it does
-     * not commit an elapsed cooldown, take the half-open probe or emit
-     * telemetry.
-     */
-    check(): AdapterCircuitAdmission;
-    /**
-     * Decide whether a call may start now. Call it immediately before the
-     * external effect and pass the returned admission to {@link record}.
-     */
-    acquire(): AdapterCircuitAdmission;
-    /**
-     * Record the outcome of a call that was admitted by {@link acquire}. Pass
-     * that admission, not a {@link check} preview, so the breaker can tell a
-     * stale outcome from a current one.
-     */
-    record(outcome: AdapterCircuitOutcome, admission?: AdapterCircuitAdmission): void;
+export interface AdapterCircuitBreaker {
+  /** Registry key this breaker guards; defaults to `adapterType:operation`. */
+  readonly key: string;
+  readonly mode: "monitor" | "enforce";
+  /** Current state, applying any elapsed cooldown or manual override. */
+  getState(): AdapterCircuitState;
+  /**
+   * Preview whether a call would be admitted now. Side-effect free: it does
+   * not commit an elapsed cooldown, take the half-open probe or emit
+   * telemetry.
+   */
+  check(): AdapterCircuitAdmission;
+  /**
+   * Decide whether a call may start now. Call it immediately before the
+   * external effect and pass the returned admission to {@link record}.
+   */
+  acquire(): AdapterCircuitAdmission;
+  /**
+   * Record the outcome of a call that was admitted by {@link acquire}. Pass
+   * that admission, not a {@link check} preview, so the breaker can tell a
+   * stale outcome from a current one.
+   */
+  record(outcome: AdapterCircuitOutcome, admission?: AdapterCircuitAdmission): void;
 }
-type AdapterCircuitBreakerEventReason = "failure_threshold" | "cooldown_elapsed" | "probe_succeeded" | "probe_failed" | "manual_override" | "manual_override_cleared";
+export type AdapterCircuitBreakerEventReason = "failure_threshold" | "cooldown_elapsed" | "probe_succeeded" | "probe_failed" | "manual_override" | "manual_override_cleared";
 interface AdapterCircuitBreakerEventBase {
-    key: string;
-    mode: "monitor" | "enforce";
-    /** Epoch milliseconds from the breaker's clock. */
-    at: number;
+  key: string;
+  mode: "monitor" | "enforce";
+  /** Epoch milliseconds from the breaker's clock. */
+  at: number;
 }
 /** Telemetry reported by {@link InMemoryAdapterCircuitBreaker}. */
-type AdapterCircuitBreakerEvent = (AdapterCircuitBreakerEventBase & {
-    type: "state_change";
-    from: AdapterCircuitState;
-    to: AdapterCircuitState;
-    reason: AdapterCircuitBreakerEventReason;
-    manualOverride?: AdapterCircuitBreakerManualOverride;
+export type AdapterCircuitBreakerEvent = (AdapterCircuitBreakerEventBase & {
+  type: "state_change";
+  from: AdapterCircuitState;
+  to: AdapterCircuitState;
+  reason: AdapterCircuitBreakerEventReason;
+  manualOverride?: AdapterCircuitBreakerManualOverride;
 }) | (AdapterCircuitBreakerEventBase & {
-    /** Enforce mode refused a call; it was not attempted. */
-    type: "rejected";
-    state: AdapterCircuitState;
-    retryAfterMs?: number;
-    manualOverride?: AdapterCircuitBreakerManualOverride;
+  /** Enforce mode refused a call; it was not attempted. */
+  type: "rejected";
+  state: AdapterCircuitState;
+  retryAfterMs?: number;
+  manualOverride?: AdapterCircuitBreakerManualOverride;
 }) | (AdapterCircuitBreakerEventBase & {
-    /** Monitor mode let a call through that enforce mode would have refused. */
-    type: "would_reject";
-    state: AdapterCircuitState;
-    retryAfterMs?: number;
-    manualOverride?: AdapterCircuitBreakerManualOverride;
+  /** Monitor mode let a call through that enforce mode would have refused. */
+  type: "would_reject";
+  state: AdapterCircuitState;
+  retryAfterMs?: number;
+  manualOverride?: AdapterCircuitBreakerManualOverride;
 });
 /**
  * Telemetry callback. Errors it throws and promises it rejects are caught
@@ -131,14 +132,14 @@ type AdapterCircuitBreakerEvent = (AdapterCircuitBreakerEventBase & {
  * record. A callback may call back into the breaker; it sees committed state,
  * and events its own calls produce are delivered after it returns, in order.
  */
-type AdapterCircuitBreakerEventListener = (event: AdapterCircuitBreakerEvent) => void | Promise<void>;
-interface InMemoryAdapterCircuitBreakerOptions {
-    /** Usually `adapterType:operation`. */
-    key: string;
-    config: AdapterCircuitBreakerConfig;
-    /** Epoch-millisecond clock. Defaults to `Date.now`. */
-    now?: () => number;
-    onEvent?: AdapterCircuitBreakerEventListener;
+export type AdapterCircuitBreakerEventListener = (event: AdapterCircuitBreakerEvent) => void | Promise<void>;
+export interface InMemoryAdapterCircuitBreakerOptions {
+  /** Usually `adapterType:operation`. */
+  key: string;
+  config: AdapterCircuitBreakerConfig;
+  /** Epoch-millisecond clock. Defaults to `Date.now`. */
+  now?: () => number;
+  onEvent?: AdapterCircuitBreakerEventListener;
 }
 /**
  * Validate a circuit-breaker config. Throws a `RangeError` naming the first
@@ -147,7 +148,7 @@ interface InMemoryAdapterCircuitBreakerOptions {
  * finite numbers; `cooldownMs` a non-negative finite number; `manualOverride`
  * `force_open` or `force_closed` when present.
  */
-declare function assertAdapterCircuitBreakerConfig(config: AdapterCircuitBreakerConfig): void;
+export declare function assertAdapterCircuitBreakerConfig(config: AdapterCircuitBreakerConfig): void;
 /**
  * Dependency-free, in-process circuit breaker for one adapter operation.
  *
@@ -211,72 +212,72 @@ declare function assertAdapterCircuitBreakerConfig(config: AdapterCircuitBreaker
  * automatic open, `force_open` blocks only in `enforce` mode. Clearing the
  * override returns the breaker to `closed` with its window intact.
  */
-declare class InMemoryAdapterCircuitBreaker implements AdapterCircuitBreaker {
-    readonly key: string;
-    readonly mode: "monitor" | "enforce";
-    private readonly config;
-    private readonly now;
-    private readonly onEvent;
-    private readonly probeLeaseMs;
-    private samples;
-    private state;
-    private openedAt;
-    private probeIssuedAt;
-    /** Advances on every state change, manual override change and probe grant. */
-    private generation;
-    private manualOverride;
-    /** Telemetry waiting for the current operation to commit. */
-    private readonly outbox;
-    private operationDepth;
-    private flushing;
-    constructor(options: InMemoryAdapterCircuitBreakerOptions);
-    getState(): AdapterCircuitState;
-    getManualOverride(): AdapterCircuitBreakerManualOverride | undefined;
-    /**
-     * Set (`force_open` / `force_closed`) or clear (`undefined`) the manual
-     * override. Clearing returns the breaker to `closed` with its window intact.
-     */
-    setManualOverride(override: AdapterCircuitBreakerManualOverride | undefined): void;
-    check(): AdapterCircuitAdmission;
-    acquire(): AdapterCircuitAdmission;
-    record(outcome: AdapterCircuitOutcome, admission?: AdapterCircuitAdmission): void;
-    private applyOutcome;
-    /**
-     * `take` is false for {@link check}: a pure preview that sees an elapsed
-     * cooldown without committing it, takes no probe and emits nothing.
-     */
-    private decide;
-    private refuse;
-    private releaseProbe;
-    /** Apply the time-based open → half_open transition. */
-    private advance;
-    private shouldTrip;
-    private prune;
-    private transition;
-    private reportedState;
-    /**
-     * Commit an elapsed cooldown as an operation of its own, delivering its
-     * event before the caller's operation reads state.
-     */
-    private settle;
-    /**
-     * Run `step` to completion, then deliver the telemetry it produced. The
-     * return value is fixed before any listener runs.
-     */
-    private operation;
-    private emit;
-    /**
-     * Deliver buffered events in order. A listener that calls back into the
-     * breaker queues its own events; this loop delivers them after it returns
-     * instead of recursing.
-     */
-    private flush;
-    private deliver;
+export declare class InMemoryAdapterCircuitBreaker implements AdapterCircuitBreaker {
+  readonly key: string;
+  readonly mode: "monitor" | "enforce";
+  private readonly config;
+  private readonly now;
+  private readonly onEvent;
+  private readonly probeLeaseMs;
+  private samples;
+  private state;
+  private openedAt;
+  private probeIssuedAt;
+  /** Advances on every state change, manual override change and probe grant. */
+  private generation;
+  private manualOverride;
+  /** Telemetry waiting for the current operation to commit. */
+  private readonly outbox;
+  private operationDepth;
+  private flushing;
+  constructor(options: InMemoryAdapterCircuitBreakerOptions);
+  getState(): AdapterCircuitState;
+  getManualOverride(): AdapterCircuitBreakerManualOverride | undefined;
+  /**
+   * Set (`force_open` / `force_closed`) or clear (`undefined`) the manual
+   * override. Clearing returns the breaker to `closed` with its window intact.
+   */
+  setManualOverride(override: AdapterCircuitBreakerManualOverride | undefined): void;
+  check(): AdapterCircuitAdmission;
+  acquire(): AdapterCircuitAdmission;
+  record(outcome: AdapterCircuitOutcome, admission?: AdapterCircuitAdmission): void;
+  private applyOutcome;
+  /**
+   * `take` is false for {@link check}: a pure preview that sees an elapsed
+   * cooldown without committing it, takes no probe and emits nothing.
+   */
+  private decide;
+  private refuse;
+  private releaseProbe;
+  /** Apply the time-based open → half_open transition. */
+  private advance;
+  private shouldTrip;
+  private prune;
+  private transition;
+  private reportedState;
+  /**
+   * Commit an elapsed cooldown as an operation of its own, delivering its
+   * event before the caller's operation reads state.
+   */
+  private settle;
+  /**
+   * Run `step` to completion, then deliver the telemetry it produced. The
+   * return value is fixed before any listener runs.
+   */
+  private operation;
+  private emit;
+  /**
+   * Deliver buffered events in order. A listener that calls back into the
+   * breaker queues its own events; this loop delivers them after it returns
+   * instead of recursing.
+   */
+  private flush;
+  private deliver;
 }
 /** Trusted invocation context available when selecting an adapter breaker. */
-interface AdapterCircuitBreakerScope {
-    tenantId: string;
-    spaceId?: string;
+export interface AdapterCircuitBreakerScope {
+  tenantId: string;
+  spaceId?: string;
 }
 /**
  * Key by tenant, optional space, vendor, and adapter operation. Components are
@@ -290,24 +291,24 @@ interface AdapterCircuitBreakerScope {
  * adapter type, but its absence is tolerated for JavaScript callers.
  * Keys appear in errors and telemetry: use non-secret identifiers.
  */
-declare function scopedAdapterCircuitBreakerKey(adapter: AdapterImplementation, scope: AdapterCircuitBreakerScope | undefined): string;
+export declare function scopedAdapterCircuitBreakerKey(adapter: AdapterImplementation, scope: AdapterCircuitBreakerScope | undefined): string;
 /** Supplies the breaker, if any, that guards an adapter in invocation scope. */
-interface AdapterCircuitBreakerProvider {
-    forAdapter(adapter: AdapterImplementation, scope?: AdapterCircuitBreakerScope): AdapterCircuitBreaker | undefined;
+export interface AdapterCircuitBreakerProvider {
+  forAdapter(adapter: AdapterImplementation, scope?: AdapterCircuitBreakerScope): AdapterCircuitBreaker | undefined;
 }
-interface AdapterCircuitBreakerRegistryOptions {
-    /**
-     * Defaults to `adapterType:operation`, shared across tenants and vendors in
-     * this registry. Use {@link scopedAdapterCircuitBreakerKey} for tenant,
-     * space, and vendor isolation. The first config seen for a key wins;
-     * later conflicting configs reuse that breaker without throwing. Breakers
-     * are never evicted, and scoped keys are high-cardinality: avoid them as
-     * metric labels.
-     */
-    key?: (adapter: AdapterImplementation, scope: AdapterCircuitBreakerScope | undefined) => string;
-    /** Epoch-millisecond clock handed to every breaker. Defaults to `Date.now`. */
-    now?: () => number;
-    onEvent?: AdapterCircuitBreakerEventListener;
+export interface AdapterCircuitBreakerRegistryOptions {
+  /**
+   * Defaults to `adapterType:operation`, shared across tenants and vendors in
+   * this registry. Use {@link scopedAdapterCircuitBreakerKey} for tenant,
+   * space, and vendor isolation. The first config seen for a key wins;
+   * later conflicting configs reuse that breaker without throwing. Breakers
+   * are never evicted, and scoped keys are high-cardinality: avoid them as
+   * metric labels.
+   */
+  key?: (adapter: AdapterImplementation, scope: AdapterCircuitBreakerScope | undefined) => string;
+  /** Epoch-millisecond clock handed to every breaker. Defaults to `Date.now`. */
+  now?: () => number;
+  onEvent?: AdapterCircuitBreakerEventListener;
 }
 /**
  * Lazily creates one {@link InMemoryAdapterCircuitBreaker} per
@@ -318,70 +319,71 @@ interface AdapterCircuitBreakerRegistryOptions {
  * wins; later conflicting configs reuse the existing breaker without throwing.
  * Share a key only between adapters intended to use the same configuration.
  */
-declare class AdapterCircuitBreakerRegistry implements AdapterCircuitBreakerProvider {
-    private readonly options;
-    private readonly breakers;
-    constructor(options?: AdapterCircuitBreakerRegistryOptions);
-    forAdapter(adapter: AdapterImplementation, scope?: AdapterCircuitBreakerScope): InMemoryAdapterCircuitBreaker | undefined;
-    /** Looks up the default `adapterType:operation` key without creating a breaker. */
-    get(adapterType: string, operation: string): InMemoryAdapterCircuitBreaker | undefined;
-    /** Looks up an exact key, including a custom key, without creating a breaker. */
-    getByKey(key: string): InMemoryAdapterCircuitBreaker | undefined;
+export declare class AdapterCircuitBreakerRegistry implements AdapterCircuitBreakerProvider {
+  private readonly options;
+  private readonly breakers;
+  constructor(options?: AdapterCircuitBreakerRegistryOptions);
+  forAdapter(adapter: AdapterImplementation, scope?: AdapterCircuitBreakerScope): InMemoryAdapterCircuitBreaker | undefined;
+  /** Looks up the default `adapterType:operation` key without creating a breaker. */
+  get(adapterType: string, operation: string): InMemoryAdapterCircuitBreaker | undefined;
+  /** Looks up an exact key, including a custom key, without creating a breaker. */
+  getByKey(key: string): InMemoryAdapterCircuitBreaker | undefined;
 }
 /**
  * Thrown by `executeWithAdapterRetry` when an `enforce`-mode breaker refuses
  * an attempt. The refused attempt never reached `execute`, so no external
  * effect happened for it.
  */
-declare class AdapterCircuitOpenError extends Error {
-    readonly name = "AdapterCircuitOpenError";
-    readonly code: "ADAPTER_CIRCUIT_OPEN";
-    readonly reason: "circuit_open";
-    readonly adapterKey: string;
-    readonly state: AdapterCircuitState;
-    /** The attempt number that was refused (1 = refused before any call). */
-    readonly attempt: number;
-    readonly retryAfterMs?: number;
-    readonly manualOverride?: AdapterCircuitBreakerManualOverride;
-    /** Error of the previous attempt, when the breaker opened mid-retry. */
-    readonly lastError?: string;
-    constructor(input: {
-        adapterKey: string;
-        state: AdapterCircuitState;
-        attempt: number;
-        retryAfterMs?: number;
-        manualOverride?: AdapterCircuitBreakerManualOverride;
-        lastError?: string;
-    });
+export declare class AdapterCircuitOpenError extends Error {
+  readonly name = "AdapterCircuitOpenError";
+  readonly code: "ADAPTER_CIRCUIT_OPEN";
+  readonly reason: "circuit_open";
+  readonly adapterKey: string;
+  readonly state: AdapterCircuitState;
+  /** The attempt number that was refused (1 = refused before any call). */
+  readonly attempt: number;
+  readonly retryAfterMs?: number;
+  readonly manualOverride?: AdapterCircuitBreakerManualOverride;
+  /** Error of the previous attempt, when the breaker opened mid-retry. */
+  readonly lastError?: string;
+  constructor(input: {
+    adapterKey: string;
+    state: AdapterCircuitState;
+    attempt: number;
+    retryAfterMs?: number;
+    manualOverride?: AdapterCircuitBreakerManualOverride;
+    lastError?: string;
+  });
 }
 /**
  * Recognise an {@link AdapterCircuitOpenError}, including one constructed by a
  * second copy of this package (for example an ESM and a CommonJS build loaded
  * side by side), where `instanceof` fails.
  */
-declare function isAdapterCircuitOpenError(error: unknown): error is AdapterCircuitOpenError;
-
-interface AdapterExecutionContext {
-    tenantId: string;
-    spaceId: string;
-    actionInvocationId: string;
-    adapterInvocationId: string;
-    correlationId: string;
-    causationId?: string;
-    attempt: number;
-    maxAttempts: number;
-    /** Epoch-millis deadline after which the adapter should abandon the call. */
-    deadlineMs?: number;
-    /** Set by the host when the invocation has been cancelled; adapters should stop work. */
-    cancelled?: boolean;
-    /** Non-secret reason the invocation was cancelled. */
-    cancellationReason?: string;
-    /**
-     * AbortSignal the host aborts when the deadline expires or the invocation is
-     * cancelled. Adapters should propagate this to underlying HTTP/database
-     * clients so in-flight work is abandoned rather than left dangling.
-     */
-    signal?: AbortSignal;
+export declare function isAdapterCircuitOpenError(error: unknown): error is AdapterCircuitOpenError;
+//#endregion
+//#region adapters/index.d.ts
+export interface AdapterExecutionContext {
+  tenantId: string;
+  spaceId: string;
+  actionInvocationId: string;
+  adapterInvocationId: string;
+  correlationId: string;
+  causationId?: string;
+  attempt: number;
+  maxAttempts: number;
+  /** Epoch-millis deadline after which the adapter should abandon the call. */
+  deadlineMs?: number;
+  /** Set by the host when the invocation has been cancelled; adapters should stop work. */
+  cancelled?: boolean;
+  /** Non-secret reason the invocation was cancelled. */
+  cancellationReason?: string;
+  /**
+   * AbortSignal the host aborts when the deadline expires or the invocation is
+   * cancelled. Adapters should propagate this to underlying HTTP/database
+   * clients so in-flight work is abandoned rather than left dangling.
+   */
+  signal?: AbortSignal;
 }
 /**
  * Additive classification of an adapter outcome so the retry layer can
@@ -392,20 +394,20 @@ interface AdapterExecutionContext {
  * layer treats a non-success result as `transient_failure` for backward
  * compatibility.
  */
-type AdapterOutcomeKind = "success" | "transient_failure" | "permanent_failure" | "timeout" | "ambiguous";
+export type AdapterOutcomeKind = "success" | "transient_failure" | "permanent_failure" | "timeout" | "ambiguous";
 /**
  * Durable, non-secret evidence attached to a classified adapter outcome.
  * Used by the host to record reconciliation evidence when an adapter returns
  * an ambiguous result whose external effect may or may not have been applied.
  */
-interface AdapterOutcomeEvidence {
-    kind: AdapterOutcomeKind;
-    reason?: string;
-    /** Opaque, non-secret reference to external operation state for reconciliation. */
-    externalReference?: string;
-    /** Whether the external effect may have been applied (true for ambiguous/timeout). */
-    effectMayHaveApplied?: boolean;
-    observedAt: Date | string;
+export interface AdapterOutcomeEvidence {
+  kind: AdapterOutcomeKind;
+  reason?: string;
+  /** Opaque, non-secret reference to external operation state for reconciliation. */
+  externalReference?: string;
+  /** Whether the external effect may have been applied (true for ambiguous/timeout). */
+  effectMayHaveApplied?: boolean;
+  observedAt: Date | string;
 }
 /**
  * An adapter handed the work to an external system that will finish it later.
@@ -415,45 +417,45 @@ interface AdapterOutcomeEvidence {
  * in someone else's hands. The host keeps the invocation running and expects a
  * completion carrying this reference through its completion ingress.
  */
-interface AcceptedExternalOperation {
-    /** Opaque, non-secret reference the external system will complete by. */
-    externalReference: string;
-    /** When the external system said it expects to finish, if it said. */
-    expectedBy?: Date | string;
+export interface AcceptedExternalOperation {
+  /** Opaque, non-secret reference the external system will complete by. */
+  externalReference: string;
+  /** When the external system said it expects to finish, if it said. */
+  expectedBy?: Date | string;
 }
-interface AdapterExecutionResult {
-    success: boolean;
-    correlationId?: string;
-    error?: string;
-    /** Additive outcome classification. Omitted = infer from `success`. */
-    outcome?: AdapterOutcomeKind;
-    /** Durable evidence for ambiguous or timeout outcomes requiring reconciliation. */
-    outcomeEvidence?: AdapterOutcomeEvidence;
-    /** Present when a successful call handed the work off to finish elsewhere. */
-    acceptedExternalOperation?: AcceptedExternalOperation;
+export interface AdapterExecutionResult {
+  success: boolean;
+  correlationId?: string;
+  error?: string;
+  /** Additive outcome classification. Omitted = infer from `success`. */
+  outcome?: AdapterOutcomeKind;
+  /** Durable evidence for ambiguous or timeout outcomes requiring reconciliation. */
+  outcomeEvidence?: AdapterOutcomeEvidence;
+  /** Present when a successful call handed the work off to finish elsewhere. */
+  acceptedExternalOperation?: AcceptedExternalOperation;
 }
-type AdapterExecutor = (input: Record<string, unknown>, context: AdapterExecutionContext) => Promise<AdapterExecutionResult>;
-interface AdapterRetryPolicy {
-    /** External calls must explicitly opt into retry by being idempotent. */
-    idempotent: boolean;
-    /** Total attempts including the first call. Non-idempotent policies are forced to 1. */
-    maxAttempts?: number;
-    /** First backoff delay in milliseconds. */
-    initialDelayMs?: number;
-    /** Exponential multiplier applied after each failed attempt. */
-    backoffMultiplier?: number;
-    /** Upper bound for any single retry delay in milliseconds. */
-    maxDelayMs?: number;
+export type AdapterExecutor = (input: Record<string, unknown>, context: AdapterExecutionContext) => Promise<AdapterExecutionResult>;
+export interface AdapterRetryPolicy {
+  /** External calls must explicitly opt into retry by being idempotent. */
+  idempotent: boolean;
+  /** Total attempts including the first call. Non-idempotent policies are forced to 1. */
+  maxAttempts?: number;
+  /** First backoff delay in milliseconds. */
+  initialDelayMs?: number;
+  /** Exponential multiplier applied after each failed attempt. */
+  backoffMultiplier?: number;
+  /** Upper bound for any single retry delay in milliseconds. */
+  maxDelayMs?: number;
 }
-interface ResolvedAdapterRetryPolicy {
-    idempotent: boolean;
-    maxAttempts: number;
-    initialDelayMs: number;
-    backoffMultiplier: number;
-    maxDelayMs: number;
+export interface ResolvedAdapterRetryPolicy {
+  idempotent: boolean;
+  maxAttempts: number;
+  initialDelayMs: number;
+  backoffMultiplier: number;
+  maxDelayMs: number;
 }
 /** Manual circuit-breaker override: pin the breaker open or closed. */
-type AdapterCircuitBreakerManualOverride = "force_open" | "force_closed";
+export type AdapterCircuitBreakerManualOverride = "force_open" | "force_closed";
 /**
  * Per-adapter circuit-breaker configuration, read by
  * {@link AdapterCircuitBreakerRegistry} (and so by Platform Host) to create one
@@ -461,113 +463,113 @@ type AdapterCircuitBreakerManualOverride = "force_open" | "force_closed";
  * `adapterType:operation`; configurable through the registry `key` option).
  * Validated by {@link assertAdapterCircuitBreakerConfig}.
  */
-interface AdapterCircuitBreakerConfig {
-    /**
-     * `monitor` records outcomes, runs the state machine and reports what it
-     * would have refused, but never blocks a call. `enforce` refuses calls
-     * while the breaker is open, without attempting them.
-     */
-    mode: "monitor" | "enforce";
-    /**
-     * A failure count. Let `M = minimumSamples ?? failureThreshold`. Once at
-     * least `M` outcomes fall within `windowMs`, the breaker opens when the most
-     * recent `failureThreshold` of them are all failures, or when the failure
-     * ratio in the window reaches `failureThreshold / M`. Without
-     * `minimumSamples` this is "`failureThreshold` consecutive failures".
-     * Matches the .NET port's `InMemoryAdapterCircuitBreaker`. Positive integer.
-     */
-    failureThreshold: number;
-    /** Rolling window, in milliseconds, of outcomes the thresholds consider. */
-    windowMs: number;
-    /** Milliseconds an open breaker waits before admitting one half-open probe. */
-    cooldownMs: number;
-    /** Outcomes required in the window before the breaker can open. Defaults to `failureThreshold`. */
-    minimumSamples?: number;
-    /**
-     * How long, in milliseconds, the single half-open probe holds its slot
-     * before it is presumed lost and another call may probe. Defaults to
-     * `max(cooldownMs, windowMs)`; it is independent of `cooldownMs`, so a zero
-     * or short cooldown never admits concurrent probes. Positive.
-     */
-    probeLeaseMs?: number;
-    /**
-     * Optional initial manual override. `force_open` reports `open` (and blocks
-     * only in `enforce` mode); `force_closed` reports `closed` and never blocks.
-     * Change it at runtime with `InMemoryAdapterCircuitBreaker.setManualOverride`.
-     */
-    manualOverride?: AdapterCircuitBreakerManualOverride;
+export interface AdapterCircuitBreakerConfig {
+  /**
+   * `monitor` records outcomes, runs the state machine and reports what it
+   * would have refused, but never blocks a call. `enforce` refuses calls
+   * while the breaker is open, without attempting them.
+   */
+  mode: "monitor" | "enforce";
+  /**
+   * A failure count. Let `M = minimumSamples ?? failureThreshold`. Once at
+   * least `M` outcomes fall within `windowMs`, the breaker opens when the most
+   * recent `failureThreshold` of them are all failures, or when the failure
+   * ratio in the window reaches `failureThreshold / M`. Without
+   * `minimumSamples` this is "`failureThreshold` consecutive failures".
+   * Matches the .NET port's `InMemoryAdapterCircuitBreaker`. Positive integer.
+   */
+  failureThreshold: number;
+  /** Rolling window, in milliseconds, of outcomes the thresholds consider. */
+  windowMs: number;
+  /** Milliseconds an open breaker waits before admitting one half-open probe. */
+  cooldownMs: number;
+  /** Outcomes required in the window before the breaker can open. Defaults to `failureThreshold`. */
+  minimumSamples?: number;
+  /**
+   * How long, in milliseconds, the single half-open probe holds its slot
+   * before it is presumed lost and another call may probe. Defaults to
+   * `max(cooldownMs, windowMs)`; it is independent of `cooldownMs`, so a zero
+   * or short cooldown never admits concurrent probes. Positive.
+   */
+  probeLeaseMs?: number;
+  /**
+   * Optional initial manual override. `force_open` reports `open` (and blocks
+   * only in `enforce` mode); `force_closed` reports `closed` and never blocks.
+   * Change it at runtime with `InMemoryAdapterCircuitBreaker.setManualOverride`.
+   */
+  manualOverride?: AdapterCircuitBreakerManualOverride;
 }
-interface AdapterImplementation {
-    adapterType: string;
-    operation: string;
-    vendor: string;
-    /** Whether this adapter operation can be safely retried by default. */
-    idempotent: boolean;
-    retryPolicy?: AdapterRetryPolicy;
-    /** Defaults to monitor-only; enforce mode must be explicitly configured. */
-    circuitBreaker?: AdapterCircuitBreakerConfig;
-    execute: AdapterExecutor;
+export interface AdapterImplementation {
+  adapterType: string;
+  operation: string;
+  vendor: string;
+  /** Whether this adapter operation can be safely retried by default. */
+  idempotent: boolean;
+  retryPolicy?: AdapterRetryPolicy;
+  /** Defaults to monitor-only; enforce mode must be explicitly configured. */
+  circuitBreaker?: AdapterCircuitBreakerConfig;
+  execute: AdapterExecutor;
 }
-interface AdapterAttempt<T> {
-    attempt: number;
-    result?: T;
-    error?: string;
-    willRetry: boolean;
-    nextDelayMs?: number;
+export interface AdapterAttempt<T> {
+  attempt: number;
+  result?: T;
+  error?: string;
+  willRetry: boolean;
+  nextDelayMs?: number;
 }
-interface ExecuteWithRetryOptions<T> {
-    policy?: AdapterRetryPolicy;
-    defaultIdempotent: boolean;
-    execute: (attempt: number, maxAttempts: number) => Promise<T>;
-    isSuccessful: (result: T) => boolean;
-    getError: (result: T) => string | undefined;
-    /**
-     * Optional outcome classifier. When provided, the retry layer retries only
-     * `transient_failure` outcomes (and only when the policy is idempotent).
-     * `permanent_failure`, `timeout`, and `ambiguous` outcomes are never retried.
-     * When omitted, all non-success results are treated as transient (backward compatible).
-     */
-    classifyOutcome?: (result: T) => AdapterOutcomeKind;
-    /**
-     * Optional classifier for errors thrown by the execute callback (not returned
-     * as results). When provided, the retry layer retries only `transient_failure`
-     * classifications. When omitted, thrown errors are never retried — the caller
-     * must explicitly opt into retrying a thrown failure by classifying it.
-     */
-    classifyThrownError?: (error: unknown) => AdapterOutcomeKind;
-    sleep?: (delayMs: number) => Promise<void>;
-    onAttempt?: (attempt: AdapterAttempt<T>) => Promise<void> | void;
-    /**
-     * Optional per-attempt preparation, awaited before the circuit breaker is
-     * consulted and before `execute` (for example, persisting the attempt
-     * number). Put every await a caller needs before the call here, so that
-     * nothing awaits between breaker admission and the external call. If it
-     * throws, no admission is taken and no breaker outcome is recorded; the
-     * error is classified with `classifyThrownError` and retried or rethrown
-     * exactly like an error thrown by `execute`.
-     */
-    prepareAttempt?: (attempt: number, maxAttempts: number) => Promise<void> | void;
-    /**
-     * Optional circuit breaker. When present, `acquire()` is called
-     * immediately before every `execute` call, with no await in between, and every attempt's outcome is
-     * recorded through {@link classifyCircuitBreakerOutcome}. In `enforce` mode
-     * a refused attempt is not executed and {@link AdapterCircuitOpenError} is
-     * thrown; if the breaker opens between attempts, retrying stops and the
-     * same error is thrown. When omitted, behaviour is unchanged.
-     */
-    circuitBreaker?: AdapterCircuitBreaker;
+export interface ExecuteWithRetryOptions<T> {
+  policy?: AdapterRetryPolicy;
+  defaultIdempotent: boolean;
+  execute: (attempt: number, maxAttempts: number) => Promise<T>;
+  isSuccessful: (result: T) => boolean;
+  getError: (result: T) => string | undefined;
+  /**
+   * Optional outcome classifier. When provided, the retry layer retries only
+   * `transient_failure` outcomes (and only when the policy is idempotent).
+   * `permanent_failure`, `timeout`, and `ambiguous` outcomes are never retried.
+   * When omitted, all non-success results are treated as transient (backward compatible).
+   */
+  classifyOutcome?: (result: T) => AdapterOutcomeKind;
+  /**
+   * Optional classifier for errors thrown by the execute callback (not returned
+   * as results). When provided, the retry layer retries only `transient_failure`
+   * classifications. When omitted, thrown errors are never retried — the caller
+   * must explicitly opt into retrying a thrown failure by classifying it.
+   */
+  classifyThrownError?: (error: unknown) => AdapterOutcomeKind;
+  sleep?: (delayMs: number) => Promise<void>;
+  onAttempt?: (attempt: AdapterAttempt<T>) => Promise<void> | void;
+  /**
+   * Optional per-attempt preparation, awaited before the circuit breaker is
+   * consulted and before `execute` (for example, persisting the attempt
+   * number). Put every await a caller needs before the call here, so that
+   * nothing awaits between breaker admission and the external call. If it
+   * throws, no admission is taken and no breaker outcome is recorded; the
+   * error is classified with `classifyThrownError` and retried or rethrown
+   * exactly like an error thrown by `execute`.
+   */
+  prepareAttempt?: (attempt: number, maxAttempts: number) => Promise<void> | void;
+  /**
+   * Optional circuit breaker. When present, `acquire()` is called
+   * immediately before every `execute` call, with no await in between, and every attempt's outcome is
+   * recorded through {@link classifyCircuitBreakerOutcome}. In `enforce` mode
+   * a refused attempt is not executed and {@link AdapterCircuitOpenError} is
+   * thrown; if the breaker opens between attempts, retrying stops and the
+   * same error is thrown. When omitted, behaviour is unchanged.
+   */
+  circuitBreaker?: AdapterCircuitBreaker;
 }
-declare class MissingAdapterRegistrationError extends Error {
-    constructor(adapterType: string, operation: string);
+export declare class MissingAdapterRegistrationError extends Error {
+  constructor(adapterType: string, operation: string);
 }
-declare class AdapterRegistry {
-    private readonly adapters;
-    register(adapter: AdapterImplementation): void;
-    resolve(adapterType: string, operation: string): AdapterImplementation | undefined;
-    require(adapterType: string, operation: string): AdapterImplementation;
+export declare class AdapterRegistry {
+  private readonly adapters;
+  register(adapter: AdapterImplementation): void;
+  resolve(adapterType: string, operation: string): AdapterImplementation | undefined;
+  require(adapterType: string, operation: string): AdapterImplementation;
 }
-declare function resolveAdapterRetryPolicy(policy: AdapterRetryPolicy | undefined, defaultIdempotent: boolean): ResolvedAdapterRetryPolicy;
-declare function getRetryDelayMs(attempt: number, policy: ResolvedAdapterRetryPolicy): number;
+export declare function resolveAdapterRetryPolicy(policy: AdapterRetryPolicy | undefined, defaultIdempotent: boolean): ResolvedAdapterRetryPolicy;
+export declare function getRetryDelayMs(attempt: number, policy: ResolvedAdapterRetryPolicy): number;
 /**
  * Classify an {@link AdapterExecutionResult} into an {@link AdapterOutcomeKind}.
  * When `outcome` is explicitly set, it is returned directly, after rejecting a
@@ -575,20 +577,20 @@ declare function getRetryDelayMs(attempt: number, policy: ResolvedAdapterRetryPo
  * Otherwise a successful result maps to `success` and a failed result maps to
  * `transient_failure` (the historical default).
  */
-declare function classifyAdapterOutcome(result: AdapterExecutionResult): AdapterOutcomeKind;
+export declare function classifyAdapterOutcome(result: AdapterExecutionResult): AdapterOutcomeKind;
 /**
  * Determine whether an outcome kind is retryable. Only `transient_failure`
  * is retryable, and only when the adapter policy is idempotent. Permanent
  * failures, timeouts, and ambiguous outcomes are never retried.
  */
-declare function shouldRetryAdapterOutcome(kind: AdapterOutcomeKind, idempotent: boolean): boolean;
+export declare function shouldRetryAdapterOutcome(kind: AdapterOutcomeKind, idempotent: boolean): boolean;
 /**
  * Reject a contradictory adapter result where `success` is true but the
  * explicit `outcome` is a non-success kind. A successful result claiming an
  * ambiguous, permanent, timeout, or transient outcome is a programming
  * error — the adapter cannot have both succeeded and require reconciliation.
  */
-declare function assertAdapterOutcomeConsistency(result: AdapterExecutionResult): void;
-declare function executeWithAdapterRetry<T>(options: ExecuteWithRetryOptions<T>): Promise<T>;
-
-export { type AcceptedExternalOperation, type AdapterAttempt, type AdapterCircuitAdmission, type AdapterCircuitBreaker, type AdapterCircuitBreakerConfig, type AdapterCircuitBreakerEvent, type AdapterCircuitBreakerEventListener, type AdapterCircuitBreakerEventReason, type AdapterCircuitBreakerManualOverride, type AdapterCircuitBreakerProvider, AdapterCircuitBreakerRegistry, type AdapterCircuitBreakerRegistryOptions, type AdapterCircuitBreakerScope, AdapterCircuitOpenError, type AdapterCircuitOutcome, type AdapterCircuitState, type AdapterExecutionContext, type AdapterExecutionResult, type AdapterExecutor, type AdapterImplementation, type AdapterOutcomeEvidence, type AdapterOutcomeKind, AdapterRegistry, type AdapterRetryPolicy, type ExecuteWithRetryOptions, InMemoryAdapterCircuitBreaker, type InMemoryAdapterCircuitBreakerOptions, MissingAdapterRegistrationError, type ResolvedAdapterRetryPolicy, assertAdapterCircuitBreakerConfig, assertAdapterOutcomeConsistency, classifyAdapterOutcome, classifyCircuitBreakerOutcome, executeWithAdapterRetry, getRetryDelayMs, isAdapterCircuitOpenError, resolveAdapterRetryPolicy, scopedAdapterCircuitBreakerKey, shouldRetryAdapterOutcome };
+export declare function assertAdapterOutcomeConsistency(result: AdapterExecutionResult): void;
+export declare function executeWithAdapterRetry<T>(options: ExecuteWithRetryOptions<T>): Promise<T>;
+//#endregion
+export {};